Wei Dong
View CV
Back to projects

Team project / Technical VFX

SkyFire Uprising

A six-person UE5.4 vehicle-combat project. I owned the dynamic weather and gameplay VFX stack, spanning Blueprint orchestration, Niagara and materials, and a reusable C++ particle framework.

A four-panel overview of rain, speed, collision, and combat effects in SkyFire Uprising.
Gameplay VFX overview: dynamic rain and lightning, speed feedback, collision sparks, and combat atmosphere.

Project overview

Role
Gameplay VFX / Technical VFX Programmer
Team
6 people
Engine
Unreal Engine 5.4
Scope
C++, Blueprint, Niagara, Materials

System architecture

I divided the work into state orchestration, reusable simulation components, effect authoring, and gameplay integration so each layer could evolve without owning the others’ details.

  • Weather requests flow through BP_WeatherManager into data-driven presets, which blend global sky, exposure, cloud, post-process, and vehicle-fog parameters over a configurable duration.
  • A C++ base particle component owns emission, lifetime simulation, and instanced rendering; Data Assets configure it, while specialized components supply fog, smoke, and spark behavior.
  • Blueprint-facing APIs connect those systems to weather events, wheel state, vehicle speed, and collision impulses without moving simulation logic back into gameplay Blueprints.
Blueprint graph showing weather request setup, timed interpolation, and application of blended environment parameters.
BP_WeatherManager transition pipeline: capture current and target presets, advance a normalized alpha, then apply the blended environment state.

Dynamic weather

The weather layer presents one event-oriented interface to level logic while coordinating several independent rendering systems behind it.

  • Defined sunny, overcast, and rainy presets with transition duration, Rayleigh scattering, exposure compensation, post-process materials, cloud-density offset, and vehicle-fog density.
  • Combined Niagara rain streaks and collision-driven ground splashes with a lightning material, temporary exposure response, and a screen-space rain-drip post process.
  • Kept rain simulation local to the player and blended the custom vehicle-fog density through the same weather transition, preserving atmosphere without simulating rain across the full level.
The same driving scene shown in sunny, overcast, and rainy weather.
One scene, three coordinated presets: sunny, overcast, and rainy.
Niagara rain and splash emitters alongside the splash material graph.
Rain presentation combines falling streaks, ground splashes, and a lightweight splash material.
Post-process material graph and preview for animated rain droplets on the screen.
A screen-space rain-drip material separates the rainy state from a simple lighting change.

Reusable C++ particle framework

The framework handles a deliberately small set of particle features in native code and exposes focused controls to Blueprint rather than recreating a general-purpose VFX editor.

  • UL1_ParticleComponent supports continuous and burst emission, accumulated spawn rates, particle limits, randomized lifetimes and scales, world- or local-space simulation, and lifecycle cleanup.
  • Particles share a UInstancedStaticMeshComponent renderer; per-instance custom data carries opacity while age-based fade-in and fade-out are applied during instance rebuilding.
  • Vehicle fog scales spawn rate, particle cap, and material opacity with density, then fades particles by distance so dense fog does not cover the immediate driving area.
  • Tire smoke inherits vehicle velocity and applies damping; collision sparks derive burst count and opacity from impact intensity, then use the hit normal, spread, gravity, and damping to shape motion.
Blueprint call into the C++ vehicle-fog component with a clear and dense fog comparison.
Weather-driven fog density reaches the native component through a narrow Blueprint API.
Blueprint graph mapping vehicle collision data into the Burst At function of the C++ spark component.
OnComponentHit supplies impact position and normal; normalized impulse becomes the spark intensity.
Vehicle Blueprint graph evaluating wheel contact, steering, slip, and speed before updating tire smoke.
Wheel state stays in gameplay Blueprint while particle simulation remains inside the reusable C++ component.

Niagara and gameplay feedback

  • Built a parameterized beam from separate core, halo, spark, and hit-point emitters, with a panning emissive material and public start/end positions.
  • Attached speed-line emitters to the vehicle camera and toggled them at a speed threshold to reinforce acceleration without changing the vehicle simulation.
  • Created a target-driven missile effect with a lead mesh, layered trails, and smoke, plus Ribbon-based tire marks placed at the rear-wheel contact points.
Niagara beam preview and its core, halo, spark, and hit-point emitter stack.
Beam readability comes from layered emitters with distinct responsibilities.
Niagara speed-line preview and emitter stack.
Camera-local speed lines provide a restrained high-speed cue.
Niagara missile preview with lead, trail, secondary trail, and smoke emitters.
Projectile duration and target position drive a layered missile presentation.

Engineering decisions

  • Limited rain generation to the area around the player and used instanced meshes for the native particle effects, keeping the implementation mindful of runtime cost without claiming unmeasured gains.
  • Used presets and narrow Blueprint APIs so artists and gameplay programmers could tune density and intensity without depending on the simulation internals.
  • Identified distance culling or LOD for larger particle counts and reduced coupling around shared SFX logic as the next iteration rather than hiding those limits.
View all projects