Struct SdfVolume 

pub struct SdfVolume {

    pub asset_id: AssetId,
    pub centre: [f32; 3],
    pub extent: [f32; 3],
    pub fragment_shader: String,
    pub max_gradient: f32,
    pub max_steps: u32,
    pub max_distance: f32,
    pub params: [f32; 32],
    pub cast_shadows: bool,
    pub receive_shadows: bool,
    pub volumetric: bool,
    pub visible: bool,
    pub locator: Option<PayloadLocator>,
}

A raymarched signed-distance-field volume. It occupies a world-space bounding box; a user-authored fragment shader sphere-traces an SDF inside the box, composites correctly with the surrounding scene through the depth buffer, and shades hits with the engine’s lighting helpers.

The distance field is one .slang file for every backend. The build compiles it, so a field that does not compile fails cn build rather than the renderer, and a shipped player needs no shader compiler of its own.

SdfVolume {
    centre: [0.0, 2.0, -4.0],
    extent: [2.0, 2.0, 2.0],
    max_gradient: 1.0,
    max_steps: 64,
    max_distance: 12.0,
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

centre: [f32; 3]

World-space centre of the bounding box.

extent: [f32; 3]

XYZ half-widths of the bounding box. The raymarch is clipped to the box, so the SDF only has to be well-defined inside this region.

fragment_shader: String

Distance-field source path (e.g. "shaders/chrome_blob.slang"), resolved relative to the project’s assets/ at build time. The file defines map and shade, or sampleVolume for a volumetric volume.

max_gradient: f32

Worst-case gradient of the SDF, used to size the cone-march step. 1.0 is correct for any well-formed SDF; higher values shorten the step but stay safe. Must be > 0.

max_steps: u32

Maximum cone-march steps per pixel. Clamped to [8, 256].

max_distance: f32

Maximum march distance in metres. Must be ≥ 0.1.

params: [f32; 32]

Generic parameter block passed to the shader as a uniform buffer; the shader interprets it however it likes. Up to 32 values.

cast_shadows: bool

When true, the volume casts shadows onto the surrounding scene. Disable for translucent / volumetric effects that shouldn’t block light.

receive_shadows: bool

When true (the default), the volume is shadowed by the scene. Set to false for unlit / always-bright effects (energy fields, etc.).

volumetric: bool

When true, the volume renders as a participating medium (clouds, smoke, fog blobs, energy fields) instead of an opaque surface. The shader must define sampleVolume(p, params, time) returning per-point density, scattering colour, and emission instead of map / shade. Volumetrics never cast shadows (cast_shadows is forced off). The medium fills the whole bounding box, so don’t overlap it with geometry it should render behind.

visible: bool

When false the volume is skipped each frame.

locator: Option<PayloadLocator>

Injected at load time from the blob def. Carries the compiled distance field the build produced.

Implementations

impl SdfVolume

pub fn cone_ratio(&self) -> f32

Effective cone-march step ratio derived from the Lipschitz constant. A 1-Lipschitz SDF (gradient ≤ 1) cone-marches at ratio 1; larger gradients shorten the step proportionally.

Trait Implementations

impl Clone for SdfVolume

fn clone(&self) -> SdfVolume

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for SdfVolume

const NAME: &'static str = "SdfVolume"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<Self, 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_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.

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).

impl ComponentSlot for SdfVolume

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for SdfVolume

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

Formats the value using the given formatter.

impl Default for SdfVolume

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SdfVolume

where SdfVolume: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SdfVolume> for ComponentAsset

fn from(c: SdfVolume) -> Self

Converts to this type from the input type.

impl RuntimeComponent for SdfVolume

impl Serialize for SdfVolume

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

where __S: Serializer,

Serialize this value into the given Serde serializer.