Vladislav Krilev

Reasons for Half-life cult following

2025-12-18T15:10:35.380Z

NOTES:

Механическая драма:

За эмоциональные перепады игрока отвечают геймплейные механики
Изменения темпа и типа механик в зависимости от ситуаций

Распознание игрока и плотность опыта

Если игрок делает что-то, игра должна это распознать. Игрок стреляет в стену - в ней остаются следы от пуль. Игрок заходит в комнату, на него оборачиваются персы.
С игроком должны происходить события, количество которых должно быть пропорционально размеру карты.

Качественный экшен

Niagara UE

2025-08-28T15:19:10.262Z

Important notes:

Mesh Reproduction Sprites modules

These modules requires the Skeletal Mesh settings :

Allow CPUAccess -> true

UE5.4

Sub UV settings in the Sprite Renderer module:

Sub image size means number of columns in X and rows in Y.

UE5.4

Camera Offset emitter module:

Module is used to set the depth for rendered layers. It fixes that bug the sprite clips through the mesh.

UE5.4

FDG

Cinematics production UE5

2025-08-26T16:48:23.764Z

Sequencer:

CTRL + drag&drop the animation ending -> slow the animation

Can be used for fade-in / fade-out camera effects

OCIO - OpenСolorIO

Plugin for exporting to DaVinci for color grading

UE5.4

Movie Render Queue

Plugin for advanced render settings

Movie Render Queue Additional Render Passes

Plugin for render passes settings

Groom error

2025-08-19T15:36:12.034Z

Hair spiking

Fix:

Lack of rougness

Fix:

Scatter Scene Lighting -> True

Reflection system

2025-06-12T18:54:00.350Z

Title: "The Hidden Life of UObjects: From SCS to GC"

Description: At the heart of Unreal Engine lies a powerful but often misunderstood system: UObject. This article takes a deep dive into how the reflection system works under the hood — from GENERATED_BODY() macros to FProperty and metadata — and how these systems enable Blueprints, serialization, and editor tools. We’ll also explore how Unreal’s custom Garbage Collection ties into the UObject model, and how understanding these internals can help you debug smarter, write safer systems, and even build your own advanced tools on top of the engine. We’ll briefly touch on how SCS (Simple Construction Script) fits into this system as a bridge between editable Blueprint data and runtime component instancing.

Target Audience: Programmers

Level: Intermediate

Takeaways:

* Developing the mechanics used the Reflection system
* Working with Garbage Collector
* Developing Editor tools
* Understanding how UE usess UObjects
* What is a Blueprint class

Topics:

Reflection system

What is Reflection and why UE5 relies on it so heavily

UCLASS, USTRUCT, UPROPERTY, how reflection powers BP integration, serialization, networking. Diagrams of memory layout, FField.

Role of the Unreal Header Tool (UHT) and what happens at compile time

Comparison of reflection in UE vs traditional C++ RTTI or C# reflection

Custom metadata and property reflection at runtime (FindField, GetDefaultObject, etc.)

✅ This is not common knowledge. Even many devs who use macros daily don’t really know what’s going on under the hood.

Garbage Collection

Covering AddToRoot, TWeakObjectPtr, reference chains, MarkPendingKill

What’s "managed" and what’s not in UE’s memory model

UObject lifecycle: New → Referenced → Pending Kill → GC’d

Circular references and memory leaks in blueprints

Bonus: visually demo memory leaks and safe practices in a project.

Components vs SCS_Nodes

The difference between runtime components and editor-only SCS_Nodes, how blueprint compilation handles them, instancing behavior, transform inheritance

✅ Even advanced BP users don’t know the difference clearly. This talk would demystify something that causes bugs in real games.

The people who get invited to speak don’t have to say something no one’s ever heard. They just need to say something most people never fully understood — and explain it clearly, visually, and with passion.

You’re focusing on what the community should know deeply, not just what’s flashy.

Consider adding a short real-world example like:

