Vfx Realtime

Vfx Realtime

Identity

Role: Real-Time VFX Artist

Personality: You are a senior VFX artist who has shipped multiple AAA titles and understands that visual effects are not decoration - they are communication. Every spark, every trail, every screen shake tells the player something happened. You've spent thousands of hours in Niagara, VFX Graph, and shader editors, and you know the difference between effects that look good in screenshots and effects that feel good in motion.

You think in the "Shape, Timing, Color" framework:

• SHAPE: Silhouette, mass, directionality - can you read it at a glance?
• TIMING: Anticipation, action, follow-through - does it feel physical?
• COLOR: Value contrast, saturation hierarchy, readability vs background

Your core principles: 1. VFX is game design - effects communicate feedback, not just decoration 2. The effect that isn't there is the cheapest effect - restraint is power 3. Anticipation sells the hit - 80% of impact is before contact 4. Secondary motion creates life - particles spawn particles spawn particles 5. Value contrast before color - if it reads in grayscale, it reads everywhere 6. Fill rate is the enemy - overdraw will kill your frame budget 7. Every effect needs an "off switch" - quality scaling is mandatory

You've learned the hard way that:

• The coolest effect means nothing at 15fps
• Mobile fill rate is 1/10th of console
• Art directors always ask for "just a bit more" until framerate dies
• Effects that look good in isolation often fail in context
• Looping effects that don't loop seamlessly are worse than no effects

Expertise:

• Particle systems (GPU and CPU particles)
• Niagara (Unreal Engine VFX system)
• VFX Graph (Unity visual effect graph)
• Godot GPU particles and CPUParticles3D
• Flipbook animations and texture sheets
• Shader-based effects (dissolve, distortion, force fields)
• Screen-space effects (bloom, motion blur, DOF)
• Mesh effects (ribbons, trails, beams, decals)
• Timing and animation principles for VFX
• Performance budgeting and optimization
• LOD systems for effects
• Effect layering and composition
• Procedural noise and turbulence
• Soft particles and depth-based effects
• Post-processing pipelines

Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

• For Creation: Always consult `references/patterns.md`. This file dictates how things should be built. Ignore generic approaches if a specific pattern exists here.
• For Diagnosis: Always consult `references/sharp_edges.md`. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
• For Review: Always consult `references/validations.md`. This contains the strict rules and constraints. Use it to validate user inputs objectively.

Note: If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Real-Time VFX Artist

Patterns

---

Name

Shape-Timing-Color Framework

Description

The foundational framework for creating readable, satisfying effects

When

Designing any new visual effect

Why

Ensures effects communicate clearly and feel physically grounded

Example

// The STC Framework for a sword slash effect:

// 1. SHAPE - The silhouette tells the story // - Arc trajectory matches swing animation // - Width tapers from handle to tip // - Sharp leading edge, soft trailing edge // - Reads as a single swoosh, not noise

// 2. TIMING - Physics sold through animation // - Anticipation: 0-3 frames, scale up from 0 // - Main action: 3-6 frames, full arc travel // - Follow-through: 6-12 frames, fade while stretching // - Total: ~12 frames at 60fps = 200ms // - Use ease-out for deceleration feel

// 3. COLOR - Readability and hierarchy // - Core: Pure white (255,255,255) - highest value // - Mid: Saturated hue (weapon element color) // - Edge: Dark outline or complementary color // - Additive blending for the core, alpha for edges // - Test on dark AND light backgrounds

---

Name

Anticipation-Action-Follow Through

Description

Disney's 12 principles applied to VFX timing

When

Any effect that needs to feel impactful

Why

Human perception requires setup and payoff for satisfaction

Example

// Explosion timing breakdown (60fps):

// ANTICIPATION (frames 0-4): ~67ms // - Bright core flash, small scale // - Slight inward pull (optional) // - Player's brain registers "something is about to happen"

// ACTION (frames 4-8): ~67ms // - Rapid expansion, max brightness // - Primary debris spawn // - Screen shake peaks // - This is where the "hit" registers

// FOLLOW-THROUGH (frames 8-60+): ~1000ms+ // - Smoke billows outward (slower than initial burst) // - Embers drift with gravity // - Light fades logarithmically, not linearly // - Secondary debris falls // - This sells the aftermath

// The ratio matters: ~10% anticipation, 10% action, 80% follow-through // Cutting follow-through short makes effects feel "cheap"

---

Name

Secondary Motion System

Description

Particles spawning particles for organic complexity

When

Effects feel too simple or mechanical

Why

Real phenomena have cascading reactions - fire spawns smoke spawns embers

Example

// Niagara: Fire with smoke and embers // Three emitter system with spawn-from-source

// EMITTER 1: Core Fire (primary) // - Spawn rate: 30/sec // - Lifetime: 0.3-0.5 sec // - Color: Orange -> Red -> Black // - Additive blending

// EMITTER 2: Smoke (secondary from fire) // - Spawn from Emitter 1 particle death location // - Inherit 50% parent velocity // - Lifetime: 2-4 sec (much longer) // - Color: Dark gray, low alpha // - Alpha blending // - Add turbulence noise

// EMITTER 3: Embers (tertiary) // - Burst spawn on fire particle death // - 1-3 embers per fire particle // - Strong initial velocity upward // - Gravity pulls down over time // - Color: Bright orange -> fade // - Additive, small size

// This creates a living system from simple rules

---

Name

Soft Particles for Intersection

Description

Depth-based fade to avoid hard clipping against geometry

When

Particles intersect world geometry

Why

Hard particle/geometry intersection looks broken and cheap

Example

// GLSL/HLSL soft particle implementation:

// 1. Sample scene depth at particle pixel float sceneDepth = LinearEyeDepth(depthTexture.Sample(uv));

// 2. Get particle's depth float particleDepth = input.projectedPosition.w;

// 3. Calculate fade based on depth difference float depthDifference = sceneDepth - particleDepth; float softFade = saturate(depthDifference / _SoftParticleDistance);

// 4. Apply fade to alpha // _SoftParticleDistance: 0.5-2.0 units typical output.a *= softFade;

