Skip to content
CRUSHFORMV1.1.0
GET IT ON FAB

REFERENCESETTINGS

UCFSettings

MODULECrushformINCLUDECFSettings.hPARENTUDeveloperSettings

Blueprint: Crushform

Project-wide Crushform settings: Project Settings > Plugins > Crushform.

Functions

AUTHORITY · server, every machineLOCAL · this machinePURE · read only
const UCFSettings* Get()
C++ ONLY

The project's Crushform settings object (the class default object).

const FCFDirtChannelSettings& GetDirtChannel(ECFDirtChannel Channel) const
PUREC++ ONLY

The settings of one dirt channel.

FCollisionResponseTemplate GetLoosePartCollision() const
PUREC++ ONLY

The collision a hinged part takes once it swings or came off: the template of Loose Part Collision Profile, or the plugin's own when that is None or names no profile. The plugin's own needs no profile or collision channel in the project: a physics body that blocks the world and ignores pawns, vehicles, cameras, visibility traces, destructibles and other physics bodies, other loose parts among them. Either way, the hinge then makes vehicles block the part one-way.

void ApplyConsoleVariables(EConsoleVariableFlags SetBy = ECVF_SetByProjectSetting) const
PUREC++ ONLY

Writes the settings into their console variables at the given priority. The default is the project-setting priority, which a console command or a device profile overrides.

int32 GetCollisionDeferFrames()
C++ ONLY

Frames a heavy collision build may defer, 0 or 1, as Crushform.Collision.DeferFrames gives them: a negative console value defers nothing and a value above 1 reads as 1.

bool IsCollisionDeformEnabled()
C++ ONLY

Whether body and part collision may follow dents in this project, as Crushform.Collision.Deform gives it. Off wins over a profile's Deform Collision.

float GetDentCullDistance()
C++ ONLY

How far from the camera dents and scratches are drawn, in cm, as Crushform.Dents.CullDistance gives it. 0: no limit.

int32 GetMaxDentedBodies()
C++ ONLY

How many bodies draw dents and scratches, as Crushform.Dents.MaxBodies gives it. 0: no limit.

float GetDirtCullDistance()
C++ ONLY

How far from the camera dirt is drawn, in cm, as Crushform.Dirt.CullDistance gives it. 0: no limit.

int32 GetMaxDirtyBodies()
C++ ONLY

How many bodies draw dirt, as Crushform.Dirt.MaxBodies gives it. 0: no limit.

Properties

float DentCullDistance = 0.0f

How far from the camera a body's dents and scratches are drawn, in cm. Past it the body is drawn whole, and it shows them again when it comes closer. Only the drawing stops: the lattice, the collision, replication and the damage events go on. 0: no limit. Local to this machine. Crushform.Dents.CullDistance or a device profile overrides it.

Default
0.0f
Category
Culling
int32 MaxDentedBodies = 0

How many bodies draw dents and scratches: the nearest, those on screen first, looked at a few times a second. Only the drawing stops for the others. 0: no limit. Local to this machine. Crushform.Dents.MaxBodies or a device profile overrides it.

Default
0
Category
Culling
float DirtCullDistance = 0.0f

How far from the camera a body's dirt is drawn, on the body and on its wheels, in cm. Past it they are drawn clean, and show their dirt again when they come closer. While it is culled the body's dirt stands still on this machine: it neither gathers nor fades, and moves on when the body is shown again. A wash, a fill or added dirt still applies. 0: no limit. Local to this machine. Crushform.Dirt.CullDistance or a device profile overrides it.

Default
0.0f
Category
Culling
int32 MaxDirtyBodies = 0

How many bodies draw dirt: the nearest, those on screen first, looked at a few times a second. The dirt of the others stands still on this machine, as past Dirt Cull Distance. 0: no limit. Local to this machine. Crushform.Dirt.MaxBodies or a device profile overrides it.

Default
0
Category
Culling
TSoftObjectPtr<UTexture> Atlas

RGBA8 texture every deformed mesh samples, without mips or sRGB: a render target, or a NeverStream uncompressed Texture2D. Its size decides how many slots there are.

