Infinity Weather

Download

Infinity Weather is a powerful and clean system designed for weather control in Unreal Engine.

The package is a combination of 7 systems that could be divided into separate packages: wind, displacement, landscape, precipitation, footsteps, fog, and post-process now available as a configurable unified system.

Features

Displacement:

• configurable displacement capture blueprint
• top-down projection of displacements rendered using shape definition in the shader (sphere, capsule, box, cylinder, decal, trace-sphere)
• skeletal mesh displacement supports
• interface for easy integration with all types of actors
• area of displacement moves dynamically with the actor or camera 
• time-based accumulation of snow
• build functions can be used for multiple other effects (like grass interaction)
• displacement material functions ( snow, mud, sand, grass)
• small world texture (1024×1024) can handle even 150x150m area

Post-process:

• two materials with fast dynamic switching between material permutations 
• post-process effects (raindrops, frozen, sharpen/blur)
• pre-translucent effects (rain circles, heat haze, experimental glitter)
• reacts dynamically to weather conditions
• supports character and sequencer camera

Footstep:

• notify-based footstep detection system
• example footstep types (SFX, VFX) snow, rain, mud
• physics material support
• configurable footstep component adjustable per character
• footstep volumes with priorities and conditional spawning

Precipitation:

• defined effects of snow, rain, dust, hail
• GPU-friendly and efficient, implemented on single material and mesh.
• up to 65000 particles per emitter with high-performance
• occlusion maps
• crossfade wind and rain sound effects

Landscape:

• basic example materials (snow, mud, sand)
• advanced landscape material prepared for mixing displacement and dynamic weather.
• virtual texturing and layered landscape materials.
• multiple example ground layers (rock, grass, mud, sand)

Environment:

• weather controller actor
• spherical volumetric fog area and atmosphere and temperature
• weather surface material function (snow/wet layer)
• spline-based rainbow mesh with camera facing,
• water puddle decal
• directional light clouds’ shadow reacts to wind direction.
• wind reactive effects like precipitation, ground dust, flags, trees, bushes, grass, emitters
• example maps: Snow, Sand, Rain, World
• character reaction to strong wind

Discord

Roadmap

[Demonstration]

Gallery

Documentation

Project Config

Make sure that the Infinity Weather package version is up to date. The current newest version is described at the top of the documentation.

The package requires a Procedural Mesh Component and Sun Position Calculator to work so make sure that it’s enabled.

A new sky system requires a Sun Component

I’ve decided to make this project downloadable content that can be added to the project. Unreal Engine does not support sending config files in downloadable content so users have to add footsteps configuration in the project that uses pack to make it work properly.  The process is really simple:

1. Open the project configuration Edit->Project Settings
2. Select tab Engine->Physics and scroll down
3. Add physical surface types: Snow, Sand, Mud, Rock

The package works perfectly with the TPP input config files. if you have used another template then probably you will have to add inputs into your project for package testing: 

[/Script/Engine.InputSettings]
+AxisMappings=(AxisName="MoveForward",Key=W,Scale=1.000000)
+AxisMappings=(AxisName="MoveForward",Key=S,Scale=-1.000000)
+AxisMappings=(AxisName="MoveForward",Key=Up,Scale=1.000000)
+AxisMappings=(AxisName="MoveForward",Key=Down,Scale=-1.000000)
+AxisMappings=(AxisName="MoveRight",Key=A,Scale=-1.000000)
+AxisMappings=(AxisName="MoveRight",Key=D,Scale=1.000000)
+AxisMappings=(AxisName="Turn",Key=MouseX,Scale=1.000000)
+AxisMappings=(AxisName="LookUp",Key=MouseY,Scale=-1.000000)

The package is now ready!

Getting started

Every user of this package should start by checking all examples delivered with the product. Example maps can be found in the InfinityWeather/Demo/Maps folder.

There are available multiple examples that preset different configurations:

