UDN
Search public documentation:
VFXOptimizationResults
日本語訳
中国翻译
한국어
Interested in the Unreal Engine?
Visit the Unreal Technology site.
Looking for jobs and company info?
Check out the Epic games site.
Questions about support via UDN?
Contact the UDN Staff
中国翻译
한국어
Interested in the Unreal Engine?
Visit the Unreal Technology site.
Looking for jobs and company info?
Check out the Epic games site.
Questions about support via UDN?
Contact the UDN Staff
UE3 Home > Particles & Effects > Particles Systems > VFX Optimization in UE3 > VFX Optimization: Getting Results
UE3 Home > FX Artists > VFX Optimization in UE3 > VFX Optimization: Getting Results
UE3 Home > FX Artists > VFX Optimization in UE3 > VFX Optimization: Getting Results
VFX Optimization: Getting Results
- VFX Optimization: Getting Results
- Core Systems in Cascade - GPU/Game Thread/Render Thread
- Overdraw - GPU
- LODs - Level of Detail - GPU/Game Thread
- Draw Calls - Render Thread
- Mesh Emission - Game Thread/Render Thread
- Collisions - Game Thread
- Spawn Per Unit - GPU/Game Thread
- Memory Costs
- Tick Time - Game Thread
- Non Directional Lighting Costs - Game Thread
Core Systems in Cascade - GPU/Game Thread/Render Thread
- Particle simulation times (Tick) are calculated on the Game Thread (gamethread)
- Particle data finalization (Packing Geometry, Draw calls) are calculated on the Render Thread
- Particle visuals (Shader complexity, overdraw) are calculated on the GPU
Overdraw - GPU
Overdraw = Pixel shader cost = Number of layers * avg number of pixels affected by a layer * avg number of instructions for a layerEssentially, when you add a material to the surface of a sprite, that material has a cost in instruction count, which UE3 displays in the content browser and material editor. For translucent objects this instruction cost adds up as translucency stacks up, creating overdraw. The more layers of translucency, the higher the cost. You can easily see this cost in the shader complexity mode. Bright Red = 300 instructions, pink = 600 instructions, and white = 900 instructions. Press F5 to view shader complexity on PC. Shader complexity outputs an approximation of what the cost of a system will be, however it is also dependent upon the scene since translucency is calculated against opaque objects which also have a cost. Checking the usage of your effects is critical. An effect which may be called in any given scenario (weapon impact) will generally need to be lighter than an effect you can custom build to match a specific scenario, since it will be drawn in fluctuating cost scenarios. Some steps that can be taken to get overdraw impact under control are:
- Reduce emission rates
- Reduce material instruction count
- Reduce particle scale (fill less of the screen)
- Create LODs for near/far particle emissions to reduce cost at different view distances
- Check for emitters placed in a line stacking against each other (static placed effects)
LODs - Level of Detail - GPU/Game Thread

