Struct PhysicsConfig 

pub struct PhysicsConfig {
    pub floor_y: f32,
    pub terrain_half_width: f32,
    pub terrain_half_depth: f32,
    pub terrain_subdivisions: u32,
    pub terrain_amplitude: f32,
    pub terrain_offset_y: f32,
    pub terrain_mesh: Option<AssetId>,
    pub layers: Vec<String>,
    pub no_collide: Vec<[String; 2]>,
    pub contact_min_impulse: f32,
    pub spawn_headroom: u32,
}

Configures the world’s physics floor / terrain.

Optional: a world with physics bodies but no PhysicsConfig simulates over a flat floor at Y = 0, and receives one carrying these values at start so the settings are a component rather than a fallback. Physics runs whenever the world declares a PhysicsConfig, a RigidBody, a PropBody, a TriggerVolume, or a SkinnedMesh with a capsule. Declare a PhysicsConfig to put bodies on terrain or a non-zero floor.

For terrain-based outdoor scenes the terrain parameters must match the terrain mesh exactly.

PhysicsConfig {
    terrain_offset_y: -0.5,
    ..Default::default()
};

Fields

floor_y: f32

Y coordinate of the floor. When left at 0.0 it is auto-detected from the camera; set it explicitly to override.

terrain_half_width: f32

Half-width of the terrain mesh along X. Must match the terrain mesh. Leave at 0.0 (with terrain_subdivisions = 0) for flat-floor scenes.

terrain_half_depth: f32

Half-depth of the terrain mesh along Z. Must match the terrain mesh.

terrain_subdivisions: u32

Subdivision count of the terrain mesh. When 0, a flat floor at Y = 0 is used instead of a heightfield.

terrain_amplitude: f32

Height variation of the terrain mesh. Must match the terrain mesh.

terrain_offset_y: f32

World-space Y offset of the terrain: the height of the prop that renders the terrain mesh. Leave at 0.0 when the terrain sits at the origin.

terrain_mesh: Option<AssetId>

Name of a ProceduralMesh with generator: "heightfield". When set, the physics surface is built from that mesh’s source image so props rest on the visible terrain. Takes precedence over the terrain_* values above.

layers: Vec<String>

Extra collision layer names beyond the built-ins (world, prop, character, trigger). At most 28; referenced by collider layer fields and no_collide pairs.

no_collide: Vec<[String; 2]>

Unordered layer-name pairs that do not collide. Everything collides by default; each pair here disables collision (and contact solving) between its two layers symmetrically. Pairs naming character also filter the character controller’s movement.

contact_min_impulse: f32

Minimum contact impulse (mass times velocity change) for a collision to publish a contact event. Resting contact stays below it; raise to hear only hard impacts.

spawn_headroom: u32

Extra physics bodies reserved for props created while the world runs (by a Spawner, a Behavior spawn node, or the host). Physics reserves every body it will ever need when the world loads and never grows: once the declared bodies plus this many are live, a further spawn gets no physics body and is reported as an error.

This is a floor beneath what the build reserves on its own, not the whole reservation. Every Spawner whose interval and lifetime bound how many copies can be alive at once is already reserved for, and the larger of the two numbers wins. Set a value here for the sources the build cannot count: a Spawner with lifetime: 0 (its copies live forever), a spawn node in a behavior, and spawns the host drives itself.

Trait Implementations

impl Authored for PhysicsConfig

const TYPE: &'static str = "PhysicsConfig"

The registered asset type, as it appears in a world line’s type.

impl Clone for PhysicsConfig

fn clone(&self) -> PhysicsConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for PhysicsConfig

const NAME: &'static str = "PhysicsConfig"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<PhysicsConfig, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

fn inject_name(&mut self, _id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

impl ComponentSlot for PhysicsConfig

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<PhysicsConfig>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<PhysicsConfig>

Mutably borrow this type’s column out of the storage.

impl Debug for PhysicsConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for PhysicsConfig

fn default() -> PhysicsConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PhysicsConfig

where PhysicsConfig: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<PhysicsConfig, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RuntimeComponent for PhysicsConfig

impl Serialize for PhysicsConfig

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.