• SnowMap – simple snow effects with lightweight landscape material.
• RainMap – simple rain and mud effects with lightweight landscape material.
• DesertMap – simple desert and sunny weather with lightweight landscape material.
• WorldMap – advanced multi-layered material with mixed landscape effects.

The example character interaction with the Infinity Weather world is implemented in Demo/Mannequin/BP_DemoCharacter by four basic components added to it:

• BP_InfinityFootstepComponent – spawns footsteps effect from notifiers
• BP_InfinityDisplacementComponent – renders shapes for ground displacement 
• BP_InfinityPostProcessComponent – controls post-process and controller communication.
• BP_InfinityPawnComponent – additional effects on a character like breath particle when it’s cold.

Weather Control

The most important element of the pack is the InfinityWeather/BP_InfinityWeatherController blueprint that gives the users the possibility to control weather conditions like fog, wind direction, precipitation, and accumulation.

Drag and drop BP_InfinityWeatherController on your level to start controlling the weather.

Atmosphere effects requires Exponential Height Fog plugged into the BP_InfinityWeatherControllers to work properly. Remembet to polace height fog actor on your map and set the attribute of weather controller.

A list of weather controller attributes looks simple but it’s a very powerful tool. For testing try to set some rainy windy weather using parameters like the below:

The system can be controlled dynamically by blending between parameters during the game using the functions below.

Precipitation

The precipitation system is based on a Niagara particle system calculated on GPU only in camera space which makes it very efficient.  

There are a few predefined effects of precipitation defined in the project (/InfinityWeather/Precipitation/)

• Rain/BP_InfinityPrecipitationRain
• Snow/BP_InfinityPrecipitationSnow
• Dust/BP_InfinityPrecipitationDust

The precipitation effect can be used without a weather controller. You can drag and drop the blueprint of the chosen effect on the map to use it as static volume.

A manually placed actor can be configured and limited by the area of precipitation. Users also can set multiple weather types visible locally in some areas of the map. All parameters are described in editor hints.

 

You can create your own precipitation effect classes for specific rain/snow configuration by extending the base class and changing attributes. That newly created class will be available on the Precipitation Effect Class list in weather controller.

The /InfinityWeather/Precipitation/BP_InfinityPrecipitationOcclusion is a specific type of actor that contains a render target texture used for calculating precipitation collision with the roofs and other cached meshes. After placing this actor on the scene you will notice that in the area of the occlusion map the rain and snow are not rendered under the meshes.

Currently supported is only one occlusion map per level but its planned to implement switching between multiple occlusion maps dynamically.

Wind

The wind is based on the integration of multiple effects that react to a simple wind direction vector.

Currently, the wind effects can be controlled globally on the full scene using the Wind Direction vector in BP_InfinityWeatherController.

Most of the objects that react to wind use the Environment/Functions/MF_InfinityWind material function that returns all important information about the current wind status. It’s the simplest way to get global wind data.

List of implemented effects and objects that react to the wind force.

