Wind bridge

The wind bridge is one level actor, AT Wind Manager (AATWindManager). It reads a wind intensity and a wind angle from a source, and writes them to the Material Parameter Collections (MPCs) your foliage materials read. It also calls every actor in the level that implements the ATWindReceiver interface.

Wind source  ->  AT Wind Manager  ->  Mpc Targets (your material parameter collections)
 intensity 0-1                    ->  Receivers   (actors implementing ATWindReceiver, e.g. AT Wind Niagara Actor)
 angle in degrees

Set it up

1. In the Place Actors panel, search for AT Wind Manager and place one in the level. One is enough; it reaches every collection and receiver you give it.
2. Under Wind → Source, fill in the source. The default is Actor Property + MPC Angle: assign your weather actor, name the float property that holds the wind intensity, and, if your project stores the angle in a Material Parameter Collection, assign that collection and the scalar parameter name. See Actor property source.
3. Under Wind → Targets, add one element to Mpc Targets per Material Parameter Collection your foliage reads. Set Mpc, then type the parameter names your materials use into the Param fields. Leave a Param field empty to skip it. See Mpc targets.
4. Press Sync Now on the actor.

The manager also resolves its targets, re-initialises the source, refreshes receivers and pushes the current wind each time the actor is constructed, which includes when you change one of its properties in the editor, and again at Begin Play.

The manager ticks in editor viewports, so the wind updates in the editor as well as in play.

To confirm what it writes, turn on verbose output for the plugin's log category, then press Sync Now:

Log LogAgenticBiomes Verbose

Each push then prints one line in the Output Log. The numbers are an example of the format:

ATWindManager: Intensity=0.50 Angle=90.0 -> 1 MPC targets, 2 receivers

Manager properties

Two buttons on the actor:

Both are also callable from Blueprints (category Wind).

When the manager pushes

On each poll the manager reads the intensity from the source and compares it with the last value it pushed. It pushes only when the difference is greater than 0.01. The angle is read only at the moment of a push.

• A wind that changes by 0.01 or less between polls is not pushed.
• An angle change on its own is not pushed. The new angle arrives the next time the intensity moves by more than 0.01, or when you press Sync Now.
• The manager clamps intensity to 0 to 1 only when it writes to an MPC target. Receivers get the value exactly as the source returned it.

Mpc targets

Each element of Mpc Targets is a FATWindMpcTarget. A target whose Mpc is empty is skipped. Every Param field that is empty is skipped, so a target only writes what you name.

For each push, the manager computes:

Alpha         = Clamp(Intensity, 0, 1) ^ CurveExponent
Strength      = Lerp(StrengthCalm, StrengthStorm, Alpha)
Speed         = Lerp(SpeedCalm,    SpeedStorm,    Alpha)
Weight        = Lerp(WeightCalm,   WeightStorm,   Alpha)
DirectionScalar = (angle wrapped to 0..360) / 360
DirectionVector = (cos(angle), sin(angle), 0, 0), multiplied by -1 if Negate Direction is on

The angle is in degrees, measured from the world +X axis toward +Y. With a Curve Exponent of 2 and an intensity of 0.5, Alpha is 0.25.

In the direction vector, Z and W are written as 0.

Parameter names must exist

The manager does not check that a parameter exists in the collection. If you type a name the collection does not have, Unreal logs a one-time warning to the Message Log (PIE category):

SetScalarParameterValue called on <collection> with invalid ParameterName '<name>'. This is likely due to a Blueprint error.

The vector variant says SetVectorParameterValue instead. Nothing else tells you the name is wrong, and the foliage does not move.

Actor property source

Actor Property + MPC Angle (UATActorPropertyWindSource) is the source every new manager starts with. It reads the intensity from a property on one of your actors, and the angle from a scalar parameter in one of your collections. It carries no names of its own.

Notes:

• The intensity is Clamp(Raw / Intensity Max, 0, 1). If the actor, the property or the name is missing, it is 0.
• The angle is read from the collection as it is. It is not converted. It must already be in degrees.
• Only a float or double property is accepted. Any other type is rejected with a warning.
• Fields you leave empty are skipped without a message. If you set something that cannot be resolved, the source logs a warning:

When the search succeeds it logs UATActorPropertyWindSource: Found weather actor '<name>'.

Your own source

Wind Source (UATWindSource) is the abstract base for sources. It has three events, all in the Wind Source category:

WorldContext is the AT Wind Manager itself, so it can reach the world. ReadIntensity and ReadAngle are const.

The class is Abstract. A concrete subclass that is declared EditInlineNew appears in the Source dropdown. Subclass it in C++ in your own game module, which needs AgenticBiomes in its module dependencies:

#include "ATWindSource.h"
#include "MyWindSource.generated.h"

UCLASS(EditInlineNew, meta = (DisplayName = "My Wind Source"))
class MYGAME_API UMyWindSource : public UATWindSource
{
	GENERATED_BODY()

public:
	virtual float ReadIntensity_Implementation(const UObject* WorldContext) const override;
	virtual float ReadAngle_Implementation(const UObject* WorldContext) const override;
};

Receivers

Any actor can follow the wind by implementing the ATWindReceiver interface (IATWindReceiver). It has one event, category Wind:

The manager calls it on every cached receiver each time it pushes, after it has written the MPC targets. In a Blueprint actor, add ATWindReceiver under Class Settings → Interfaces and implement On Wind Changed.

The manager finds receivers when it is constructed, at Begin Play, and when you press Refresh Receivers. A receiver spawned later is not seen until you call RefreshReceivers. Sync Now does not refresh the list. The list holds weak references, so a destroyed receiver drops out.

AT Wind Niagara Actor

AT Wind Niagara Actor (AATWindNiagaraActor) extends Epic's Niagara Particle System Actor and implements the receiver interface. Use it as the parent class of a Blueprint for a wind-driven effect. It does not tick; it reacts only when the manager pushes.

On each push it sets the actor's yaw to the wind angle, if Rotate To Wind is on, and then writes Niagara float user parameters by name on the actor's Niagara component. A parameter with an empty name is skipped. If the actor has no Niagara component it logs ATWindNiagara [<name>]: No NiagaraComponent found.

No Niagara system ships for this actor. Create a system with float user parameters whose names match, or rename the Param fields to match your own system.

The foliage wind material

The plugin ships a foliage wind material and its parts under /AgenticBiomes/Materials/Wind/:

None of the plugin's shipped sample materials use M_AT_FoliageWind, and the manager does not drive MPC_AT_FoliageWind until you add a target for it.

M_AT_FoliageWind is a masked, two-sided foliage material (Two Sided Foliage shading, opacity clip 0.33). It is flagged for instanced static meshes and Nanite. World position offset comes from MF_AT_GrassWind plus the character push.

Prepare the mesh

The bend weight is read from the mesh's vertex colour: it is 1 minus the red channel. Paint red as 1 at the root of the plant and 0 at the tip. A mesh with no vertex colour data reads as white in Unreal, which gives a bend weight of 0, so it will not move until you paint it.

Collection parameters

WindDirection is a fraction of a turn, the same unit as Direction Scalar Param, so a target needs no conversion. The material does not use a direction vector, so leave Direction Vector Param empty.

A target for this collection looks like this. Pick your own calm and storm values; the manager has none of its own:

The manager never writes GustStrength. It stays at the value you set in the collection, or whatever your own Blueprint writes.

Character push

MF_AT_CharacterPush reads PlayerPosition, PlayerRadius and PlayerStrength. The default PlayerPosition is far below the world (Z of -1000000), which switches the push off. Nothing in the plugin writes PlayerPosition. To use the push, write the player location to the collection yourself every frame, for example with Set Vector Parameter Value on MPC_AT_FoliageWind, using the player's feet position. The push covers a vertical window from 30 cm below to 200 cm above that position, and its displacement is capped at 60 cm sideways and 45 cm down.

Material instance parameters

• Bend and Sway scale the bend and the side sway, and Sway Speed sets the rate of the sway.
• Color Variation darkens each instance by a random amount, up to that fraction.
• With Enable Gust Colour on, the gust mask, scaled by Gust Colour Strength, drives a brightness change toward Gust Brightness.
• The displacement texture slot is not connected to anything in the material.
• Noise Scale, Gust Scale and Gust Speed feed the inputs of the same names on MF_AT_GrassWind.

Limits

• The bridge does nothing until you configure it: no targets, no weather actor, no property name.
• It pushes only when the intensity changes by more than 0.01, and it reads the angle only on a push.
• It does not check that a collection parameter exists.
• It writes only the parameters you name. GustStrength and the player parameters of MPC_AT_FoliageWind are never written.
• A receiver added at runtime is not seen until Refresh Receivers.
• A custom source must be written in C++.
• No Niagara system ships for AT Wind Niagara Actor.
• No tool in the agent toolsets edits the wind bridge; use the Details panel.

Troubleshooting

For wider problems, see Troubleshooting. To ask a question, join the Discord.

Next steps

• Terrain material, the other material system that ships with the plugin.
• Biome assets, which hold species rows and ground cover. A biome has no wind setting; wind is configured on the bridge.