Category
Atlas
int32 SlotWidth = 256

Texels across one slot. A lattice fits when ResX * ResZ <= SlotWidth. Slots tile the atlas; the shader reads each slot's origin from Custom Primitive Data.

Default
256
Category
Atlas
int32 SlotHeight = 8

Texel rows of one slot. A lattice fits when ResY <= SlotHeight.

Default
8
Category
Atlas
int32 CustomDataOffset = 0

First Custom Primitive Data index Crushform writes; it uses 18 floats from there. The editor rebuilds the material functions that bake it when it changes (Crushform.RebakeOffsets does it by hand); save them to keep it.

Default
0
Category
Atlas
int32 WheelCustomDataOffset = 34

First Custom Primitive Data index of a wheel mesh's four dirt channels and their layer ranks (CF::WheelData). A separate offset: a wheel never carries the deformed block, and its tyre often carries other data from index 0 (tyre deformation does), so the default is the last two floats. The editor rebuilds the material functions that bake it when it changes (Crushform.RebakeOffsets does it by hand); save them to keep it.

Default
34
Category
Atlas
int32 TireCustomDataOffset = 0

First Custom Primitive Data index of a tyre mesh's contact records (CF::TireData, 32 floats). A tyre never carries the deformed block, but it must not overlap the wheel's dirt block at Wheel Custom Data Offset (the default 0..31 clears 34..35). The editor rebuilds the material functions that bake it when it changes (Crushform.RebakeOffsets does it by hand); save them to keep it.

Default
0
Category
Atlas
int32 GlassCustomDataOffset = 18

First Custom Primitive Data index of a glass pane's cracks (CF::GlassData, 16 floats); a pane is a deformed mesh too, so it must not overlap the 18 floats from Custom Data Offset. The editor rebuilds the material functions that bake it when it changes (Crushform.RebakeOffsets does it by hand); save them to keep it.

Default
18
Category
Atlas
int32 MaxReportsPerBatch = 8

Reports a driving client sends in one batch per frame; the server rejects the rest of a bigger batch.

Default
8
Category
Network
float MaxReportsPerSecond = 60.0f

Reports per second the server accepts from one component. The sender spends from a bucket this deep; the server's is 1.5 times deeper, as network jitter bunches reports the sender spaced out.

Default
60.0f
Category
Network
float ScrapeReportInterval = 0.1f

Seconds between two scrape reports of one component.

Default
0.1f
Category
Network
float MaxScrapeDt = 0.25f

Longest slide one scrape report may stand for, seconds.

Default
0.25f
Category
Network
float PendingReportTimeout = 10.0f

Seconds a client keeps a predicted hit the server neither confirmed nor rejected.

Default
10.0f
Category
Network
float ContactGapSeconds = 0.1f

Seconds a body may go without a hit from another body before its next hit counts as a new contact, which can dent. A body lying on another is hit every physics step with several weights of solver push-out; those hits are one contact and, once its crash window has passed, dent only on a spike. A frame longer than this (a hitch) stretches it past the frame.

Default
0.1f
Category
Contact
float ContactSpikeRatio = 2.0f

How many times harder than the contact's running level a hit must be to dent again within the same contact: a crash on top of a rest. It opens a crash window of its own.

Default
2.0f
Category
Contact
float ContactImpactWindowSeconds = 0.25f

Seconds from the start of a contact, or from a spike in it, in which every hit still dents: the crash itself dents on every physics step it spans. Past it a contact at rest (lying, pressing) dents only on a spike.

Default
0.25f
Category
Contact
float ContactRestingSpeed = 0.5f

Metres per second of relative speed at the contact point below which a steady contact is at rest and stops denting. A body lying or pressing on another barely moves against it; one sweeping past (a vehicle running a door shut) keeps denting on every step, as a crash does.

Default
0.5f
Category
Contact
float AutoRepairDelay = 0.0f

Seconds after its latest damage a body repairs itself on every machine, as Repair does; 0 never.

Default
0.0f
Category
Repair
TSoftObjectPtr<UCFSurfaces> Surfaces