LOD Distance Check Time
This feature dictates how often the game checks the distance of the player, to the emitter placed in the scene to determine which LOD to use. LOD Distance Check Time works when the LOD Method is set to automatic. Automatic essentially lets the game determine the LOD as you play. If you increase the LOD Distance Check Time, the amount of time between checks will increase. LOD DistanceCheckTime is calculated in seconds, so consider your player's max movement speed when setting this. If you set LOD Distance Check Time to a value of 0.00 the distance is checked every frame, which may equate to lower performance.LOD Method - Game Thread
Appropriately setting the LOD Method can be vital to performance and visuals. Automatic - the game will set the LOD based on the distance parameters defined in the effect, using the LOD Distance Check Time settings. Typically used on ambient effects which loop and are not called by game code. Direct Set - the LOD is determined (typically by game code) when the effect is spawned and stays at the LOD defined. Typically used in burst effects like explosions or impacts. Activate Automatic - The LOD is defined when the effect is spawned, based upon the distance parameters defined in the LOD. Typically used on burst effects called by kismet etc. which require LODs to never shift once spawned.Fixed vs. Non Fixed Bounds - Game Thread
Bounds are one of the ways in which the engine determines visibility of an effect. These invisible coordinates tell the engine if an effect is in view or out of view. If a corner of your bounds is visible the engine will calculate any components of the effect necessary. Bounds are costly the check and update each frame, therefore it is a good idea to set your bounds to be fixed and determine how large bounds need to be. In some cases you might want your bounds to be rather large if you need to see every piece of debris flying out of an explosion. If you wish to keep costs low, tightening bounds to core components can increase performance, at the risk of effects popping off when the bounds go out of view. There are some considerations for fixed vs. non-fixed bounds to keep in mind. Fast moving effects such as rocket trails, tracers, or anything attached to a projectile etc. should not have fixed bounds set, or have the fixed bounds set so large that the emitter cannot fly outside of the bounds. When setting bounds be aware of local vs. world space coordinates defined in your system. If an emitter is rotated the opposite direction of your bounds orientation, it is possible for elements of the effect to fly out of your bounds and elements popping out of view can occur.Draw Calls - Render Thread
- Particle System A consists of: 1 emitter, spawning 12 sprites, using a material with 1 Pass, the entire system costs 1 draw.
- Particle System B consists of: 1 emitter, spawning 12 sprites, using a material with 2 Passes, the entire system costs 2 draws.
- Particle System C consists of: 1 emitter spawning 12 meshes, using a material with 2 Passes, the entire system costs 24 draws. (2 passes per call * 12 meshes since each mesh is a single draw call = 24 draws)
- Particle System D consists of: 1 emitter spawning 6 meshes, using a material with 2 Passes, and 1 emitter spawning 10 sprites with 1 pass the entire system costs 13 draws. ( 2 passes per call * 6 meshes since each mesh is a single draw call = 12 draws, 1pass * 10 sprites = 1 draw call)
Translucent material = 1 pass base
- +2 for distortion
- +1 for bUseLitTranslucencyDepthPass
- +1 for bUseLitTranslucencyPostRenderDepthPass
- +2 for bUsedWithFogVolumes
DumpParticleFrameRenderingStats
. This command outputs a spreadsheet which lists draw call costs in detail.
Impact from draw calls increases proportionally to the number of views being rendered. This means that in split-screen, the effects are multiplied. See the VFX Optimization: SplitScreen page for more detailed information on optimizing effects for splitscreen.
It is important to keep these costs in mind when constructing your effects, and when optimizing effects. If your render thread is high due to draw calls, and the environment is within budget this is the place to start looking.
Mesh Emission - Game Thread/Render Thread
Collisions - Game Thread
- MaxCollisions: keep this value as low as possible
- Collision Completion Option: set this to HaltCollisions/Freeze to stop doing collision checks against the scene once MaxCollisions is reached.
- The Damping Factor determines the bounce of objects following collision, lower values may result in objects coming to rest faster (lower Max Collisions value.)
Spawn Per Unit - GPU/Game Thread
- Keep the Unit Scalar to a value as high as possible, and balance it with the emission rate to get the fill you need, without making the effect too heavy
- Try and use lower instruction count materials if you know you are going to have high emission rates using Spawn Per Unit
- Adjust the Max Frame Distance to limit how many particles can be emitted. If the emitter goes above this Max Frame Distance Spawn Per Unit will cease emission until it returns below the distance. This prevents the emitter from dumping large amounts of sprites into the scene.
Memory Costs
- Reduce the number of modules in a system to the essential modules required for a given behavior
- For looping effects reduce Loop Time/Duration (allocates fewer particles per loop)
- Reduce Lifetime (fewer particles overall)
- Share as many modules as possible
Tick Time - Game Thread
Non Directional Lighting Costs - Game Thread
- Cost to store a unique color variant of an effect in memory
- Cost to load a unique color variant at run-time
- Cost to create each color variant in Cascade
- Cost to light the effect to match the environment with Non Directional Lighting on the Game Thread