• Precipitation direction – Attribute Wind Force in precipitation blueprint scales how much it affects
• Vegetation – MF_WindBush, MF_WindTreeLeafs, MF_WindTreeTrunk, and MF_WindGrass nodes implement the effects of wind on vegetation.
• Flags – specific implementation of flag material M_Flag.
• Cascade particle emitters (Wind Affected Emitters attribute in Weather Controller is a list of emitters that should use Wind Direction and Wind Intensity parameters to react. (Example Environment/Dust/PS_SnowBlowingLarge)
• Dust – predefined planar dust effects that rotate and fade based on wind direction.
• Grass – MF_WindGrass material node.
• Landscape dust – MF_GroundDust effect on the sandy landscape. 
• Clouds shadow – M_CloudsShadow

 

Fog

The BP_InfinityFog actor can be used for changing fog settings in some areas.  Fog actor is divided into two parts

• Fog volume – The volumetric shape of fog is rendered as overlay mesh.
• Fog atmospherics – Atmospherics settings. When the camera is inside the Fog volume the controller uses those settings to blend into new parameters based on the Weight attribute value.

Currently supported is only the ellipsoidal shape of fog.

Accumulation

Accumulation is the group of parameters that controls the coverage of snow and wetness of meshes that uses the MF_InfinityWeatherSurface node in the master material.  

MF_InfinityWeatherSurface is an advanced node that adjusts base color, normal, and roughness values to current weather conditions set by the two basic parameters that are used in the material.

• Weather.Controller.WetSurface – Controls wetness of the surface
• Weather.Controller.SnowySurface – Controls the snow shell on the surface.

An example of MF_InfinityWeatherSurface use is presented in the rocks material M_RockSnowMaterial. Drag and drop rocks mesh(/InfinityWeather/Demo/Environment/Rock/SM_Rock ) on your map to check how weather conditions affect the material. Notice that the combination of wetness and snowy material can result in a nice-looking effect of icy snow.

Additionally, meshes can be painted by vertex color (red channel) to mask the effect on meshes that are hidden under the occluders.

A more detailed description of additional parameters can be found in the landscape and displacement section.

Displacements

The Infinity Weather system introduces an advanced displacement material system based on render targets. In short, the BP_InfinityDisplacementCapture actor is searching for actors around the focus point, that implements BPI_DisplacementShape. BPI_DisplacementShape implementation adds the list of shapes (a type of shape and transform) to the stack. In the final stage stack of shapes is rendered to displacement texture. The iteration is repeated every frame with some random offset.  

3 elements are needed to make the system work:

1. Displacement receiver landscape with the material that supports displacements. (MI_LandscapeSnow/MI_LandscapeMud/MI_LandscapeSand, MI_LandscapeCombined)
2. Displacement capture actor placed on the map (BP_InfinityDisplacementCapture), set to capture landscape ground.
3. Displacement mesh actor or component that will affect the ground (BP_InfinityDisplacementStaticMeshActor)

The video below shows how to combine all these tools and make them work:

Landscape materials

Landscape material is an advanced topic because requires basic knowledge about an unreal material system to inject them into the project.

Example content (Landscape/Materials) comes with a few examples of the landscape configurations to make this step easier. There are simple materials that cover the landscape fully with a single type of displacement:

• M_LandscapeSnow (uses MF_InfinitySnow)
• M_LandscapeMud (uses MF_InfinityMud)
• M_LandscapeSand  (uses MF_InfinitySand)

There is also an advanced version of the material that is a combination of all three effects in one landscape. Additionally, the extended version supports the MF_InfnityWeather. Available in two versions virtual texturing and multilayered 

• MI_LandscapeCombinedLayered
• MI_LandscapeCombinedVirtual 

Let’s take a look at the example Sand (M_LandscapeSand) material used on DesertMap:

The material is a combination of four nodes:

1. MF_GroundDand – it’s the base material layer of sand that contains a color map, normal map roughness, etc. It can be replaced by any material for example created from GameTextures/Example Project/Any pack.

2. MF_InfinityDisplacement – is a base node that reads displacement render target and returns data from it. As an input, it takes the displacement layer intensity. It’s the layer that will be used to paint the landscape.
3. MF_InfinitySand – combines data from displacement and ground layer. Additionally, this node implements some additional effects like coloring displaced ground. There are another two nodes that could be used here to achieve another effect MF_InfinityMud, and MF_InfinitySnow.
4. MF_InfinityWeather – adding the overlay effect of a wet surface that can be controlled by the weather controller.

Displacement capture

The BP_InfinityDisplacementCapture is the main actor that prepares displacement depth textures for the landscape. Below is a simple explanation of how the algorithm of this actor works:

1. Displacement capture actors are searching for actors that overlap the area of displacement.
2. If an actor that supports the displacement interface is detected then he is asked about list shapes to displace ground.
3. New generated shapes are added to the stack.
4. In the final step, the displacement capture actor renders all shapes added to the stack.  

A simple configuration of the scene with displacements is presented below:

1. Drag and drop BP_InfinityDisplacementCapture on the map.
2. Add the Landscape actor to BP_InfinityDisplacementCapture.GroundMeshes.

   it’s an important step to notify the system about the receiver of the displacements.

3. Select landscape and use the material that supports displacements for example M_LandscapeSand.

4. Edit the landscape and paint the layer of displacement on it.

For optimization, displacements are rendered only in the area of the focus point. The focus point is taken from BP_InfinityDisplacementCapture.CaptureActor. If the CaptureActor is null then it uses the character Pawn as the focus. If Pawn is null then it uses camera location.

Two types of render targets are defined in the system. Both area sizes can be changed in the capture displacement actors.

• Capture Render Target  – cache shapes around the focus point. Modify the CatureTextureSize attribute.
• World Render Target – combines all cached data. Modify the render target TR_Persistent.resolution to adjust the size of history.

Simple static shapes

The displacement map rendering is based on ray tracing shapes in the shader to get the best possible efficiency but it’s also limited to the number of shapes predefined in shaders. The shapes that can displace the ground are defined in the /InfinityWeather/Displacement/Blueprints/Shapes/ folder:

• BP_DisplacementStaticMeshCapsule
• BP_DisplacementStaticMeshCube
• BP_DisplacementStaticMeshCylinder
• BP_DisplacementStaticMeshSphere
• BP_DisplacementDecal (heightmap mapping on the ground)

All of them can be placed on the map and scaled.

Use Debug Option in BP_InfinityDisplacementCapture to preview shapes that are rendered by capture displacement

Character displacement

BP_InfinityDisplacementComponent is a component that allows attaching a list of shapes that affect displacement ground.

The example implementation of the displacement component in a clean mannequin character is presented in the video below:

Adding displacements to your character is easy:

1. Open the character blueprint, and add BP_InfinityDisplacementComponent to your character.
2. Select the component and set the Displacement Shapes data asset. You can use full ragdoll  (DS_MannequinRagdoll) or foot (DS_MannequinFoots) implementation that is faster and more prepared for walking.
3. Select “Class Settings” on the top bar and add the BPI_DisplacementShape interface to the list of Implemented Interfaces. It should look as on the screen:
4. 
5. Now implement the interface function called AddDisplacementShapeData.

After those few steps, the character will be detected and ready to work.

Custom collision

The Infinity Weather displacement capture system uses box collision volume during searching for the actors that should be captured in the displacement buffer. The overlap detection requires a specific collision type for filtering collision shapes. The engine has no option to include a custom collision type in the external marketplace package because it’s defined in the configuration files.

By default, Infinity Weather takes advantage of using a predefined destructible collision type but it’s not the best solution for every project, this collision type can be occupied by other functionalities and turned off for specific actors like characters.

The best way to overcome this problem and also improve performance during overlap tests is by creating a custom collision type and using it to detect shapes that should be detected in the displacement area This solution will also fix all issues with ALS ragdoll detection and other strange behaviors that could occur after placing BP_InfinityDisplacement actor on the map.

Creating a custom collision type is described in the Unreal Engine 4 documentation and the explanation below shows how to apply this knowledge with Infinity Weather:

1. Find  Edit->ProcectSettings->Collision

2. Open the ObjectChannels tab and add a New Object Channel type called “InfinityCapture“, set to ignore by default.

Now you have to set a new collision type in the displacement capture actor.

It’s good practice to inherit BP_DisplacementCapture class and edit the child class instead of changing package assets. If you do tit this way then the next package update will not break your project.

1. Open BP_DisplacementCapture (or child instance) and find the CaptureVolume component.
2. In CaptureVolume->DetailPanel->Collision->CollisionPresets->ObjectType set the InfinityCapture type.

Since now every actor that has set Collision Response->InfinityCapture->Overlap true will be considered during the displacement detection process.

1. Find the character class and select the collision component that should be detected (CapsuleComponent or Mesh)
2. In the details panel find the Collision tab ->  Collision presets
3. If the collision preset type is “Custom…” then just switch InfinityCapture->Overlap to true.
4. Otherwise, you will have to set custom or edit existing presets the same way in project collision settings.
   

   

5. Remember to repeat these steps for all actors that should be detected by displacement capture like BP_InfinityDisplacementStaticMeshActor.

You can use debug option in BP_InfinityDisplacement actior to see if the actor is detected.

Displacement data asset

The configuration of displacement shapes attached to actors is stored in Data assets (PDS_DisplacementShapes).

The Infinity Weather contains a few examples of data assets for mannequins and vehicles but any user can create custom data assets that will work with specific skeletal mesh. Creating a displacement data asset is simple:

1. Press the right mouse button in the content browser
2. Select Miscellaneous->DataAsset
3. Pick PDS_DisplacementShapes and create
4. Set the name of the newly created data asset “DS_ExampleDataAsset” for future use.

Newly created data assets can be used in the characters but we still need some shape definitions. Shapes can be added by hand but Infinity Weather comes with a simple editor that helps preview how shapes are attached.

1. Drag and drop the editor class on the map (BPU_InfinityDisplacementShapesEditor).
2. Select editor, and chose newly created data assed (DS_ExampleDataAsset) in Data attribute.
3. Pick the skeletal/static mesh reference that will be a visual representation of the shape that makes displacement. It can be your character or car.
4. Press Load and now you can add shapes to the List. The shape structure is described below.
5. After work is done press the save changes using button. Remember to apply the newly created data asset in DisplacementComponent.

Shape property	Description
Socket	Bone or socket name used as an attachment transform. The system will use component transform if the socket name is not defined.
Shape.Type	Shape type. Currently supported: Box/Sphere/Cylinder/Capsule/Decal, Trail Wheel, Trail Sphere
Shape.Intensity	Scale the intensity of interaction (not implemented yet)
Shape.Transform	Relative transform in space of attachment.
Shape.Pattern	The texture is used as a pattern in the displacement decal.

Footsteps

Weather System also supports the advanced footstep system integration based on notifiers placed in animation.  

Working with footstep system:

1. Add BP_InfinityFootstepComponent component to a character. The configuration of components contains default predefined templates of effects and attachments for the mannequin.
2. Add BP_NotifyFootstep to the animation of walking/running in place when the foot hits the ground. Choose the left or right foot in the properties.
3. Add BP_FootstepVolume on your scene and select the preset of footstep that should be spawned inside of the volume.

Footstep volume

The engine sometimes wrongly detects the footstep ground because of limited landscape layers blending during ground tracing. Footstep volumes BP_FootstepVolume can solve this problem easily. When the character is inside the volume then the system uses the footstep set in the volume definition so the incorrect footstep effect is overridden.

The priority and Required conditions are taken into account to choose the most relevant footstep effect. It can be even filtered. The example below shows how to config volume on second priority (higher priority more important) that spawns snow and will be visible only when there is at least 0.1% of the weather displacement active.

Screen Effects

The BP_InfinityPostProcessComponent placed into an actor that contains the camera component will add automatically the post-process material and communicate with the weather controller to get info about the current conditions.

Three types of post-process view objects are supported:

1. Postprocess camera – by default system searches for the camera in owner.
2. Postporcess component – if there is no camera in the owner then the system searches for a component.
3. Postprocess Volume – custom volume can be set for the character on the scene by setting the Postprocess volume attribute.

A custom post-process object can be also set by the function SetPostProcessView.

Features:

• Raindrops and circles show only when the precipitation actor has IneractWeather > 0.0. That means raindrop shows only inside the rain volume.
• Screen raindrops fade after some time. The duration of the fade can be controlled by BP_InfinityPostProcessComponent.Rain parameters.
• When the camera is under the cover it’s not getting wet and raindrops are not appearing.
• Freezing and heat haze distortion are calculated locally from the weather controller and fog actor’s atmosphere. (temperature, distortion) 

The screen effects are implemented using two post-process materials.

MI_InfinityPreTranslucent – a group of effects rendered before the translucency layer.

• Rain Circles – Enables automatically when rain precipitation is active.
• Distortion – Heat Haze effect that enables when 
• Glittering – Experimental disabled effect of glittering rendered on snow and sand.

MI_InfinityPostProcess – a group of effects rendered after the tone-mapping.

• Sharpening – Additional sharpening effect that improves the quality of close objects (can be disabled) by UseSharpening.
• Drops – Animated raindrops on-screen are visible only if the camera is exposed to rain.
• Frozen – Frozen screen edges.

Replication

The replication of the weather is implemented on the server side. That means all functions from BP_InfinityWeatherController that control weather should be activated on the server and then the state will be automatically sent to clients. The state of the weather is also replicated when the player joins to game after some time.

Displacement render targets are not replicated but only calculated locally around the focus point of the displacement capture actor that follows the local player 0. That means if multiple actors are walking in the same area at the same time then the result will be calculated locally and similar for all of them. It behaves this way not because it’s replicated but because it’s simulated locally with the same data.

During testing displacements in multiplayer be sure to run it in separate instances of the game, otherwise, UE4 shares the memory of ground texture and there are bugs because multiple displacement actors render the same displacement texture at the same. This issue does not affect the final released game so don’t worry. Use option SingleProcess=false for testing the game in the editor with proper displacements in multiple windows.

Future features that will be implemented for multiplayer games:

• Local weather controllers are not supported yet but it’s something on my roadmap.
• Replicated foodprint decals that will be sent to clients and activated when displacement actors close.

Sky System

The Infinity Weather 2.0 introduces a completely new sky system which is simultaneously the most innovative feature of this product.

The sky is organized out of a few separate blueprints responsible for different parts of the sky rendering:

BP_InfinitySky is the basic class that manages fundamental sky-related settings, providing the flexibility to customize visual appearance. The system links useful components that can be adjusted:

• atmosphere
• exponential height fog
• background clouds
• celestials (Sun, Moon, and stars)
• post-process exposure
• Skylight

After adding an actor map map system works automatically, and you can edit all parameters according to the descriptions highlighted when the mouse is hovering over it.

By default, the BP_InfinitySky system uses the SunRotation attribute to control the position sun in the sky. It’s a simple solution that gives 100% control but is not very handy when you want to build a real world which is why the BP_InfinitySolarSystem actor was created. 

BP_InfinitySolarSystem – The solar system is an actor that feeds the Sky with information about the celestials based on the current time, date, and localization to calculate the Sun position. Configuration is simple:

1. Add BP_InfinitySolarSystem on your level
2. Select BP_InfinitySky and set BP_InfinitySky.SoilarSystem = (the solar system added before)

From now SunRotation will be calculated using SolarSystem configuration and you can use BP_InfinitySolarSystem.TimeOfDay parameter to control the sun position.

It requires the build-in engine Sun Position Calculator plugin to work properly otherwise blueprint won’t compile, so make sure the plugin is enabled in your project:

BP_InfinityLightning – It involves generating the effect of illuminating clouds at the location of lightning. It randomizes lightning within a specified area, allowing for periodic activation, and also displays lightning bolts.

Additionally system provides the BP_InfinityLightningMask actor which defines a mask area that can be used for cutting off the light effect inside the buildings. The example of use is presented on the RainMap.

It seems like an emissive output is doing the job. I love the way volumetric clouds work in #UnrealEngine. The lightning bolt effect is from my Lightning Fast asset.
BTW, the Infinity Weather update is ready and awaiting approval! 🙂 pic.twitter.com/zC13LiqNDF

— Krystian Komisarek (@ImaginaryBlend) January 17, 2024

BP_InfinityVolumetricClouds – Separate volumetric clouds system that can be easily integrated with every project without destroying other lightning settings on the map.Shipped with 20 predefined cloud presets that can be easily mixed. The volumetric cloud control is simplified to a few basic parameters (Coverage, Slope, Density, Erode, Softness, Light) that can model many different types of clouds.

The system supports two data assets of clouds Primary and Secondary that are blended partially by a defined circular area. The area of blending is defined by three parameters.

• SecondaryCloudsPosition – Position of center (represented by the 3D point that can be moved in the editor)
• SecontaryCloudsRadius – Radius of the circle area  
• SecontaryCloudsSoftness – Softness of the circle area

When PrimaryDataAsset/SecondayDataAsset are not specified system automatically uses the parameters PrimaryClouds/SecondaryClouds so there is no need to build data asset for every sky setup.

The BP_InfinityVolumetricClouds system can also cast high-quality shadows on the ground. The feature is implemented using a light function whitch means it requires changing parameters in Direcitonal light used by the system as the Sun. It can be done by using TargetSunLightActor, you can use BP_InfinitySky, DIrectionalLight, or even UDS sky as a target.

EUW_InfinityCloudsEditor – The volumetric cloud editor enables the blending of sample presets and the creation of new ones.

The tool is simple to use:

1. Find EUW_InfinityCloudsEditor in content.
2. Click right on EUW_InfinityCloudsEditor and choose Run
3. Select the BP_InfinityVolumetricClouds 
4. Duplicate some of the existing cloud data assets
5. Choose the duplicated cloud data asset in EditedDataAset of editor the data asset to edit 
6. Use cloud parameters or a mixer
7. Use “Save Asset” button to write into EditedDataAsset

It definitely took me too long, but I finally found the ‘right’ parameters for volumetric clouds. The Infinity Weather update, which will also include support for UE5, is coming soon 🙂 pic.twitter.com/PI0P99oxwt

— Krystian Komisarek (@ImaginaryBlend) November 8, 2023

The integration with the Sequencer allows for cloud control through a timeline with the ability to scroll through time and adjust cloud transition effects. 

I’ve successfully gained control over the sky in the sequencer. The configuration could be more intuitive but it’s still better than nothing. 🙂 #UnrealEngine pic.twitter.com/2sCVD9V9QY

— Krystian Komisarek (@ImaginaryBlend) January 5, 2024

Integrations

Advanced Locomotion System

Collision setup

The most important part is implementing a custom collision type that will solve most of the problems related to ALS and IW volume overlapping. You can find detailed descriptions of this step in the chapter called “Custom Collision Type”.

After you finish this collision configuration then additionally it is worth setting Climbable  = Ignored in Trace Responses of Capture volume component because it’s not needed. The final configuration of the InfinityCapture actor should look like below:

It’s also important to update the ALS_Character collision preset in the project config. The InfinityCapture channel should be set to overlap.

Ragdoll

When the collision setup is ready then it’s time for ragdoll. During ALS ragdoll mode capsule overlap is not detected and that is why displacements are not rendered by default. There are two possible methods to fix it and the choice on you:

1. Select ALS Character Mesh and switch Generate Overlap Events = true, and InfinityCapture channel to Overlap.
2. Alternative more general method. ALS_Character -> Add Component ->Sphere Collision to character actor and configure attributes as presented on the screen below:

There is another important thing about ragdolls that is switching between presets ragdoll/feet.

The DS_MannequinRagdoll preset is slower and more precise, the DS_MannequinFoots preset works perfectly in low FPS because it supports continuous movement. Fortunately, ALS can support this feature very easily ALS_AnimMan_CharacterBP has functions RagdollStart and RagdollEnd that perfectly fit the requirements of switching.

Use SetDisplacementShapesDataAsset on the DisplacementComponent.

• RagdollStart should set DS_MannequinRagdoll asset as a parameter
• RagdollEndshould set DS_MannequinFoots asset as a parameter

Questions & Answers