As part of an advanced weather system in Unreal Engine 5, I implemented a modular snowy weather feature that dynamically integrates with the existing sky and lighting system. I also used Unreal Engine's Landscape tool to sculpt a basin-shaped terrain and added assets to create a snowy wilderness scene to showcase the snowy weather feature.
DEVELOPMENT NOTES

Overview of the Weather System Event Graph

    To extend the Sky Blueprint for snowy weather, I created animated snow coverage using Material Parameter Collections, Lerp masking, and Blueprint timelines, allowing snow to gradually appear across landscape and static meshes. Then I used Niagara system to create snowflake and snow smoke effects that follow the player camera. Their spawn origin and radius are calculated in real time using custom modules based on the camera’s position and movement speed. Footprints are procedurally generated with Niagara decals, triggered by animation notifies synchronized with footstep timing. Lastly I added wind and footstep sounds that react to the current weather preset. The full implementation breaks down into the following modular steps and design patterns:

Lighting Parameter Reference for Snowy Weather (ref: Udemy Weather System UE5 by Vince Petrelli)

Lighting Adjustments: 
Realistic snowy lighting was achieved by fine-tuning Directional Light, Skylight, Sky Atmosphere, and Exponential Height Fog to simulate cold, diffuse conditions.
Data-Driven Weather Presets & Params Organization:
Designed a flexible structure using Primary Data Assets to switch between multiple weather types (e.g., Sunny and Snowy) with a single dropdown in the editor. Also implemented Blueprint Structs to categorize lighting and fog parameters, making the system scalable and easy to maintain.
One-Click Weather Switching: 
Added an enum-based logic in Blueprints to apply preset weather conditions settings and fix the time to daytime during snowy weather, ensuring visual consistency across transitions. Link for full blueprint function
Snow Mask System:
Created a directional snow mask using vertex normals to control accumulation based on surface orientation — ensuring snow only appears on upward-facing surfaces regardless of mesh rotation.
Used a material instance parameter to adjust snow strength in real time for blending snow.
Reusable Material Functions:
Built a multi-use material function to blend snow textures onto both landscapes and static meshes, featuring a toggle to control snow visibility specifically on landscape surfaces. Integrated a Material Parameter Collection (MPC) to enable Blueprint-controlled snow visibility across all materials without direct references. Link for full blueprint material function
Snow Integration for Landscape, Objects and Foliage:
Applied snow blending to props and foliage by modifying materials and preserving transparency through opacity mask logic. For landscape, integrated a Voronoi-based texture bombing technique to break up UV tiling repetition, producing a more realistic snow distribution instead of obvious texture patterns.
    After building the material-based snow coverage for both landscapes and static meshes, I added features to make the environment feel more immersive and responsive. These included camera-following snowfall, animated buildup of snow, dynamic footprints that appear only in snowy weather, and ambient wind and footstep audio for a richer atmosphere.