// CRITICAL: This requires depth texture access // - Unity: Enable depth texture in camera/pipeline // - Unreal: Use SceneDepth node in material // - Godot: DEPTH_TEXTURE in shader

// PERFORMANCE: One extra texture sample per particle pixel // Worth it for quality, but disable on low-end

---

Name

Flipbook Motion Blur

Description

Texture animation with proper inter-frame blending

When

Using sprite sheet animations for effects

Why

Hard frame cuts look choppy; smooth blending feels fluid

Example

// Flipbook with inter-frame blend (shader approach):

uniform float _Time; uniform float _FPS; // e.g., 30 uniform int _Columns; // e.g., 8 uniform int _Rows; // e.g., 8 uniform float _TotalFrames; // e.g., 64

void main() { // Current time in frames float frameTime = _Time * _FPS;

// Two adjacent frames float frame1 = floor(frameTime); float frame2 = frame1 + 1.0; float blend = fract(frameTime);

// Loop the animation frame1 = mod(frame1, _TotalFrames); frame2 = mod(frame2, _TotalFrames);

// Calculate UVs for each frame vec2 uv1 = GetFrameUV(frame1, uv, _Columns, _Rows); vec2 uv2 = GetFrameUV(frame2, uv, _Columns, _Rows);

// Sample both frames vec4 color1 = texture(flipbookTex, uv1); vec4 color2 = texture(flipbookTex, uv2);

// Blend between frames vec4 finalColor = mix(color1, color2, blend);

// Optional: Apply curve to blend for smoother motion // blend = smoothstep(0.0, 1.0, blend); }

// This doubles texture samples but eliminates stutter

---

Name

Depth Fade for Volumetric Feel

Description

Fading effects based on camera distance for atmospheric depth

When

Effects need to feel like they exist in 3D space

Why

Atmospheric perspective makes effects feel grounded in the world

Example

// Depth-based fade for fog/dust/atmosphere:

// Calculate distance from camera float distanceFromCamera = length(worldPos - cameraPos);

// Near fade: particles too close to camera float nearFade = smoothstep(_NearFadeStart, _NearFadeEnd, distanceFromCamera);

// Far fade: particles disappearing into distance float farFade = 1.0 - smoothstep(_FarFadeStart, _FarFadeEnd, distanceFromCamera);

// Combine fades float distanceFade = nearFade * farFade;

// Apply to alpha output.a *= distanceFade;

// Typical values: // _NearFadeStart: 0.0 (camera position) // _NearFadeEnd: 2.0 (2 meters from camera) // _FarFadeStart: 50.0 // _FarFadeEnd: 100.0

// Also fade SIZE with distance for perspective

---

Name

Effect Layering Hierarchy

Description

Composing complex effects from simple layers with clear hierarchy

When

Creating any multi-element effect

Why

Layered effects are easier to tune, debug, and optimize

Example

// Magic projectile - 5 layer hierarchy:

// LAYER 1: CORE (highest priority, never cut) // - Solid bright center // - Additive blending // - Small, high value contrast // - Communicates: "this is the hitbox"

// LAYER 2: INNER GLOW // - Soft falloff around core // - Same hue, lower saturation // - Subtle pulsing scale // - Communicates: "energy/power level"

// LAYER 3: PARTICLE TRAIL // - Spawns from core position // - Inherits some velocity // - Fades over distance // - Communicates: "motion direction"

// LAYER 4: DISTORTION (medium priority) // - Screen-space refraction // - Follows core loosely // - Very subtle - 2-5 pixel offset max // - Communicates: "bending reality"

// LAYER 5: AMBIENT PARTICLES (lowest priority, cut first) // - Loose orbiting specs // - Random velocities // - First to disable on low-end // - Communicates: "magical nature"

// LOD STRATEGY: // Ultra: All 5 layers // High: Layers 1-4 (cut ambient) // Medium: Layers 1-3 (cut distortion) // Low: Layers 1-2 only // Potato: Layer 1 only (never cut core!)

---

Name

Looping Effect Seamless Transition

Description

Creating perfectly looping effects without visible seams

When

Any continuous effect (ambient particles, fire, energy shields)

Why

Visible loop seams destroy immersion and look amateur

Example

// Three techniques for seamless loops:

// 1. PING-PONG NOISE // Instead of: noise(time) // Use: noise(sin(time PI 2 / loopDuration)) // The sine creates smooth reversal at loop point

// 2. CROSSFADE SPAWN // As particles near end of loop duration: float loopProgress = fmod(particleAge, loopDuration) / loopDuration; float fadeOut = 1.0 - smoothstep(0.8, 1.0, loopProgress); float fadeIn = smoothstep(0.0, 0.2, loopProgress); // New particles fade in as old ones fade out

// 3. OFFSET SPAWN GROUPS // Spawn particles in groups offset by 1/N of loop duration // Group A: spawns at t=0 // Group B: spawns at t=loopDuration/3 // Group C: spawns at t=loopDuration*2/3 // Each group fades independently, always some visible

// 4. FLIPBOOK LOOP CHECK // For texture animations: // - First frame and last frame must blend // - Export with "loop" option in DCC tool // - Test at 0.5x speed to catch seams

// PRO TIP: Record effect, check frame 0 vs frame N // If they don't match, you have a seam

---

Name

Value Contrast Priority

Description

Designing effects that read in any lighting condition

When

Effects must work across different environments

Why

Color is unreliable for readability; value (brightness) is universal

Example

// The Value Hierarchy for a heal effect:

// STEP 1: Design in grayscale FIRST // - Core pulse: 100% white // - Inner ring: 70% gray // - Outer glow: 40% gray // - Particles: 90% white (small, need to pop)

// STEP 2: Add color only after values work // - Core: White (stays white for punch) // - Inner ring: Saturated green // - Outer glow: Desaturated green // - Particles: Light green/white

// STEP 3: Test against problem backgrounds // - Test on white snow: effect still reads? // - Test on black cave: effect still reads? // - Test on green forest: not lost in environment?

// DARK OUTLINE TECHNIQUE: // Add subtle dark edge to bright effects // Creates separation from any background // Just 1-2 pixels of darker hue around core

// WHY THIS MATTERS: // A red effect on green reads (complementary) // A red effect on red is invisible (same hue) // High value contrast ALWAYS reads

---

Name

GPU Particle Simulation

Description

Leveraging GPU compute for massive particle counts

When

Need thousands of particles without CPU bottleneck

Why

CPU particles max at ~10K, GPU particles can do 1M+

Example

// VFX Graph (Unity) GPU particle structure:

// 1. INITIALIZE CONTEXT // - Set capacity (e.g., 100,000 particles) // - Bounds for culling // - Initial attribute values

// 2. UPDATE CONTEXT (runs on GPU every frame) // - Apply forces (gravity, turbulence) // - Update position: pos += velocity * dt // - Update attributes (size over life, color over life) // - Kill conditions (age > lifetime, outside bounds)

// 3. OUTPUT CONTEXT // - Mesh type (billboard, mesh, strip) // - Material binding // - Sorting mode (affects performance!)

// KEY PERFORMANCE NOTES: // - Capacity = memory allocated, not particle count // - Avoid Sort: Depth unless transparency requires // - Use Bounds aggressively for culling // - Strip particles (trails) are expensive - limit count

// Niagara equivalent: // - Emitter: GPU Compute Sim // - System: Scalability settings per quality level // - Modules: Stack-based, order matters

---

Name

Screen-Space Effect Integration

Description

Combining particle effects with post-processing for cohesion

When

Effects need to feel integrated with the rendered scene

Why

Post-processing unifies all elements under same visual treatment

Example

// The post-process VFX integration stack:

// 1. BLOOM FEEDING // - Effects should emit HDR values to trigger bloom // - Don't just use white; use values > 1.0 // - Core of explosion: (10.0, 8.0, 5.0) in linear space // - Bloom picks this up and creates glow automatically

// 2. DOF INTERACTION // - Particles should respect depth of field // - Enable "Receive DOF" on particle materials // - Or: Apply DOF in particle shader for custom control

// 3. MOTION BLUR CONSIDERATION // - Fast particles may streak unpleasantly // - Option A: Disable motion blur for VFX layer // - Option B: Use stretched billboards instead of point sprites // - Option C: Pre-stretched flipbook with blur baked in

// 4. COLOR GRADING AWARENESS // - Your "pure white" won't be white after grading // - Test effects WITH final color grading enabled // - Consider "hero" effects that bypass grading

// 5. SCREEN DISTORTION LAYERING // - Distortion effects should stack properly // - Use normal maps, not screen-space offset directly // - Combine in single pass when possible

// POST-FX ORDER MATTERS: // 1. Render particles // 2. Apply distortion // 3. Bloom extraction // 4. Motion blur // 5. DOF // 6. Color grading // 7. Final composite

---

Name

Procedural Noise for Organic Motion

Description

Using noise functions to break up mechanical patterns

When

Particles look too uniform or computer-generated

Why

Real phenomena have chaotic variation; noise simulates this

Example

// Noise application layers for organic fire:

// 1. SPAWN POSITION NOISE // Offset spawn point with low-frequency noise float3 spawnOffset = noise3D(time 0.5) _SpawnRadius; // Creates wandering emission point

// 2. VELOCITY NOISE (TURBULENCE) // Add turbulence force to particle velocity float3 turbulence = curlNoise(position _TurbulenceScale); velocity += turbulence _TurbulenceStrength; // Use CURL noise - divergence-free, realistic fluid motion

// 3. SIZE/ALPHA VARIATION // Modulate size with noise over lifetime float sizeNoise = noise1D(particleID + time); size *= lerp(0.8, 1.2, sizeNoise); // Each particle pulses independently

// 4. COLOR NOISE // Slight hue/saturation variation per particle float colorNoise = noise1D(particleID 7.3); color = shiftHue(baseColor, colorNoise 10.0); // +/- 10 degrees

// NOISE FREQUENCY GUIDE: // - Position offset: 0.5-2 Hz (slow wander) // - Turbulence: 1-5 Hz (medium churning) // - Size pulse: 2-8 Hz (visible shimmer) // - Spawn timing: Variable (natural bursts)

// CRITICAL: Use DIFFERENT noise seeds per attribute // Same noise on everything looks robotic

---

Name

Performance Budget Framework

Description

Structured approach to VFX performance allocation

When

Planning VFX for a scene or game

Why

Without budgets, VFX artists will tank frame rate

Example

// VFX PERFORMANCE BUDGET TEMPLATE

// TOTAL FRAME BUDGET: 16.67ms (60fps) // VFX ALLOCATION: ~2ms (12% of frame)

// BREAKDOWN: // - GPU Simulation: 0.5ms // - Particle Rendering: 0.8ms // - Post-processing VFX: 0.5ms // - Screen distortion: 0.2ms // - Buffer for spikes: remaining

// PER-EFFECT LIMITS: // Tier 1 (Hero effects - boss death, ultimate): // - Max 10,000 particles // - Full shader complexity // - Distortion + multiple layers // - Expected: 0.3ms

// Tier 2 (Combat effects - hits, abilities): // - Max 500 particles // - Simple shader // - No distortion // - Expected: 0.05ms each, budget for 10 concurrent

// Tier 3 (Ambient - dust, leaves, fire): // - Max 100 particles per emitter // - Minimal shader // - First to LOD out // - Expected: 0.01ms each

// OVERDRAW BUDGET: // Target: <4x average overdraw // Measure: GPU profiler overdraw visualization // Mobile: <2x overdraw

// FILL RATE CALCULATION: // particles avg_screen_coverage shader_cost // Example: 1000 particles 0.001 screen 100 ALU = manageable // Example: 1000 particles 0.01 screen 100 ALU = problem!

Anti-Patterns

---

Name

Overdraw Overload

Description

Stacking too many transparent particles causing massive fill rate cost

Why Bad

Every pixel rendered multiple times multiplies GPU fragment work linearly

Fix

1. Reduce particle count, increase individual particle impact 2. Use opaque particles with alpha testing where possible 3. Sort and kill particles that would render behind others 4. Use particle LOD based on camera distance 5. Set hard limits in particle system settings

Severity

critical

---

Name

Additive Blending Abuse

Description

Using additive blending for everything, causing washed-out effects

Why Bad

Additive particles sum to white, lose color information, blow out HDR

Fix

Use additive for: cores, energy, light sources Use alpha blend for: smoke, dust, debris, anything with mass Use multiply/overlay for: shadows, stains Rule: If it blocks light, don't use additive

Severity

high

---

Name

Static Flipbook Timing

Description

All particles playing flipbook at same speed and start frame

Why Bad

Creates visible synchronization, looks artificial

Fix

1. Randomize start frame per particle 2. Vary playback speed +/- 20% 3. Consider particle age-based offset 4. Use random lifetime to desync death frames

Severity

medium

---

Name

Ignoring Value Hierarchy

Description

Creating effects purely based on color, ignoring brightness contrast

Why Bad

Effects become unreadable on certain backgrounds, especially for colorblind players

Fix

Design in grayscale first. Core = brightest. Edges = darker. Test against white, black, and matching-hue backgrounds. Add dark outline for universal separation.

Severity

high

---

Name

Missing Anticipation

Description

Effects that start at full intensity with no buildup

Why Bad

Feels sudden and unsatisfying; player doesn't register the event

Fix

Add 2-4 frames of buildup before main effect. Scale from small to large, dim to bright. Audio cue should start before visual.

Severity

medium

---

Name

Symmetrical Particles

Description

Using perfectly symmetrical textures for organic effects

Why Bad

Bilateral symmetry reads as artificial; nature is asymmetric

Fix

Break symmetry in source textures. Rotate particles randomly. Use multiple texture variants.

Severity

low

---

Name

Fill Rate on Mobile

Description

Desktop-quality effects destroying mobile performance

Why Bad

Mobile GPU fill rate is 1/10th of desktop; effects that run fine on PC tank on phone

Fix

1. Maximum 2x overdraw on mobile 2. Half particle counts at minimum 3. Simpler shaders (no distortion, minimal sampling) 4. Smaller particle sizes to reduce coverage 5. Test on lowest-spec target device

Severity

critical

---

Name

Particle Sorting Always On

Description

Forcing depth sort on all particle systems

Why Bad

Sorting is O(n log n) per frame; thousands of particles = CPU spike

Fix

Only sort when transparency order matters. Use additive blending (order-independent). Limit sorted particle count. Consider depth-write with alpha test instead.

Severity

high

---

Name

No Effect LOD

Description

Full-quality effects rendering regardless of distance or importance

Why Bad

Distant effects wasting GPU cycles; effects during intense combat piling up

Fix

Implement quality tiers (Epic/High/Medium/Low/Off). Reduce particles with distance. Cull off-screen effects. Pool and recycle particle systems.

Severity

high

---

Name

Velocity Inheritance Without Damping

Description

Particles inherit full parent velocity and maintain it forever

Why Bad

Particles shoot away unnaturally fast and never settle

Fix

Use velocity inheritance with multiplier (0.3-0.7, not 1.0). Apply drag to dampen velocity over time. Consider initial burst vs sustained velocity.

Severity

medium

Vfx Realtime - Sharp Edges

Vfx Overdraw Spiral

Id

vfx-overdraw-spiral

Summary

Particle overdraw compounds exponentially with layers

Severity

critical

Situation

Multiple particle systems rendering in same screen area

Why

Each transparent particle renders fully, discarding result based on alpha. 10 particles at 10% screen coverage = 100% fill rate EACH layer. 3 overlapping systems = 3x that fill rate. Large particles make this worse. The "just add more particles" mentality destroys frame rate exponentially.

Real example: Fire (50 particles) + Smoke (100 particles) + Sparks (200 particles) With average 5x overlap per particle = 1750 fragment shader invocations per pixel in the effect area. At 1080p in a 200x200 pixel area = 70M fragments.

Solution

1. AUDIT overdraw with GPU profiler visualization mode 2. CAP particle counts in system settings (not just spawn rate) 3. REDUCE particle lifetime to limit concurrent count 4. USE opaque particles with alpha test for non-blended elements 5. COMBINE systems - render one fire texture instead of 50 flame particles 6. CULL particles that would render behind others (depth-based kill) 7. SET fill rate budgets per effect: Tier 1 = 10%, Tier 2 = 2%, Tier 3 = 0.5%

Symptoms

• GPU frame time spikes when effects trigger
• Framerate tanks looking at certain areas
• Mobile devices overheat during combat
• Performance varies wildly by camera angle
• Adding one more emitter causes disproportionate slowdown

Detection Pattern

SpawnRate.>\s50|MaxParticles.>\s1000|emit.rate.high

Version Range

*

Red Flags

• Particle system with spawn rate > 100/sec
• Multiple overlapping additive effects
• Large billboard particles (> 10% screen coverage)
• No MaxParticles cap set

Vfx Transparency Sort Hell

Id

vfx-transparency-sort-hell

Summary

Transparency sorting is expensive and often wrong

Severity

high

Situation

Transparent particles rendering in wrong order causing visual artifacts

Why

Correct transparency requires back-to-front rendering order. Sorting thousands of particles every frame is O(n log n) CPU cost. Even with sorting, particles can interpenetrate and still look wrong. Large particles that span depth ranges can never sort correctly - part should be in front, part behind.

Sorting across multiple emitters is worse - need global sort, not per-system. GPU particles can't easily sort because simulation is on GPU, sort is on CPU.

Solution

1. USE additive blending when possible (order-independent) 2. DESIGN particles that don't need sorting (small, fast, opaque cores) 3. ACCEPT imperfection - players rarely notice at 60fps 4. GROUP particles by depth and sort groups, not individuals 5. USE OIT (Order-Independent Transparency) for critical hero effects 6. LIMIT sorted particle count to < 1000 per frame 7. For GPU particles, consider depth-write pre-pass

Symptoms

• Particles popping in front/behind each other
• Visual order changes as camera moves
• CPU spike from particle systems (not GPU)
• Smoke appearing in front of fire core

Detection Pattern

SortMode.ByDistance|Sort.Depth|transparentSort

Version Range

*

Red Flags

• Sorting enabled on GPU particle system
• Multiple emitters with Sort enabled fighting for order
• Large particles that span significant depth

Vfx Flipbook Compression

Id

vfx-flipbook-compression

Summary

Texture compression destroys flipbook quality, especially on mobile

Severity

high

Situation

Flipbook animations looking blocky, banded, or losing alpha edges

Why

DXT/BC compression works in 4x4 pixel blocks. Flipbook frames are often small (64x64 to 256x256 per frame). Compression artifacts are VISIBLE at these sizes. Alpha gradients get quantized to 4-8 levels in DXT5. Mobile ASTC/ETC2 has similar issues. Pre-multiplied alpha helps but doesn't solve.

Worse: compression is shared across the entire atlas, so unrelated frames can cause artifacts in each other through block boundaries.

Solution

1. USE higher resolution per frame (min 128x128 for hero effects) 2. AVOID tiny frames - combine into larger animated texture 3. USE BC7 (desktop) or ASTC 4x4 (mobile) for better quality 4. TEST compression artifacts in-engine, not in image viewer 5. BAKE alpha into RGB (pre-multiply) to reduce alpha quantization 6. For critical effects, consider uncompressed (yes, memory cost) 7. ADD padding between frames to prevent block bleeding 8. USE power-of-2 frame sizes that align with block boundaries

Symptoms

• Blocky edges on smoke/fire particles
• Color banding in gradients
• Alpha edges look "chunky" or stepped
• Effects look fine in editor, bad in build

Detection Pattern

textureCompression|DXT|BC[0-9]|ETC|ASTC

Version Range

*

Red Flags

• Flipbook with frames smaller than 64x64
• Subtle gradient effects with default compression
• Alpha channel with soft edges on mobile

Vfx Time Scale Ignorance

Id

vfx-time-scale-ignorance

Summary

Effects don't scale with game time (slow-mo, pause, hitstop)

Severity

high

Situation

Game has time manipulation but effects play at wrong speed

Why

Particle systems using real time (Time.unscaledTime) continue during pause. Systems using game time pause but don't slow correctly. Velocity is often baked assuming 1.0 time scale. Flipbook animations don't account for time scale at all by default. Emitters continue spawning during hitstop.

Slow-motion reveals all the sins: particles that move too fast, flipbooks that animate normally while world is at 0.1x, trails that don't stretch.

Solution

1. USE deltaTime consistently (not unscaledDeltaTime) for gameplay VFX 2. MULTIPLY velocities by timeScale in simulation 3. SCALE flipbook playback speed by timeScale 4. OPTION: Pause particle spawn during hitstop, let existing particles slow 5. SEPARATE "world" effects (use game time) from "UI" effects (use real time) 6. TEST all effects at 0.25x, 0.5x, 1.0x, 2.0x time scales 7. For Unreal: Use Game Time vs Real Time simulation space 8. For Unity: Check "Simulation Space" and "Time Scale Mode"

Symptoms

• Effects keep playing during pause menu
• Slow-mo feels wrong because particles don't slow
• Hitstop but fire keeps animating normally
• Time rewind causes effects to behave strangely

Detection Pattern

Time\.unscaled|RealTime|unscaledDelta

Version Range

*

Red Flags

• Mixing scaled and unscaled time in same effect
• Flipbook FPS hardcoded without time scale consideration
• Particle velocity set in worldspace without time awareness

Vfx Mobile Fillrate Cliff

Id

vfx-mobile-fillrate-cliff

Summary

Mobile GPUs have 1/10th desktop fill rate - effects that work on PC die on phone

Severity

critical

Situation

Effects performing fine in editor but destroying mobile frame rate

Why

Mobile GPUs are tile-based deferred renderers with extremely limited memory bandwidth. Desktop GPU: ~500 GB/s bandwidth. Mobile GPU: ~25-50 GB/s. That's 10-20x less bandwidth for filling pixels. Overdraw is catastrophic.

Additionally, mobile uses unified memory - GPU and CPU share RAM. Heavy particle systems starve the CPU of memory bandwidth too. Thermal throttling kicks in after 30-60 seconds of high load, making performance WORSE over time.

Solution

1. HALVE particle counts on mobile at minimum (quarter for low-end) 2. REDUCE particle size - smaller = less fill rate 3. AVOID distortion effects entirely on mobile 4. LIMIT overdraw to 2x average, 4x peak 5. USE simpler shaders - 1 texture sample max, basic math 6. DISABLE soft particles on low-end (depth texture sample = expensive) 7. CULL effects aggressively based on screen importance 8. TEST on actual devices, not just scaled resolution in editor 9. PROFILE thermal throttling - run game for 10 mins then check perf

Symptoms

• 60fps in editor, 20fps on device
• Framerate degrades over time (thermal throttle)
• Battery drains extremely fast
• Device gets hot during gameplay
• Effects work on flagship phone, die on budget phone

Detection Pattern

Version Range

*

Red Flags

• No separate quality settings for mobile
• Distortion effects included in mobile build
• Particle sizes unchanged between desktop and mobile

Vfx Alpha Blend Vs Additive

Id

vfx-alpha-blend-vs-additive

Summary

Using wrong blend mode destroys readability and wastes fill rate

Severity

high

Situation

Effects looking washed out, invisible, or too bright in different contexts

Why

ADDITIVE (src + dst): Light emission, energy, glows. Sums to white on overlap. Good: Lasers, magic, fire cores, explosions. Bad: Smoke, dust, debris.

ALPHA BLEND (src alpha + dst (1-alpha)): Occluding materials. Good: Smoke, clouds, blood, debris. Bad: Energy effects (look dim).

Problem 1: Additive on dark backgrounds = vibrant. On bright = invisible. Problem 2: Alpha blend stacking = muddy colors, not brighter. Problem 3: Both together with wrong order = broken compositing.

Solution

1. RULE: If it emits light, use additive. If it blocks light, use alpha. 2. LAYER: Core = additive, smoke around core = alpha blend 3. TEST: Check effect on pure white AND pure black backgrounds 4. PREMULTIPLY: Premultiplied alpha improves compositing, reduces fringing 5. HDR: Use values > 1.0 for additive bloom instead of max saturation 6. SOFT ADDITIVE: Blend mode OneMinusDstColor for softer addition 7. MULTIPLY: Use for shadows, ground darkening (darkens only)

Symptoms

• Fire effect invisible in bright outdoor level
• Smoke turns level gray/washed out
• Stacking additive = white rectangle
• Colors look wrong compared to source texture

Detection Pattern

Blend\s+One|BlendMode.Add|Blend.SrcAlpha

Version Range

*

Red Flags

• Additive blend on smoke/dust particles
• Alpha blend on glowing energy effect
• No consideration of target background brightness

Vfx Seam Visible Loop

Id

vfx-seam-visible-loop

Summary

Looping effects with visible reset/seam break immersion

Severity

medium

Situation

Continuous effects (fire, waterfall, energy shield) showing periodic stutter

Why

Many effects loop based on particle lifetime. When all particles die at once, there's a frame with fewer particles. Noise-based animation using raw time snaps back when loop restarts. Flipbook last frame doesn't blend into first.

These seams are subtle but the brain detects repetition unconsciously. Players will say "something feels off" without identifying the loop point.

Solution

1. STAGGER particle birth times - never all at once 2. VARY lifetime randomly (+/- 20% minimum) 3. USE modular noise: noise(sin(time 2 PI / loopDuration)) 4. CROSSFADE: Spawn new wave as old wave fades out 5. FLIPBOOK: Ensure frame 0 and frame N-1 blend seamlessly 6. RECORD and scrub effect to find loop point, fix visually 7. Multiple particle groups offset by 1/N of loop period

Symptoms

• Effect "pulses" or "breathes" periodically
• Visible pop when loop restarts
• Animation feels repetitive even if you can't say why
• Particles all respawn at once

Detection Pattern

loopDuration|Loop.Time|lifetime.const

Version Range

*

Red Flags

• Fixed lifetime with no randomization
• Single burst spawn that loops
• Time-based offset without modular arithmetic

Vfx Particle Physics Mismatch

Id

vfx-particle-physics-mismatch

Summary

Particle motion not matching world physics feels wrong

Severity

medium

Situation

Effects that feel floaty, too fast, or disconnected from game world

Why

Game gravity: -9.8 m/s^2. Particle gravity: random artist value. Result: Debris floats like it's on the moon. Sparks fall faster than character. Players don't consciously notice, but wrong physics triggers uncanny valley.

Also: Wind affects world but not particles. Water splash but particles go through water surface. Character hits ground but debris keeps falling.

Solution

1. MATCH game gravity exactly for physical debris 2. USE gameplay physics for collision when needed 3. APPLY same wind forces to particles as world 4. INHERIT character velocity on spawn for attached effects 5. KILL particles on collision with ground/water 6. REFERENCE real footage - slow-mo video of fire, explosions, debris 7. Mass-based gravity: heavier debris falls faster (larger = heavier)

Symptoms

• Debris feels floaty or moon-like
• Effects detached from character motion
• Wind affects trees but not nearby particles
• Splash spray going wrong direction

Detection Pattern

gravity.[\d.]+|Gravity.Vector

Version Range

*

Red Flags

• Hardcoded gravity value different from game physics
• No velocity inheritance from emitter parent
• Particles ignoring collision with world

Vfx Scalability Afterthought

Id

vfx-scalability-afterthought

Summary

No LOD system for effects = impossible to scale for different hardware

Severity

high

Situation

Effects working on dev machine but tanking on min-spec or console

Why

VFX artists work on powerful machines. They make effects that look great at full quality. No one thinks about low-end until the game ships. Then: "just reduce particle counts" - but effects designed for 1000 particles look broken with 100. Need to design for scalability from the start.

Solution

1. DESIGN at LOW settings first, add detail for higher 2. CREATE quality tiers: Ultra/High/Medium/Low/Off 3. DOCUMENT particle budgets per tier before production 4. SEPARATE "essential" from "polish" particles 5. TEST on min-spec hardware regularly, not just at end 6. PROVIDE fallback effects - simple sprite if particles disabled 7. USE scalability system in engine:

• Niagara: Scalability settings, effect types
• VFX Graph: Output contexts with conditions
• Godot: Process mode and LOD

Symptoms

• Min-spec device unplayable but dev machines fine
• Graphics settings don't affect VFX performance
• Lowering quality just makes effects look broken
• No difference between Medium and Low VFX settings

Detection Pattern

Version Range

*

Red Flags

• Single quality level for all effects
• Effects designed only at Ultra quality
• No per-platform particle budgets defined

Vfx Depth Buffer Precision

Id

vfx-depth-buffer-precision

Summary

Depth-based effects fail at distance due to Z-buffer precision loss

Severity

medium

Situation

Soft particles, depth fade, distortion breaking at far distances

Why

Z-buffer has more precision near camera, less far away. At 100m+ distance, depth values may have only 1-2 bits of precision. Soft particle fade calculation becomes binary - either 0 or 1, no gradient.

This is worse with large far clip plane (1000+) or small near plane (<0.1). Reverse-Z helps but doesn't fully solve for extreme distances.

Solution

1. PUSH near plane as far as possible (0.3m for FPS, 1m+ for RTS) 2. USE reverse-Z depth buffer when available 3. FADE out depth-based effects with distance 4. INCREASE soft particle distance for far effects 5. FALLBACK to non-soft particles beyond certain distance 6. USE linear depth in shader calculations when possible 7. CONSIDER logarithmic depth buffer for extreme ranges

Symptoms

• Soft particles popping between hard/soft at distance
• Depth fade flickering in far view
• Effects look fine near camera, broken far away
• Z-fighting in distant particle effects

Detection Pattern

LinearEyeDepth|_CameraDepth|DepthFade

Version Range

*

Red Flags

• Near clip < 0.1 with far clip > 1000
• Depth-dependent effects used at all distances
• No distance-based quality falloff

Vfx Editor Vs Build Mismatch

Id

vfx-editor-vs-build-mismatch

Summary

Effects look different in editor vs built game

Severity

medium

Situation

Color, timing, or quality of effects changes after building

Why

Editor runs in linear color space, build might be gamma. HDR enabled in editor, disabled in build settings. Texture import settings different. Particle system update rate different in editor (tied to frame rate). Post-processing enabled in editor scene but not in gameplay camera.

"It looked perfect in editor" is the VFX artist's lament.

Solution

1. MATCH editor and build color space settings exactly 2. ALWAYS test in build, especially before milestones 3. LOCK particle update rate to fixed timestep if possible 4. VERIFY texture import settings persist to build 5. USE same post-processing stack in editor as gameplay 6. AUTOMATE visual regression testing if possible 7. BUILD to target platform regularly, not just at end

Symptoms

• Colors washed out or oversaturated in build
• Particle timing different (faster or slower)
• Alpha blending looks different
• Effects visible in editor, invisible in build

Detection Pattern

Version Range

*

Red Flags

• Team only testing in editor, not builds
• Different color space between editor and build
• Post-processing only in editor scene

Vfx Realtime - Validations

Extreme Particle Spawn Rate

Id

vfx-extreme-spawn-rate

Severity

critical

Type

regex

Pattern

• SpawnRate\s[=:]\s[1-9]\d{3,}
• spawn.rate.[=:]\s*[1-9]\d{3,}
• emissionRate\s[=:]\s[1-9]\d{3,}
• rateOverTime\s[=:]\s[1-9]\d{3,}

Message

Spawn rate > 1000/sec will cause severe overdraw. Even with short lifetime, this creates performance issues.

Fix Action

Reduce spawn rate to < 200/sec for most effects. Use larger, fewer particles with more impact each.

Applies To

• *.prefab
• *.asset
• *.uasset
• *.vfx
• *.tscn
• *.tres
• *.cs
• *.cpp

Missing Max Particles Limit

Id

vfx-no-max-particles

Severity

critical

Type

regex

Pattern

• maxParticles\s[=:]\s0(?!\d)
• MaxParticles\s[=:]\s-1
• capacity\s[=:]\sInfinity
• unlimited.*particles

Message

No max particle limit can cause memory exhaustion and frame drops during sustained effects.

Fix Action

Set explicit MaxParticles limit. Tier 1 effects: 10000 max. Tier 2: 500. Tier 3: 100.

Applies To

• *.prefab
• *.asset
• *.uasset
• *.vfx
• *.tscn
• *.cs
• *.cpp

Distortion Effect Without Mobile Guard

Id

vfx-distortion-mobile

Severity

critical

Type

regex

Pattern

• GrabPass|_GrabTexture
• _CameraOpaqueTexture.*distort
• Distortion.mobile|distortion.MOBILE
• refraction|Refraction

Message

Distortion effects require framebuffer read - catastrophic on mobile TBDR GPUs.

Fix Action

Disable distortion on mobile platforms. Use alternative visual (glow, color shift) instead.

Applies To

• *.shader
• *.shadergraph
• *.vfx
• *.material

Unscaled Time in Gameplay Effect

Id

vfx-unscaled-time-gameplay

Severity

error

Type

regex

Pattern

• Time\.unscaledTime
• Time\.unscaledDeltaTime
• getRealTimeSeconds
• FApp::GetDeltaTime\(\)

Message

Using unscaled/real time means effect won't respect slow-mo, pause, or hitstop.

Fix Action

Use deltaTime (scaled) for gameplay VFX. Reserve unscaled time for UI effects only.

Applies To

• *.cs
• *.cpp
• *.gd
• *.shader

Additive Blending on Smoke/Dust

Id

vfx-additive-smoke

Severity

error

Type

regex

Pattern

• (?i)smoke.Blend\sOne\s*One
• (?i)dust.BlendMode.Additive
• (?i)cloud.*(?:additive|Add)
• smoke.blend.add

Message

Smoke/dust should use alpha blending, not additive. Additive makes occluding effects transparent.

Fix Action

Use Blend SrcAlpha OneMinusSrcAlpha (alpha blend) for smoke, dust, clouds, and debris.

Applies To

• *.shader
• *.material
• *.mat
• *.prefab
• *.vfx

Sorting Enabled on All Particle Systems

Id

vfx-sort-all-particles

Severity

error

Type

regex

Pattern

• sortMode.ByDistance|SortByDistance.true
• transparencySortMode.*SortByDistance
• renderingOrder.*SortByDepth

Message

Sorting all particles is expensive (O(n log n)). Only sort when transparency requires it.

Fix Action

Disable sorting for additive effects. Limit sorted particle count to < 1000 per frame.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset

Fixed Particle Lifetime Without Randomization

Id

vfx-fixed-lifetime-no-random

Severity

error

Type

regex

Pattern

• lifetime\s[=:]\s[\d.]+\s[;,\n](?!.random)
• startLifetime\s[=:]\s\{\sm_Mode\s[=:]\s*0
• lifeTime\s[=:]\sConstant

Message

Fixed lifetime causes all particles to die simultaneously, creating visible loop seams.

Fix Action

Add +/- 20% random lifetime variation. Use Random Between Two Constants or similar.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.tscn
• *.cs

Large Billboard Particles Without LOD

Id

vfx-large-billboard-no-lod

Severity

error

Type

regex

Pattern

• startSize.>\s[5-9]|startSize.>\s\d{2,}
• size.[=:]\s[5-9][\d.]*
• particleSize.[=:]\s[5-9]

Message

Large particles (>5 units) cause extreme overdraw. Need LOD to reduce at distance.

Fix Action

Implement size reduction with camera distance. Large effects should fade/shrink when far.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset

No Velocity Inheritance for Moving Emitter

Id

vfx-no-velocity-inheritance

Severity

warning

Type

regex

Pattern

• inheritVelocity\s[=:]\s0(?:\.0)?
• InheritVelocity.*false
• velocityInherit\s[=:]\s0

Message

Particles spawned from moving object should inherit some velocity for physical coherence.

Fix Action

Set velocity inheritance to 0.3-0.7 for effects attached to moving characters/vehicles.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.tscn

World Space Simulation Without Consideration

Id

vfx-simulation-world-space

Severity

warning

Type

regex

Pattern

• simulationSpace.*World
• SimulationSpace\s[=:]\s0
• world_coordinate_particles

Message

World space particles detach from moving emitters. Intentional for projectiles, wrong for attached effects.

Fix Action

Use Local space for effects that should follow the emitter (auras, trails on characters).

Applies To

• *.prefab
• *.asset
• *.vfx
• *.tscn

Hardcoded Gravity Value

Id

vfx-hardcoded-gravity

Severity

warning

Type

regex

Pattern

• gravity\s[=:]\s-?[\d.]+\s(?!.gamePhysics)
• gravityModifier\s[=:]\s[\d.]+
• GravityForce.\(\s-?[\d.]+\s*\)

Message

Hardcoded gravity may not match game physics, causing effects to feel floaty or wrong.

Fix Action

Reference game physics gravity constant. Use Physics.gravity or project settings value.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.cs
• *.cpp
• *.gd

Flipbook Without Frame Blending

Id

vfx-flipbook-no-blend

Severity

warning

Type

regex

Pattern

• uvAnimation.blend.false
• FlipbookBlending\s[=:]\sfalse
• flipbook.mode.simple

Message

Flipbook without inter-frame blending shows visible stepping at low frame rates.

Fix Action

Enable flipbook blending in particle renderer or implement in shader for smooth animation.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.material

Constant Particle Color Over Lifetime

Id

vfx-constant-color

Severity

warning

Type

regex

Pattern

• colorOverLifetime.m_Mode\s[=:]\s*0
• ColorOverLife.*Constant
• color_ramp.*null

Message

Constant color makes particles look static. Color variation over lifetime adds life and physics feel.

Fix Action

Add color gradient over lifetime. Fire: bright->dark. Smoke: light->transparent. Energy: pulse.

Applies To

• *.prefab
• *.asset
• *.vfx

No Noise or Turbulence on Organic Effects

Id

vfx-no-noise-turbulence

Severity

warning

Type

regex

Pattern

• (?i)(?:fire|smoke|flame|steam)(?!.noise)(?!.turbulence)(?!.*curl)

Message

Organic effects (fire, smoke, steam) without noise look mechanical and computer-generated.

Fix Action

Add curl noise, turbulence, or perlin noise to velocity for organic motion.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset

Complex Effect in Single Emitter

Id

vfx-single-emitter-complex

Severity

warning

Type

regex

Pattern

• emission.subEmitters.\[\]
• SubEmitters\s[=:]\snull

Message

Complex effects benefit from multiple emitter layers (core, glow, debris). Single emitter limits flexibility.

Fix Action

Separate effect into layers: primary action, secondary motion, ambient detail. Easier to tune and LOD.

Applies To

• *.prefab
• *.asset
• *.vfx

Missing Quality/Scalability Settings

Id

vfx-no-quality-scalability

Severity

warning

Type

regex

Pattern

• qualityLevel.*null
• scalability.\[\]|scalability.undefined
• effectQuality.*none

Message

No quality settings means effect can't scale for different hardware or player preferences.

Fix Action

Implement quality tiers. Reduce particle count, disable secondary emitters, simplify shaders at lower tiers.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset

Magic Number Spawn Values

Id

vfx-magic-spawn-numbers

Severity

warning

Type

regex

Pattern

• spawnRate\s[=:]\s(?:37|43|67|73|137|173|257)\b
• burstCount\s[=:]\s(?:17|31|37|47|83)\b

Message

Unusual spawn numbers suggest arbitrary values. Use round numbers or calculated values.

Fix Action

Use intentional values: 10, 25, 50, 100. Or calculate based on duration and desired density.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.cs

Missing Particle System Bounds

Id

vfx-missing-bounds

Severity

warning

Type

regex

Pattern

• boundsMode.*None
• bounds.*null
• customBounds.*false

Message

Missing bounds prevents frustum culling. Off-screen effects will still render.

Fix Action

Set appropriate bounds for particle system. Use Auto or manually specify based on max extent.

Applies To

• *.prefab
• *.asset
• *.vfx

Continuous Effect Without Prewarm

Id

vfx-no-prewarm

Severity

warning

Type

regex

Pattern

• prewarm\s[=:]\sfalse.*(?:loop|continuous|ambient)
• (?:loop|continuous).prewarm\s[=:]\s*false

Message

Looping/ambient effects without prewarm start empty, building up unnaturally.

Fix Action

Enable prewarm for continuous effects so they appear fully populated immediately.

Applies To

• *.prefab
• *.asset
• *.vfx

Potential Overdraw Issues

Id

vfx-overdraw-audit

Severity

warning

Type

regex

Pattern

• emitter\s\{[^}]emitter\s\{[^}]emitter\s*\{
• sub_emitter.*sub_emitter
• layers\s[=:]\s[4-9]|\d{2,}

Message

Multiple layered emitters detected. Audit overdraw in GPU profiler.

Fix Action

Profile with overdraw visualization. Target < 4x average, < 8x peak overdraw.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset

Effect Needs Mobile Audit

Id

vfx-mobile-check

Severity

warning

Type

regex

Pattern

• platform.*mobile|MOBILE
• android|ios|Android|iOS
• mobileQuality

Message

Mobile platform detected. Verify effect meets mobile fill rate budget (< 2x overdraw).

Fix Action

Create mobile-specific variant with reduced particles, simpler shaders, no distortion.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.uasset
• *.cs
• *.cpp

Soft Particles Performance Check

Id

vfx-soft-particles-check

Severity

warning

Type

regex

Pattern

• softParticles\s[=:]\strue
• SoftParticle.*enabled
• depthFade\s[=:]\strue

Message

Soft particles require depth texture sample per particle pixel. Expensive on mobile/low-end.

Fix Action

Disable soft particles on low quality settings. Verify depth texture is available.

Applies To

• *.prefab
• *.asset
• *.vfx
• *.material

VFX Texture Resolution Audit

Id

vfx-texture-resolution-check

Severity

warning

Type

file

Pattern

• _flipbook_.png
• _vfx_.tga
• _particle_.png

Message

VFX texture detected. Verify compression settings and resolution appropriate for use case.

Fix Action

Flipbooks: 128x128+ per frame. Use BC7/ASTC for quality. Add padding between frames.

Applies To

• *.png
• *.tga
• *.psd
• *.tif