One row per physical material: the dirt, the rolling sound and the rolling effect of each surface. Without it no body gets dirty.

Category
Surfaces
TSoftObjectPtr<UCFProfile> DefaultProfile

The deform profile for a body that names none; the vehicle adapter reads it.

Category
Profile
TSoftObjectPtr<UTextureRenderTarget2D> DirtAtlas

RGBA8 render target of the atlas's size: dust R, mud G, snow B, wet A, slot for slot with the lattice. Body materials must use the same one in MF_CF_Paint.

Category
Dirt
TSoftObjectPtr<UTextureRenderTarget2D> ScratchAtlas

RG8 render target of the atlas's size: scratch cover R and direction G, slot for slot with the lattice. Body materials must use the same one in MF_CF_Deform.

Category
Atlas
TSoftObjectPtr<UMaterialParameterCollection> DirtLook

The Material Parameter Collection the dirt functions read (MPC_CF_Dirt): the look of the dirt on every vehicle. The plugin ships the collection at this path and the dirt functions read it. Nothing in the runtime module loads it; it is here so that game code finds it, and sets its parameters by the names of CF::DirtLook.

Category
Dirt
float DirtUpdateInterval = 0.2f

Seconds between two dirt updates of one body.

Default
0.2f
Category
Dirt
float DirtReferenceSpeed = 8.0f

Tyre speed at which a surface's rates apply as written, m/s.

Default
8.0f
Category
Dirt
float MaxDirtSpeedScale = 2.0f

Most a faster tyre multiplies the rates by.

Default
2.0f
Category
Dirt
FCFDirtChannelSettings DustChannel

The dust channel: its name, how it stacks with the other channels and how fast it clears.

Category
Dirt|Channels
FCFDirtChannelSettings MudChannel

The mud channel: its name, how it stacks with the other channels and how fast it clears.

Category
Dirt|Channels
FCFDirtChannelSettings SnowChannel

The snow channel: its name, how it stacks with the other channels and how fast it clears.

Category
Dirt|Channels
FCFDirtChannelSettings WetChannel

The wet channel: its name, how it stacks with the other channels and how fast it clears.

Category
Dirt|Channels
ECFDirtLayerOrder DirtLayerOrder = ECFDirtLayerOrder::Fixed

What decides which layer lies above which: each channel's Z Order, or the layer that gained dirt most recently. Overlay channels always lie above every layer. Most Recent On Top needs the Dirt Fresh Atlas.

Default
ECFDirtLayerOrder::Fixed
Category
Dirt|Channels
TSoftObjectPtr<UTextureRenderTarget2D> DirtFreshAtlas

RGBA8 render target of the dirt atlas's size that records, per texel and channel, how recently the channel gained dirt, in the channel order of the Dirt Atlas. Read only when Dirt Layer Order is Most Recent On Top.

Category
Dirt
float DirtEventInterval = 0.5f

Shortest pause, s, between two dirt-changed events of one body.

Default
0.5f
Category
Dirt|Events
float DirtEventThreshold = 0.02f

How much the mean dirt of any side of a body, in any channel, must have changed since the last event, 0..1, for the next one to fire.

Default
0.02f
Category
Dirt|Events
TSoftObjectPtr<UMaterialFunctionInterface> BodyDirtLook

Material function that replaces the look of a body's dirt (MF_CF_Paint) in the project's materials. Its inputs are named after the pins of MF_CF_Paint (Base Color, Roughness, Metallic) and of MF_CF_DirtAmount, plus Normal (the material's own normal, or a flat one where it has none); its outputs after the pins it replaces, plus Normal, which takes the place of the material's normal. Base Color is required. Pin names are matched as written: case does not matter, spaces do. Unset: the built-in look.

Category
Look
TSoftObjectPtr<UMaterialFunctionInterface> WheelDirtLook

Material function that replaces the look of a wheel's dirt (MF_CF_WheelDirt). Its inputs are named after the pins of MF_CF_WheelDirt (Base Color, Roughness, Metallic) and of MF_CF_WheelDirtAmount, plus Normal (the material's own normal, or a flat one where it has none); its outputs after the pins it replaces, plus Normal, which takes the place of the material's normal. Base Color is required. Pin names are matched as written: case does not matter, spaces do. Unset: the built-in look.