Animation Notify:
Created a custom Blueprint class inheriting from UAnimNotify and overrode the Received_Notify function to trigger events at specific points in the animation. Notifies were added to the running animation to mark foot contact.
Animation-Based Foot Detection:
Created a custom Blueprint Macro Library for UAnimNotify and defined an IsSunny macro to check the IsSnowing parameter from the Material Parameter Collection (MPC), to ensure footprints only appear during snowy weather. Added an EFootType enum to the notify class to determine which foot (left or right) is landing, avoiding the need for duplicate notify classes.
For accurate footprint placement, a downward LineTraceForObjects is performed from either the foot_l or foot_r socket. The trace direction is calculated using the inverted Up Vector of the mesh scaled by 100 units, and the result is used to detect ground surfaces. Due to the const nature of the Received_Notify function, a local variable is used to dynamically store and switch the current bone name. The trace is limited to WorldStatic objects, and debug draw is set to Persistent to visualize hit locations during gameplay. The line traces work correctly for both feet and are ready to spawn footprints.
Decal Material:
Prepared a decal material sample for footprint generation. Decals can be projected onto static meshes, skeletal meshes, and landscapes, making them well-suited for footprint effects. The sample material used a translucent texture, but stretching issues may occur on sloped surfaces. By using triplanar projection and SceneTexture:WorldNormal, more even projection was achieved and stretching artifacts were resolved. A custom UV triplanar method was also integrated, allowing the same result to be achieved with only a single texture sample, improving the decal’s adaptability and stability.
Footprint Niagara System:
Built a Niagara-based footprint system that dynamically spawns left and right decals. Prepared a decal material using Decal Color instead of Particle Color to support Niagara-driven opacity and color blending, and created two material instances for each foot. Designed two Niagara systems using Decal Renderers with customizable fade timing and orientation. In the notify blueprint, used a LineTrace from foot sockets to detect surface hit locations. Used bone name check to selected the corresponding Niagara system for each foot. Rotation is inherited from the character’s actor rotation to ensure correct decal alignment. Spawned systems using Spawn System at Location, passing in hit location and rotation. Built a macro to check current weather conditions from the Material Parameter Collection, ensuring footprints only spawn when it’s snowing. This Niagara system fully automates decal lifecycle—spawning, fading, and destruction.
Link for Niagara System Basic Concepts 
get hold of camera's properties
get hold of camera's properties
compute camera's speed and decide which value for spawn radius
compute camera's speed and decide which value for spawn radius
compute spawn origin
compute spawn origin
teamplate's all params
teamplate's all params
Follow Camera Niagara System Level Module:
Built a reusable Niagara system level module that dynamically spawns snowflakes/storm particles in front of the player camera based on position and movement speed. This Niagara module queries camera properties each frame and outputs them as system parameters. Calculated the dynamic spawn radius by comparing the camera's velocity against a default threshold, ensuring adaptive coverage during player's movement. Computed a spawn origin offset from the camera’s forward and up vectors to always place particles slightly ahead in player's view. Parameters were exposed to all emitters for efficient reuse. Wrapped the setup as a template system and configured it as a library asset for easy reuse across different particle systems. Link for Follow Camera Settings Concepts 
Snow emitter created by template emitter
Snow emitter created by template emitter
Custom script to control opacity
Custom script to control opacity
Fill in params to the shape location module
Fill in params to the shape location module
Fix bounds for storm particles to solve clipping issue
Fix bounds for storm particles to solve clipping issue
Snow smoke final emitter
Snow smoke final emitter
Overview of the full snow storm particle system
Overview of the full snow storm particle system
Snow Storm Particle System (Niagara-Based Weather Effect):
Created a modular Niagara particle system simulating dynamic snowfall with layered visual effects. The base emitter spawns snow particles using a cylinder shape and follows camera movement via previous created Niagara system level module parameters. A custom dynamic input script controls particle opacity with random values, enabling easy adjustments via Blueprint. Added a secondary emitter for fine snow smoke using a sub-UV animated texture and additive blend material. Used depth fade in the material to smoothly blend particles into surfaces and remove harsh edges. Wind forces and sprite randomness were applied to simulate natural drift, while fixed bounds were configured at the system level to prevent particle clipping during movement. This snow storm system is optimized for visual quality and performance, with parameters exposed for future emitter reuse and Blueprint integration.
Niagara Blueprint Control & System Component Toggle:
Created a Blueprint function called ToggleNiagaraSystemComponent to toggle Niagara weather effects and control key parameters dynamically. Created a reusable macro to enable/disable Niagara system components using Set Auto Activate and Set Active, allowing seamless switching of weather presets like snow and sunny.
Promoted particle system values such as spawn rate, opacity range, and sprite size to Niagara User Parameters, then exposed them in Blueprint using a custom struct (S_SnowParticlesSettings). A macro (Set Snow Particles Settings) was implemented to set these parameters at runtime via Set Niagara Variable Float (by name), enabling real-time adjustments through the details panel.
This setup allows designers to fine-tune visual parameters for snowy weather, all through Blueprint with clean parameter organization and runtime flexibility. Link for Full SetSnowParticlesSetting BP 
Set Snow Coverage Animation in Event Graph
Set Snow Coverage Animation in Event Graph
Material Function Snowy Weather Blend
Material Function Snowy Weather Blend
landscape material with snowy weather blend function
landscape material with snowy weather blend function
Texture bomb the snow's noise texture to avoid pattern apperance
Texture bomb the snow's noise texture to avoid pattern apperance
Snow Coverage Animation:
Implemented a dynamic snow accumulation effect that smoothly blends snow onto objects and landscapes based on runtime weather changes. This system replaces the former instant snow toggle with a visually natural buildup using material-driven Lerp blending and Blueprint-driven timeline animation. To add randomness, overlaid a tiling noise texture (texture-bombing) onto the Lerp alpha input, achieving non-uniform, natural-looking snow accumulation.
Refactored the Dynamic Sky Blueprint for better usability and modularity. Grouped macros by category (e.g. Day/Night Settings, Weather, Clouds) to improve graph clarity. Synchronized all exposed variable defaults—such as moonlight intensity, cloud brightness, and weather presets—between the Blueprint and Details panel to ensure consistency on re-instancing.

No texture bombing technique

With texture bombing technique

Footstep Sound
Footstep Sound
Wind Sound
Wind Sound
Footstep & Ambient Wind Sound Integration:
Integrated dynamic sound effects to enhance immersion in snowy environments. Used an animation notify blueprint (AN_SpawnFootprints) to trigger footstep particles and play randomized audio from a set of several snow footstep sounds, providing variety and realism during character movement.
Additionally, ambient wind audio (winterWind) was added via a dynamically spawned audio component, which is initialized at runtime to avoid crashes caused by global audio references at Event BeginPlay. This component is safely stored in a local variable and played with the snow weather effect for atmospheric enhancement.

You may also like

Back to Top