“This bug once haunted me for weeks... until I realized the difference between a component and an SCS_Node.”

Include 2–3 short stories of real bugs, crashes, or editor issues you solved by deeply understanding these systems.

Accidentally GC-ing a critical object in PIE → solution

(The error we had in the slates (new Editor tool im) with managing UObjects where there is not place for UPROPERTY and for AddReferencedObjects() function. Our solution was TStrongPtr.

What is SCS (SimpleConstructionScript)?

To explain what SCS stands for, we should understand what exactly the Blueprint is. And the answer is: Blueprints are assets, not objects.

Inside of Blueprint

Render with UE5

2025-06-04T16:17:34.971Z

Docs

Demystifying Movie Render Queue

Movie Render Queue (MRQ) pluggin settings

EXR format is a standard formar for rendering

a 16 bit format image what stores much more data
for color grading purposes

Color Output tab:

Disable Tone Curve -> true
It ensures that the rendered image is in linear space and not a baked tone mapped image
for color grading purposes

Console Variables tab:

CVARs used to fix specific issues
Don't use any variable unless you really know what are you doing

Game Overrides tab:

It's used by default under the hood
Maxes out the quality of some console variables

Anti-aliasing tab:

Ask yourself: "Do you want motion blur in your shot or do you want crisp sharp images without motion blur?"
Motion Blur: Temporal Samples

If you have some strange motion blur in physics objects or etc. you can use next fix:

Increase the frame rate of the sequence (f.e. 48 fps instead of 24 fps) and set Motion Blur Amout to 1. It will skip every second frame but will make the motion blur smoother.

Why it works?

By doubling the frame rate you basically reducing the amount of motion blur in half but we bring it back by doubling the motion blur settings value to 1 (instead of 0.5 used by default).

No Motion Blur: Spatial Samples

+ Post Process Volume (PPV) / Camera settings: Set Motion Blur Amount to 0.

Do not mix both Temporal and Spatial, otherwise you will lose out on the benefits of temporal samples

Sample Count works only if the Anti Aliasing Method is set to None, otherwise it'll be controlled by AA method.
Use odd numbers for sample counts. You may not notice the difference but it's recommended way.
There are only 2 reasons to increase the sample count:

To increase the motion blur quality
Anti-aliasing quality

It doesn't affect the noise or flickering

Sample Count 64-128+ is largely unnecessary unless you disabled the denoisers and really need that extra samples.
Sample Count 15-31 is pretty enough in 95-98% of situations!
If you need 1-8 samples, then use TSR (Temporal Super Resolution) method. It will be the fastest way to render.
For Pathtracing it isn't unusual to need 256-1024+ samples depending on your scene.

Noise

It is likely caused by the denoisers which can be disabled
It's likely has more to do with the PPV settings:

Lumen quality and distance fields

Ray Tracing reflection samples
Individual lights also have their own sample count

Common Misconception: Increasing Anti-aliasing Sample Count does not reduce noise/flickering!

Post-production

When rendering to EXR, ensure your video editing software (DaVinci Resolve, Blender, Adobe, ect) has the Color Management/Input Lookup Table set to Linear to sRGB (or Linear to Gamma 2.4 as an alternative) or else your EXR sequence will look dark, over saturated, and not what your viewport looks like.

Tutorials

New Screenshots

Use OCIO settings in case of opening the picture in other softwares. But do not use this settings for next import to DaVinci because DaVinci already have the OCIO settings by default! For DaVinci you have to disable OCIO output but you should enable that for usual picture! Also Disable Tone Curve for DaVinci!

Always use OCIO Viewport settings in UE in case of exporting the image to the DaVinci becasue DaVinci expects that! Otherwise, the picture will be dark i

Lighting

2025-05-27T16:46:50.813Z

Lighting mindset

Source:

Notes:

Light direction
Light size:

The bigger it it, the softer shadows it casts.

Color and intensity

Lumen Settings & Light Sources

Source:

UE Version: 5.5

Lumen Settings:

World Settings:

Force No Precomputed Lighting -> true

Project Settings:

Default RHI -> DirectX 12
Dynamic Global Illumination Method -> Lumen
Reflection Method -> Lumen
Use Hardware Ray Tracing when available -> true

Keep in mind that you need NVIDIA RTX graphic card for hardware ray tracing
If you don't have one, you can still use software ray tracing

Software Ray Tracing Mode -> Detail Tracing
Ray Lighting Mode -> Surface Cache
MegaLights -> true
Shadow Map Method -> Virtual Shadow Maps
Support Hardware Ray Tracing -> true
Texture LOD -> true
Path Tracing -> true
Generate Mesh Distance Fields -> true

Light Sources:

Set Mobility to Movable for all light sources to use Lumen computations.

✨ Directional Light

It acts like a sun in the scene.

Settings:

Source Angle makes the shadows softer
Source Soft Angle influences only the metalic surfaces
Indirect Lighting Intensity with value 0 disables Lumen

✨ Point Light

It emits light in all directions from a single point. Great for adding localized lighting.

Lighting Interiors

Source:

UE Version: 5.3

Lighting and shadow course

Directional light:

Do not use the high values for intensity for non-PBR lighting scenarios.

Light sources:

Disable megalights (UE5.5+)
Volumetric Scattering Intensity

PostProcessVolume:

Skylight Leaking is used for indoor non-PBR lighting.
Screen Traces -> false (Global Illumination settings)
Screen Traces -> true + Final Gather Quality -> high values (Global Illumination settings)
Exposure metering mode -> Manual
Exposure Compensation -> 0.0
Auto Exposure Apply Physical Camera Exposure -> false
Camera Settings in case of PBR
Infinite Extent (Unbound) -> true

Project Settings:

Support Hardware Ray Tracing -> true
Shadow Map Method -> VirtualShadowMaps
Use Hardware Ray Tracing when available -> true
Ray Lighting Mode -> HitLighting for Reflections
Reflection method -> Lumen
Dynamic Global Illumination Method -> Lumen

Fog:

Exponential Height Fog can be used for both exponential and volumetric fogs.
Local Fog Volume enables the local fog only under the light source influence and is controlled by main Exponential Height Fog at the same time.

Console commands:

r.VolumetricFog.InjectRaytracedLights -> 0/1 (default 0)
r.VolumetricFog.GridSizeZ -> 1-1024 (default 512)
r.VolumetricFog.GridPixelSize -> 1-1024 (default 8)

Key points:

Layers for depth
Eye lighting for character lighting
Color grading, color palette preset and color script on preproduction
Key frames and references on preproduction
Detailed lighting scenarious
Interactive lighting for reflection of the actions what are going on the scene
PBR vs non-PBR lighting
Render passes for layers postproduction in Nuke

Bugs:

Bug no. 1

Description: Doubled reflection layers

UE5.4

Fix 1:

Light Source settings: Source Radius -> 0.0

(Works for SpotLight)

Fix 2:

Light Source settings: Cast Ray Traced Shadows -> Disabled

(Works for any source of light)

Final result:

Bug no. 2

Description: Flickering pulsing light

Statue's eyes lights are flickering instead of projecting the static light.

UE5.4

Fix 1:

PostProcessVolume settings: Screen Traces -> false

Rendering notes

2025-04-25T12:38:44.088Z

📝Overview

Sources:

UE Mesh Drawing Pipeline
UE source code
ChatGPT

1. FPrimitiveSceneProxy

UE provide UPrimitiveComponent - a base class for all actor components "that contains or generate some sort of geometry, generally to be rendered or used as collision data". That class is created and managed by the Game Thread.

To be rendered that component create the class FPrimitiveSceneProxy - an Unreal’s render-thread representation of a primitive. It acts as a bridge between the game-thread and the render-thread, storing minimal data needed to render the mesh efficiently.

// copied code from UPrimitiveComponent class UE5.2

/** 
* Creates a proxy to represent the primitive to the scene manager 
* in the rendering thread. 
* @return The proxy object. 
*/

virtual FPrimitiveSceneProxy* CreateSceneProxy()
{    
   return NULL;
}

For every new class derived from the UPrimitiveComponent UE implements a new primitive proxy class derived from FPrimitiveSceneProxy: FSpriteSceneProxy, FSphereSceneProxy, FTextRenderSceneProxy, FParticleSystemSceneProxy, FWidget3DSceneProxy etc.

The same way for creating this objects each new class derived from the UPrimitiveComponent overrides CreateSceneProxy() function.

FPrimitiveSceneProxy is responsible for submitting FMeshBatch's to the renderer through the callbacks to GetDynamicMeshElements() and DrawStaticElements().

2. FMeshBatch

FMeshBatch describes a single draw call to the GPU. It specifies:

Vertex buffers, index buffers
Material/shader references
Render states (depth, stencil, blending)
LOD and mesh pass information

When the rendering pipeline prepares to draw meshes, it assembles them into batches (FMeshBatch) grouped by compatible render states and materials.

One mesh can generate multiple batches:

Multiple materials → multiple batches.
Different rendering passes (shadow, depth pre-pass, base pass) → separate batches.

🔸Simple Example:

Mesh: SM_Rock
- Material: M_Stone → FMeshBatch #1 (Base Pass)
- Shadow Pass → FMeshBatch #2 (Shadow Pass)

FMeshBatch decouples the FPrimitiveSceneProxy implementation (user code) from mesh passes (private renderer module). It contains everything the pass needs to figure out final shader bindings and render state, so the proxy never knows what passes it will be rendered in.

3. Mesh Pass

A Mesh Pass is a step (or "stage") of rendering, each with different goals:

______________________________________________________________________
   Mesh Pass Name   |                   Goal                         
--------------------+-------------------------------------------------
Depth Pre-Pass      |Fill depth buffer early (efficient depth testing
Base Pass           |Main color/material rendering                   
Shadow Pass         |Shadow map generation                           
Translucency Pass   |Draw transparent objects                        
Post-Processing Pass|Effects (lighting, bloom, reflections)          
----------------------------------------------------------------------

Each mesh pass collects and processes specific FMeshBatches.

4. FMeshDrawCommand

The next step is to convert FMeshBatch into a mesh pass specific FMeshDrawCommand .

FMeshDrawCommand is an interface between FMeshBatch and the RHI. It's a fully stateless draw description that stores everything that the RHI needs to know about a mesh draw:

Which shaders to use.
Their resource bindings.
Draw call parameters.

This enables caching and merging the draw calls just above the RHI level. FMeshDrawCommand is created from a FMeshBatch by a mesh pass specific FMeshPassProcessor.

Finally, SubmitMeshDrawCommands() is used to convert FMeshDrawCommand into a series of RHI commands set on a RHICommandList.

5. RHI

RHI is Unreal’s abstraction layer over graphics APIs (DirectX, Vulkan, Metal, etc.):

It standardizes rendering commands across platforms.
Allows Unreal to support multiple graphics APIs without rewriting rendering logic.
Handles buffers, shaders, textures, and GPU communication.

[Game Thread (Component)]
       ↓
[Render Thread (FPrimitiveSceneProxy -> FMeshBatch -> MeshPasses)]
       ↓
[RHI Commands]
       ↓
[Vulkan / DirectX / Metal API calls]
       ↓
[GPU]

6. Under the UE hood

⚙️ What UE5 Does by Default

When you have multiple identical StaticMeshActors:

Rendering pipeline creates a separate FPrimitiveSceneProxy and separate FMeshBatch for each actor/component.
Each separate FMeshBatch typically becomes a separate GPU draw call.
More actors → More draw calls → Higher CPU overhead → Lower frame rate.

UE5 optimizes many things (occlusion culling, frustum culling, Nanite for high-density geometry), but does NOT automatically combine separate actors into batches. Each actor is considered a unique primitive.

🔥 How InstancedStaticMeshComponent (ISM) Optimizes Rendering

When you explicitly group actors into ISMs:

A single FPrimitiveSceneProxy is created for the entire instanced group.
A single (or fewer) FMeshBatch per mesh/material → dramatically reduced draw calls.
GPU efficiently draws multiple instances with only one GPU call, changing transforms internally per-instance.

Docs for new team mates

2024-11-11T14:03:15.232Z

Docs list:

Suggests areas of expertise or knowledge:

Architecture design and patterns
Representation of 3D models data in cpp
Slates
Garbage Collector and Reflection system (with UHT)
Smart pointers in UE
Modules (preprocessor) and subsystems (runtime)
Multithreading

Software architecture patterns

2024-10-30T12:00:37.068Z

Brief:

3 pattern design types
Creational

Factory
Abstract Factory
Builder
Prototype
Singleton

Structural

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

3 pattern design types:

Creational

Purpose: Manage the creation of objects, enhancing flexibility and reuse.

Structural

Purpose: Define how classes and objects are composed to form larger structures.

Behavioral

Purpose: Handle communication between objects, manage algorithms, and responsibility chains.

Creational:

Factory

Defines an interface for creating objects but lets subclasses alter the type of created objects.

Abstract Factory

Provides an interface for creating families of related objects without specifying their concrete classes.

Builder

Constructs a complex object step by step, often used when objects need many optional parameters or different configurations.

Prototype

Creates new objects by copying an existing object, used for cloning and when object creation is expensive.

Singleton

Ensures a class has only one instance and provides a global access point to it.

Such class doesn't have a public constructor but a pulic static getter returned the instance of this class.

Structural

Adapter

Converts an interface of a class into another interface that clients expect, allowing incompatible interfaces to work together.

Bridge

Separates an abstraction from its implementation, so the two can vary independently.

Composite (Tree)

Treats individual objects and compositions of objects uniformly, often used to represent hierarchies (e.g., a file system).

Decorator (Wrapper)

Adds new behavior to objects dynamically without altering their structure, useful for adding features at runtime.

Facade

Provides a simplified interface to a complex subsystem, used to reduce dependency and simplify interactions.

Flyweight (Cache)

Reduces memory usage by sharing common parts of objects, especially useful in systems with large numbers of similar objects.

Bad

Good

Perfect

Proxy

Provides a placeholder for another object to control access, manage permissions, or optimize performance.

With an Adapter, you access an existing object through a different interface.
With an Proxy, the interface remains unchanged.
With Decorator, you access an object through an extended interface.

Vladislav Krilev

Reasons for Half-life cult following

Niagara UE

Important notes:

Cinematics production UE5

Sequencer:

Groom error

Hair spiking

Lack of rougnessFix:

Reflection system

Topics:

What is SCS (SimpleConstructionScript)?

Render with UE5

Docs

Movie Render Queue (MRQ) pluggin settings

Noise

Post-production

Tutorials

New Screenshots

Lighting

Lighting mindset

Lumen Settings & Light Sources

Lumen Settings:

Light Sources:

Lighting Interiors

Lighting and shadow course

Bugs:

Bug no. 1

Bug no. 2

Rendering notes

📝Overview

1. FPrimitiveSceneProxy

2. FMeshBatch

3. Mesh Pass

4. FMeshDrawCommand

5. RHI

6. Under the UE hood

⚙️ What UE5 Does by Default

🔥 How InstancedStaticMeshComponent (ISM) Optimizes Rendering

Docs for new team mates

Docs list:

Suggests areas of expertise or knowledge:

Software architecture patterns

3 pattern design types:

Creational:

Factory

Abstract Factory

Builder

Prototype

Singleton

Structural

Adapter

Bridge

Composite (Tree)

Decorator (Wrapper)

Facade

Flyweight (Cache)

Proxy

Lack of rougness

Fix: