Niagara fire tutorial: rising flames, sparks and smoke
Build fire in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Filter tutorials, troubleshooting and shared fundamentals.
285 articles
Build fire in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build water in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build ice in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build lightning in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build wind in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build earth / rock in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build light in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
Build darkness in UE 5.8 Niagara with asset steps, material diagrams, emitter settings, motion, timing and beginner troubleshooting.
A beginner fire VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner water VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner ice VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner lightning VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner wind VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner earth / rock VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner light VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
A beginner darkness VFX recipe with asset creation, Unity URP setup, starting values, expected results and troubleshooting.
Learn VFX texture, mesh and shader roles, elemental design, and workflows for Photoshop, After Effects, Blender, Unreal Engine and Unity.
Understand VFX color maps, masks, noise and flipbooks, including RGB versus alpha, UVs, color space, resolution and compression.
Choose VFX planes, rings, cones and strips, with UVs, pivots, face orientation and subdivisions matched to the intended motion and silhouette.
Understand VFX shaders versus materials, alpha/additive blending, UV motion, particle color and the different Unity and Unreal workflows.
Design elemental VFX using texture edges, geometry, acceleration and persistence, with practical comparisons for eight elemental themes.
Create a Photoshop grayscale VFX mask, distinguish RGB from alpha, check tiling and export PNGs with a clear import contract.
Build looping Fractal Noise, export 16 PNG frames and arrange a 4×4 VFX flipbook, checking alpha, duplicate endpoints and cell borders.
Model a 16-segment ring in Blender 4.5 LTS, project its UVs and check face direction, pivot, scale and FBX import into your game engine.
Build a legacy UE 5.6 unlit translucent VFX material using an R mask, tint, opacity, Panner and Material Instances.
Build a Unity 2022.3 URP 14 Unlit Shader Graph with an R mask, tint, alpha and scrolling UVs, then check particle-color integration.
Diagnose missing Unity 3D trigger events through collider/body pairing, layers, ignored pairs, callback placement and physics simulation.
Resolve uGUI size and position resets by tracing Layout Groups, Content Size Fitter, size inputs and separate layout Slots from animated Visuals.
Diagnose late or missing Animator transitions through parameters, Exit Time, all Conditions, blend duration, competing transitions and update state.
Trace Renderer.material copies, sharedMaterial edits, PropertyBlock scope and owned cleanup; verify Material counts and SRP Batcher performance separately.
Diagnose paused UI and waits using deltaTime, unscaledDeltaTime, WaitForSecondsRealtime and Animator settings, with explicit pause and resume ownership.
Trace blurry Unity textures through source pixels, platform Max Size, Quality mip limits, Streaming, filters, UVs and output resolution.
Trace unresponsive uGUI buttons through the EventSystem, input module, GraphicRaycaster, transparent panels, CanvasGroup settings and On Click.
Diagnose missing URP Bloom by checking emission output, HDR buffers, Camera post-processing, Volume application, Threshold and Intensity.
Compare Local, World and Custom Particle System simulation with one Burst, then inspect Trails, Inherit Velocity and old particles during pooled reuse.
Trace Quality overrides and the Graphics default, log the selected URP asset, then check Renderer and Camera settings when changes have no effect.
Check normal-map import, single decoding in Shader Graph, green-channel conventions, and mesh tangents and UVs when detail looks inverted or shading breaks.
Separate ReadPixels GPU waits from PNG encoding and file writes. Check async support, bound requests, manage data lifetime and verify in the target Player.
IL2CPP ExecutionEngineException: check AOT code and stripping. Missing AOT implementations and stripped reflection targets are separate problems. IL2CPP support
Optimize Unity URP rendering with the SRP Batcher. Check compatibility, shader variants and Frame Debugger batches, then measure CPU rendering cost.
Diagnose stalls during asynchronous scene transitions. Async loading can still incur activation, object lifecycle, asset cleanup, and GC work on the main thread
Measure and reduce allocations from LINQ and lambdas. LINQ iterators, result collections, sorting, delegates, and captures can add allocations or CPU work. Not
Measure and consolidate many Update callbacks. Large numbers of MonoBehaviour callbacks add native-to-managed overhead and repeated work. Profile first to decid
Reuse cells in large ScrollRect lists. Creating every ScrollRect cell increases memory, layout, and update work; layout cost is not necessarily exponential.
Reduce uGUI GraphicRaycaster CPU cost. Many UI raycast candidates can increase CPU cost. Inspect candidates, raycasters, input-module behavior, and blocking set
Cancellation and object lifetime with async/await and UniTask. Accessing a destroyed object after await can fail. Cancellation is cooperative: the awaited opera
Check URP pass timing and input buffers. A missing renderer feature can involve renderer selection, camera type, layer/queue/pass filters, input availability, a
Object pooling: lifecycle and memory considerations. Repeated creation/destruction costs initialization, native work, and managed allocations. Pooling reduces t
Edit and save prefab assets from Editor tools. Editing a prefab asset differs from recording an instance override. Confusing the targets can lose changes.
Diagnose blurry UI with URP render scale. UI drawn into a downscaled camera target becomes blurry when that target is enlarged. UI resolution depends on its ren
Check URP decal distortion, projection, and visibility. A decal projector affects compatible surfaces in its volume. Excess depth, projection angle, or unsuppor
Check model and shadow artifacts during LOD cross-fades. LOD cross-fading requires support in both LOD Group and the shader. Check the installed URP/Shader Grap
Fix transparent shadow issues in Unity URP Shader Graph: separate receiving from casting, check Lit and renderer settings, and choose a shadow proxy.
Adjust shadow bias for acne and detached shadows. Shadow acne involves self-shadow depth error; jagged outlines often involve shadow texel density. Increasing b
Diagnose black output, UI, and XR issues in Full Screen Pass. A fullscreen effect needs a valid color copy and appropriate injection timing. An unsafe custom pa
Fix Unity 2D sprite jitter by checking Pixel Perfect Camera, PPU, integer scaling, Rigidbody2D interpolation and Cinemachine camera timing.
Check missing or flickering lights in URP Forward+. Forward+ still has platform-dependent visible-light limits. A universal 32-lights-per-tile limit is not an a
Persist ScriptableObject edits in Editor tools. Editor changes to ScriptableObject assets need suitable undo/dirty/save handling. Runtime changes in a build do
Reconstruct normals after vertex displacement. Moving vertices does not automatically deform their normals or tangents. Reconstruct them in a consistent space u
Check MSAA in URP camera stacks. Overlay cameras share stack targets. It is not a general rule that MSAA always resolves after the Base camera and disables it f
Check Custom Function and SRP Batcher compatibility. Shader Graph generates its material constant buffer. Redeclaring UnityPerMaterial or duplicating graph prop
Investigate VFX Graph memory use and OOM. VFX memory depends on capacity, stored attributes, auxiliary buffers, sorting, and concurrent instances. Attribute siz
Restore values and release resources in PlayableBehaviour. A custom playable can leave its last value behind when evaluation stops. Residual state is distinct f
Diagnose dark or overbright RenderTexture previews. Separate texture format/sRGB conversion from exposure, tonemapping, and display shader differences. RawImage
Check shadow distance when distant URP shadows disappear. Realtime shadows stop at configured distance limits. Cascades mainly distribute directional-shadow pre
URP particle transparency and material settings. Check shader compatibility, surface type, blending, and sorting separately. Depth writes are usually off for tr
Diagnose first-play particle spikes in Timeline. First-play spikes may involve GPU program preparation, asset loading/creation, particle pre-simulation, or play
Check URP depth texture generation and conversion. Depth effects need the correct generation setting, camera override, sampling time, and depth-writing objects.
Check URP decals that fail to project onto a target. Check the decal feature, projector volume, compatible receiver shader, and rendering technique. A Receive D
Particle scaling modes and parent transforms. Scaling Mode determines how transform scale affects particles; it differs from Simulation Space.
Check transparent Particle System sorting. Typical transparents test depth without writing it and blend back to front. Renderer-level sorting cannot fully resol
Check bounds when VFX Graph disappears with camera motion. If VFX bounds do not enclose the effect, visible particles can be culled when the bounds leave the fr
Check VFX Graph events that do not spawn particles. Event names, graph wiring, spawn behavior, capacity, and bounds determine whether particles appear. Events d
Diagnose HLSL compilation errors in Custom Function nodes. Custom Function File and String modes use different function-definition conventions. Check precision
Diagnose dark transparent edges in RenderTexture UI. Dark fringes occur when premultiplied colors are displayed with straight-alpha blending, multiplying alpha
Check shaders that fail in one eye with single-pass instancing. One-eye artifacts can arise from missing stereo information or incorrect screen-texture sampling
Fix Unity URP SRP Batcher incompatibility by checking UnityPerMaterial, shader passes and MaterialPropertyBlock, then verify the affected draw.
Measure post-processing cost on mobile and Quest. Bloom and depth of field can add intermediate/fullscreen work, but not every effect, such as vignette, creates
Pass particle and mesh vertex colors to shaders. Particle color and source-mesh vertex color are distinct data. Match the Color stream with shader input and mul
Reduce Particle System noise CPU cost. Noise adds simulation work depending on particle count, quality, and octaves. Separate simulation cost from rendering cos
Soft particles: fade intersections using consistent depths. Soft particles fade from the gap between scene and particle depth in the same linear space. Raw scre
Check RenderTexture color conversion, HDR, and output paths. Separate texture format/sRGB conversion from exposure, tonemapping, and display shader differences.
Diagnose missing objects in custom URP passes. A missing renderer feature can involve renderer selection, camera type, layer/queue/pass filters, input availabil
Tune peripheral quality with fixed foveation on Quest. FFR reduces peripheral shading density and can expose artifacts at aggressive levels. Its fixed center is
Check player build errors from UnityEditor references. Gizmos belongs to UnityEngine, unlike UnityEditor.Handles. Editor Scene and Game views can display gizmos
Check screen-space camera UI and 3D ordering. Canvas hierarchy, renderer sorting, and depth tests are separate mechanisms. CanvasGroup has no Sorting Order, and
Update VFX Graph properties from C#. Check exposure, exact property name, type, graph connections, and competing writers. Do not assume Shader Graph display/ref
Manage URP Rendering Debugger availability in builds. Rendering Debugger is a diagnostic feature for the editor and development builds. Do not assume its UI nec
Check post-processing volume blending and transitions. Local volume blending depends on collider distance, blend distance, weight/priority, overrides, and camer
Check textures assigned to VFX Graph. Check exposed texture dimension/type, wiring, UVs, and data color space. Converting every input to Texture2D is not a vali
Shader Graph vertex animation and SRP Batcher. The SRP Batcher reduces CPU work preparing draws. It does not automatically reduce draw count. Vertex animation,
Define RenderTexture ownership and release resources. Check ownership, references, allocation frequency, and cleanup. Destroy is not categorically unable to fre
Check per-eye sampling in XR post-processing. SPI/Multiview can use per-eye texture arrays. Use pipeline-compatible inputs rather than copying Built-in screen m
Distinguish skinned-mesh emission from particle attachment. Particle System can emit directly from a Skinned Mesh Renderer shape. Manually baking a mesh every f
Check Game-view gizmos and runtime debug rendering. Gizmos belongs to UnityEngine, unlike UnityEditor.Handles. Editor Scene and Game views can display gizmos, b
Apply fog to transparent URP particles. For mismatched fog, check shader fog support and blending mode. Background scene depth is not automatically the particle
Multiple materials, submeshes, and the SRP Batcher. The SRP Batcher reduces CPU work preparing draws. It does not automatically reduce draw count. Vertex animat
Diagnose position and pose drift in Timeline loops. Separate root motion, track offsets, clip loop continuity, and competing transform writers. Enabling Apply R
Diagnose audio and visual timing in Timeline. Timeline and audio clock differences can affect synchronization during pauses or time-scale changes. DSP Clock doe
Set post-playback state in Timeline activation tracks. Activation Track uses its Post-playback state to define activation after stopping. Changing director Wrap
Prevent reimport loops in AssetPostprocessor. Repeated reimport requests inside import callbacks can restart refresh loops. Changes must converge rather than co
Release EditorWindow resources across close and reload. Editor-created textures/materials have native resources. Clearing a reference does not replace their des
Fix UnityEditor reference errors after adding asmdefs. Assembly boundaries need explicit Editor separation and the correct dependency direction. An Editor folde
Check transparent VFX sorting and renderer order. Transparent particle order depends on output sorting and blending. VFX Graph does not universally disable sort
Check supported GPU collision inputs in VFX Graph. GPU VFX collision does not automatically share every CPU physics collider. Check the selected collision block
Spawn child VFX systems through GPU events. Particle System Sub Emitters and VFX Graph GPU-event child systems are different workflows. VFX needs the appropriat
Check custom interpolator types, spaces, and interpolation. A custom interpolator carries interpolated vertex values to fragments. Space mismatches and varying
Check triplanar coordinates, scale, and blending. Triplanar blends three projections using the normal. Increasing Blend sharpens the dominant projection; values
Check view and normal spaces for Fresnel in VR. Some left/right rim differences are normal parallax. The standard Fresnel node is not inherently VR-incompatible
Check mixed-light shadow overlap and leakage. Check baked data, light modes, receivers, and mixed-lighting shader logic. There is no general requirement to add
Check device support for VFX strip outputs. Separate API/package/device support from strip capacity and attributes. A specific GPU synchronization defect requir
Check URP stencil passes, shared targets, and ordering. Stencil failures can involve pass support, ordering, references/masks, or target sharing. URP does not u
Check repeated Timeline signal dispatch. Duplicate signals can come from multiple emitters, receivers/directors, loops, seeks, or retroactive settings. Low FPS
Isolate Quest multiview, fixed foveation, and peripheral artifacts. FFR reduces peripheral shading density and can expose artifacts at aggressive levels. Its fi
SRP Batcher reduces CPU preparation cost for draws using the same shader variant.
Sorting Fudge biases a particle renderer against other systems. Smaller values tend to draw it in front.
FFR shades a fixed central region more densely than peripheral regions.
A depth texture exposes camera-view depth per pixel.
Q&A: pink URP materials and shader errors. Magenta indicates an unusable shader. Pipeline mismatch, compile errors, unsupported APIs, and missing variants are p
Q&A: disappearing VFX and bounds. If VFX bounds do not enclose the effect, visible particles can be culled when the bounds leave the frustum. The culling volume
Q&A: release RenderTextures and prevent leaks. Check ownership, references, allocation frequency, and cleanup. Destroy is not categorically unable to free GPU r
Control Particle System playback and seeking in Timeline. Activation tracks toggle active state. Timeline-controlled particle simulation requires a control trac
Render Queue. Render Queue assigns shader/material rendering groups and ordering. The pipeline then sorts within groups such as Geometry or Transparent.
GPU instancing draws compatible objects sharing geometry/material with per-instance transforms and attributes.
Variable Rate Shading (VRS). Variable rate shading changes shading frequency across regions and can reduce GPU work by evaluating some areas more coarsely.
Custom Function calls HLSL from Shader Graph. String mode takes a body, while File mode references a function with matching ports and precision.
Prewarm advances a looping particle system to an established state before presentation.
Frustum Culling. Frustum culling excludes renderers outside the camera view, generally using their bounds.
Mipmap. Mipmaps are progressively smaller images used during texture minification to reduce aliasing and sampling cost.
Scriptable Renderer Feature. A Scriptable Renderer Feature extends a URP renderer with custom rendering work, enabled on its Renderer Data.
HLSL describes GPU programs such as shaders; Unity translates/compiles it for target platforms.
Billboards orient a plane toward the camera or another chosen direction, useful for particles and distant objects.
Deferred shading records surface properties in a G-buffer before evaluating lighting.
Forward+ selects relevant lights per screen region or cluster before forward shading.
A rendering pipeline organizes culling, shadows, draws, and post-processing. Built-in, URP, and HDRP have different APIs and features.
ZTest compares fragment depth with stored depth using a selected comparison function.
ZWrite stores depth for use by later depth tests.
Stencil Buffer. A stencil buffer stores per-pixel integer values for masking through writes and comparisons.
Overdraw (overdraw / duplicate drawing). Overdraw repeatedly processes overlapping surfaces at the same pixels, particularly costly for transparency.
Anisotropic filtering improves texture sampling on oblique surfaces, such as roads or floors.
Color Space. Color space describes how values represent brightness. A linear workflow decodes color textures for lighting calculations.
LOD selects geometry detail according to visibility size or another policy; Unity LOD Group uses relative screen size.
Occlusion culling skips hidden renderers; Unity baked occlusion uses suitable occluder/occludee configuration.
Post-processing applies effects such as bloom and grading to rendered images using a supported volume/camera setup.
A render texture is a GPU rendering target used by cameras and intermediate passes.
A draw call asks the GPU to render geometry; materials, submeshes, and passes can increase counts.
Batching processes compatible objects with shared rendering work.
Simulation Space. Simulation space controls the coordinate system of particle state; local particles follow the system transform, while world particles retain w
A vector field assigns directions or velocities across space and can drive particle motion.
Particle lifetime sets lifespan; age/lifetime drive changes and expiration.
Emission rate controls spawning per time or distance; distinguish the corresponding modes.
Bursts spawn groups at selected times with supported count, repetition, and probability controls.
GPU particles update state such as positions, velocities, and lifetimes on the GPU.
A point cache stores sampled points and attributes for uses such as VFX particle placement.
A sub-emitter spawns child effects from parent-particle events.
Particle collision detects contact and can bounce, stop, or kill particles.
A noise field evaluates spatial/temporal noise to influence particle motion.
Render mode selects particle geometry such as billboards, stretched billboards, or meshes.
A ribbon renders a strip joining a sequence of points.
Trails connect position history using systems such as TrailRenderer or particle trails.
Inherit Velocity transfers emitter motion to particles; inspect supported initial/current modes.
Soft Particles. Soft particles fade intersections using the gap between particle and scene depth.
A vertex shader computes positions and attributes per vertex, including transforms and deformation.
A fragment shader evaluates rasterized fragments for color, lighting, and related outputs.
Fresnel describes angle-dependent reflectance. The graph node provides an approximate angular weight useful for rims.
Normal maps encode surface-normal detail without adding geometry.
UV Coordinates. UVs are two-dimensional texture coordinates obtained from mesh data or calculations.
PBR models light/material interaction using physically motivated parameters such as metallic and roughness.
Alpha clipping keeps or discards fragments according to a threshold, useful for cutout foliage.
Vertex color stores color or mask values per vertex.
Triplanar Projection. Triplanar mapping blends three axis projections weighted by surface normals.
Shader variants are programs for keyword combinations, trading feature selection against build/runtime preparation cost.
Single-pass instanced stereo shares some work while shaders handle per-eye information.
XR multipass renders each eye separately; distinguish it from shaders with multiple general rendering passes.
Graphics memory holds textures, meshes, targets, and other GPU resources.
Fillrate concerns pixel/fragment throughput, limited by shading, blending, bandwidth, resolution, and hardware.
Draw-call batching groups compatible rendering work through approaches with different restrictions.
The profiler measures runtime work and memory using CPU timelines, GPU modules, and other views.
Frame rate counts frames per second; 60 FPS corresponds to roughly 16.7 ms per frame. Inspect slow frames too.
A bottleneck is the stage limiting progress; compare CPU, GPU, I/O, and other work to choose a target.
LOD Group switches renderers according to relative screen size.
Shader compilation translates source for target APIs; keyword and rendering paths affect program counts.
Static batching combines static geometry to reduce rendering overhead.
Dynamic batching combines suitable small meshes using CPU work, subject to vertex-attribute and shader restrictions.
A command buffer records GPU work such as rendering and copies.
A G-buffer stores surface attributes for deferred lighting.
A depth buffer stores depth for visibility testing through ZTest/ZWrite.
A framebuffer groups rendering attachments such as color/depth for screen or intermediate targets.
A shadow map stores light-view depth for comparison with receiver depth to estimate visibility.
Shadow cascades divide directional shadows by camera distance to allocate precision near the viewer.
A shadowmask stores baked occlusion for mixed lights.
A lightmap stores precomputed illumination for mainly static surfaces.
Light probes store baked lighting at spatial samples for interpolation onto moving objects.
A reflection probe captures surrounding cubemap data for material reflections using supported baked/realtime modes.
A skybox renders the scene background and can supply environment lighting/reflection inputs.
HDR rendering preserves values outside the usual 0–1 range using suitable formats.
Bloom extracts/spreads bright contributions and composites a glow.
ACES is a color-management system; Unity offers an ACES-inspired tonemapping transform.
Tonemapping maps broad scene intensities into an output range with an appropriate transform and exposure.
Vignette adjusts image edges, commonly darkening them.
Chromatic aberration simulates color fringing from wavelength-dependent lens refraction.
Depth of field blurs out-of-focus areas using controls available in the selected mode.
Motion blur smears movement, with camera/object support depending on pipeline.
Ambient occlusion approximates reduced ambient light near geometry using baked or screen-space methods.
Screen-space Reflections (SSR). Screen-space reflections approximate reflections from visible color/depth data.
TAA combines current/history samples, commonly using motion vectors and jitter in supported implementations.
MSAA smooths polygon coverage using multiple samples.
FXAA smooths detected edges in the rendered image and can have low overhead.
SMAA analyzes edge patterns to blend appropriate samples in supported camera settings.
Render scale multiplies target dimensions; 0.5 halves each dimension and gives about one-quarter as many pixels.
Dynamic resolution changes rendering resolution at runtime.
A compute shader runs parallel GPU work through dispatched thread groups, independent of ordinary draw passes.
StructuredBuffer exposes structured elements to shaders; supported RW forms allow writes.
Custom Interpolator. A custom interpolator transfers vertex-calculated values to graph fragment processing.
Parallax mapping offsets texture coordinates according to height and viewing direction.
Detail maps add fine color/normal information through compatible material features.
Emission adds a material self-emissive contribution and can feed bloom or supported GI.
Smoothness controls reflection-lobe width, generally making reflections sharper at higher values.
Metallic describes conductor versus dielectric behavior in a metallic PBR workflow.
An occlusion map masks occlusion, typically reducing supported indirect-light contributions.
Tessellation (polygon subdivision). Tessellation subdivides geometry through supported GPU stages.
A geometry shader can emit primitives from input primitives.
Backface culling excludes triangles facing away from the view.
Blend mode specifies how source and destination colors combine, including alpha and additive formulations.
Additive blending adds color contributions for luminous effects.
Multiplicative blending multiplies destination color by source color, for example with DstColor Zero.
Straight alpha blending weights source by alpha and destination by one minus alpha.
A render pass is a rendering stage with defined inputs, outputs, and placement in compatible URP APIs.
GPU-driven rendering moves some preparation/culling work to the GPU.
Ray tracing computes effects such as reflections/shadows using ray–geometry intersections.
Shader Graph builds shader calculations from nodes for a selected pipeline/target.
Instanced drawing renders common geometry with multiple transforms/attributes.
Deferred lighting names techniques that separate surface and later lighting work; distinguish it from a specific deferred-shading implementation.
Forward rendering evaluates lighting while shading objects.
Tile-based deferred techniques organize deferred work by screen tiles and can select relevant lights per tile.
Clustered rendering partitions view space in XY and depth to select relevant lights.
GPU skinning computes bone-driven deformation through a supported GPU rendering path.
CPU skinning computes bone-driven vertex deformation on the CPU.
Root motion applies animation-derived root translation/rotation to an object.
A blend tree mixes motions according to animator parameters and configured thresholds/blend type.
An animator controller organizes states, transitions, parameters, and layers.
A Timeline control playable manages supported systems such as particles/directors on its source object.
Addressables (Addressable Asset System). Addressables locates/loads resources through catalogs and manages referenced operations/handles.
An asset bundle packages built Unity assets for runtime delivery/loading with platform and dependency management.
A sprite atlas packs multiple sprite images into shared textures.
Mipmap bias adjusts selected levels; negative values generally favor detail, positive values coarser levels.
Texture streaming manages mip residency according to demand and memory budgets.
Virtual texturing maps required tiles of large virtual textures into physical storage.
An occlusion query asks the GPU about visibility to guide later work.
Early-Z can reject occluded fragments before expensive shading.
Stencil Test. A stencil test compares stored values with references/masks and can update values through configured operations.
Color grading adjusts exposure, contrast, and color treatment through compatible controls or LUTs.
A LUT maps input values to outputs; grading LUTs encode color transforms.
White balance compensates illumination color casts using supported temperature/tint controls.
Shadow distance limits realtime shadow range, configured on the active asset/path.
Contact shadows approximate fine shadowing near contact regions.
Micro shadowing approximates fine-scale surface masking from suitable material information.
Ray-traced shadows use ray intersections to evaluate occlusion.
HBAO estimates ambient occlusion from screen-space horizon information.
Dithering distributes values into patterns to reduce visible quantization or transitions.
A flow map encodes directions used to animate texture coordinates or other flow effects.
Color temperature expresses illuminant color using a blackbody-based model; lower Kelvin appears warmer, higher cooler.
Diagnose light leakage through thin URP walls. Light leaks can involve bias, resolution, one-sided geometry, shadow casters, or baked GI. One bias value does no
Investigate long shader builds and variant counts. Keyword combinations increase shader variants. Long compilation is not automatically a freeze or infinite loo
Check particle renderer order and internal sorting. Typical transparents test depth without writing it and blend back to front. Renderer-level sorting cannot fu
Reduce uGUI canvas rebuild and layout cost. UI changes can dirty individual graphics and trigger canvas batch rebuilds. Not every change necessarily regenerates
Check Android ASTC support, fallback, and memory. Unsupported ASTC can fall back to uncompressed textures and increase memory usage. Unsupported compression doe
Investigate asmdef dependencies and repeated compilation. Separate a slow compilation, a reference error, and compilation repeatedly restarting. Circular asmdef
Release Addressables handles and instances correctly. Addressables uses reference counts. Unbalanced loads/releases retain resources, but reaching zero does not
Tune fixed foveation when Quest peripheral quality degrades. FFR reduces peripheral shading density and can expose artifacts at aggressive levels. Its fixed cen
Check CCD, geometry, and movement for fast rigidbodies. Discrete detection can miss thin obstacles between physics steps. Direct transform movement and collider
Check initial poses and camera jumps at Timeline start. T-poses can involve bindings, unevaluated starting poses, avatars, or animation culling. Cinemachine fol
Check Scene Color refraction and transparent capture timing. URP Scene Color samples the opaque texture captured before transparents. Moving a transparent objec
Check missing TMP glyphs and dynamic atlas capacity. Distinguish missing source-font glyphs from a full dynamic atlas. Adding an automatic atlas-clearing event
Check NavMeshAgent jitter and competing movement systems. Agents, dynamic rigidbodies, and root motion can compete for one transform. Navigation geometry and Ph
Separate I/O, decompression, and creation stalls in Addressables. LZMA uses whole-stream decompression while LZ4 permits chunk-based reads. Async APIs can still
Investigate WebGL out-of-memory errors and retained assets. Separate Wasm heap pressure, asset expansion, GPU memory, and browser limits. An old fixed WebGL Mem
Identify closure and delegate allocations. A lambda capturing an outer local can allocate captured-state storage and a delegate. Distinguish this from noncaptur
Smooth procedural edges with ddx, ddy, and fwidth. Hard thresholds or fixed UV smoothing widths can mismatch pixel size. Derivatives estimate local screen-space
Reduce UI overdraw coverage and GPU time. Layered UI can increase GPU work, but zero-alpha graphics are not always drawn; transparent-mesh culling and CanvasGro
Check mobile VFX Graph support and fallback effects. VFX Graph requires supported compute/graphics features and package-specific APIs. supportsComputeShaders or
Static values and events survive Play sessions: diagnosis and reset. Disabling domain reload preserves static state across sessions; explicit reset and unsubscr
Learn how to distinguish GC allocations from collection work and investigate frame spikes in Unity.
Understand height-dependent fog and why configuration differs between Unity render pipelines.
Investigate thermal throttling with sustained device measurements and workload adjustments.
Try another keyword, category, or engine.