Category
Look
TSoftObjectPtr<UMaterialFunctionInterface> GlassCrackLook

Material function that replaces the look of a glass pane's cracks (MF_CF_GlassCrack). Its inputs are named after the pins of MF_CF_GlassCrack (Base Color, Roughness, Opacity, Normal) and of MF_CF_GlassCrackData, its outputs after the pins it replaces; Opacity is required. Pin names are matched as written: case does not matter, spaces do. Unset: the built-in look.

Category
Look
TSoftObjectPtr<UNiagaraSystem> DefaultGlassShardSystem

The Niagara system that throws the shards of a glass pane whose definition names no Shard System. It must expose the shard parameters of the plugin's NS_CF_GlassShards and the mesh slots User.CF_ShardMesh0 to User.CF_ShardMesh5, the six the plugin's default system has: a definition's seventh distinct shard mesh and those after it reuse these slots.

Category
Glass
FName LoosePartCollisionProfile

Collision profile a hinged part takes once it swings or came off. None (Reset to Default) uses the plugin's own collision, which needs nothing from the project (see GetLoosePartCollision). A profile given here should block the world and ignore pawns. Whatever it says about vehicles, the hinge makes the part block them one-way: they hold it up and push it aside, and feel nothing back.

Category
Loose Parts
float SwingDamping = 1.0f

Damping of a swinging part about its hinge, as the joint's twist velocity drive. It damps the Swing Spring too: the drive has one Damping for both.

Default
1.0f
Category
Loose Parts
float SwingSpring = 0.0f

Spring that pulls a swinging part back to its closed pose, as the stiffness of the joint's twist drive, whatever its mass (an acceleration drive, scaled by p.Chaos.JointConstraint.AngularDriveStiffnessScale, 1.5). Chaos scales it by the part's inertia about its centre while the part turns about its pin: a door or hood hinged at its edge turns back at about a quarter of 1.5 times this, rad/s^2 per radian open (natural frequency about half the square root of 1.5 times this, rad/s), damped by Swing Damping. A part its weight closes, a hood, needs none; a door on an upright pin stays where it swung without one; a part that hangs open on one mount, a bumper, is pulled back up by one. Joints made after a change take it. 0: no spring.

Default
0.0f
Category
Loose Parts
float StopBounce = 0.0f

How lively a swinging part's stops are, both ends of its travel (the joint has one twist limit for both). 0: the engine's stop, which holds the part dead. Above it the stop is a spring the part sinks past before it is thrown back: at barely 0.05 of its speed just above 0, about a quarter at 0.66, about half at 1, where a door slammed at 180 deg/s first goes 4 deg past closed (15 deg at 720 deg/s). The open end overshoots too: at 0.66 a door thrown wide at 180 deg/s goes about 1.3 deg past its Open Angle. A hood resting on its stop sinks into it a little: 0.2 deg at 0.66, 0.9 deg at 1. Joints made after a change take it.

Default
0.0f
Category
Loose Parts
float BumpResponse = 0.0f

Extra push a swinging part gets when its body jolts: this many times the turn the body's acceleration at the pin gives the part about its pin, on top of what physics gives it. 0: physics only. Only on the machine that simulates the body, its impact source: where the body is played back, its network corrections would read as jolts. Read from the body's motion on the game thread: under async physics the push follows the jolt by the read lag, a few fixed steps (p.AsyncInterpolationMultiplier), while physics' own share comes at once. A steady acceleration pushes too: a hood lifts while its body falls in a jump. A part that swings harder gathers its Shake Off Travel sooner. Read every frame: a change takes effect at once.

Default
0.0f
Category
Loose Parts
float SwingStartKick = 90.0f

Angular speed, deg/s, a part gets towards its open side when it starts to swing, so that it comes ajar.

Default
90.0f
Category
Loose Parts
float SwingSettleTime = 1.0f

Seconds a part that has just started to swing keeps a joint that cannot tear, and cannot be shaken off: the crash that loosened it never also tears its joint. It does not delay a dent: a part crushed past a detach threshold comes off at once. After it, a blow can tear the joint of a part that hangs, and shaking can take it off.

Default
1.0f
Category
Loose Parts
float ArmLoadShare = 0.5f

Share of a hinge's Break Force and Break Torque its joint may carry and still be armed when the settle time ends. A joint carrying more stays unarmed, and arms once it has carried no more for a quarter of a second (CFHinge::ArmQuietTime): a part pinned in place by something pressing on it keeps hanging, rather than tearing the moment the settle time ends. Keep it below 1, so that a load just under the thresholds does not arm a joint that tears a frame later. 0 arms without reading the load.

Default
0.5f
Category
Loose Parts
float TornPartHoldMargin = 20.0f

How close, cm, another vehicle must be to the closed place of a part torn off by a dent to keep the part there. A crash dents the body before the other vehicle reaches the part; let go while it is still at the part, the part came off between two bodies both infinitely heavy to it and was shot out or wedged into its own body. The part falls the frame that vehicle has moved farther off, a frame or two in a crash. 0: kept only while a vehicle touches its place or closes in on it within Torn Part Hold Lookahead, or something stands in the place. Only vehicles count for the margin: the ground under a low part or a wall the car rests against never moves off.

Default
20.0f
Category
Loose Parts
float TornPartHoldLookahead = 0.05f

Seconds ahead a vehicle closing in on a torn-off part counts as at it already: the margin grows by its closing speed times this. A crash's contact comes up before the bodies meet: the other car can still be over 20 cm off the door when the dent tears it off, and be at it a few milliseconds later. A vehicle moving off counts at the margin alone.

Default
0.05f
Category
Loose Parts
float DetachedLifetime = 60.0f

Seconds a part that came off lies before it sinks.

Default
60.0f
Category
Loose Parts
float DetachedSinkTime = 2.0f

Seconds a part takes to sink into the ground by its own height and hide.

Default
2.0f
Category
Loose Parts
float CollisionRebuildThreshold = 2.0f

A dented body's collision is built again once a lattice node on a box's or convex's surface, or a point of a sphere or capsule, has moved this far, cm, since the last build.

Default
2.0f
Category
Collision
float CollisionRebuildInterval = 0.5f

Shortest pause, s, between two builds of one body's collision. A dent that comes sooner waits for the rest of it.

Default
0.5f
Category
Collision
float CollisionBlockTolerance = 1.5f

A dented body's box or convex is cut into collision blocks where the lattice bends it further than this, cm, from what its corners alone make of it.

Default
1.5f
Category
Collision
int32 MaxCollisionBlocks = 96

Most collision blocks the boxes and convexes of one body are cut into. At or below their count nothing is cut: one hull each.

Default
96
Category
Collision
bool bDeformCollision = true

Whether collision follows dents at all in this project: the body's blocks, the cut for a torn part and a loose part's dented hull. Off, every vehicle keeps its authored collision whatever its profile says, and dents are only drawn. A profile's Deform Collision can still turn it off for one vehicle. Read when a vehicle's play begins. The project value of `Crushform.Collision.Deform`; a device profile or the console overrides it.

Default
true
Category
Collision
int32 CollisionDeferFrames = 1

Frames a heavy collision build may run off the game thread before it must be on the body, 0 or 1: the cut for a torn part, the body's rebuild after a dent and a torn part's hull. 0 builds everything in the frame of the hit. At 1 hinged parts are reviewed in the frame after the hit, and the body's rebuild and cut are on the body before the next frame's physics, which waits for what the worker has left; a build asked for while another runs starts when that one lands and takes its own frame, and a torn part's hull lands after physics. A value above 1 reads as 1: a physics step on the shapes before the dent gives a body squeezing another against the ground a second push. With async physics a hit can reach the game thread after the next step has started, at either value, when frames are no shorter than the physics step. The project value of `Crushform.Collision.DeferFrames`; a device profile or the console overrides it.

Default
1
Category
Collision