Struct ReflectionProbe 

pub struct ReflectionProbe {
    pub position: [f32; 3],
    pub half_extents: [f32; 3],
}

A localized reflection probe. The renderer captures the surrounding scene into a cubemap from position and uses it for the specular reflection on glossy surfaces within the influence box (position plus or minus half_extents). The box is also the parallax-correction volume, so a reflection stays anchored to the surrounding geometry as the camera moves.

Place several across a level so reflections stay accurate as a first-person camera moves between areas (a room, a courtyard, a corridor): each surface uses the probe whose box it sits deepest inside, and cross-fades into the neighbouring box near a shared boundary so reflections don’t pop as the camera crosses between them. When a world declares no ReflectionProbe, the renderer auto-seeds a small grid of probes from the scene bounds, so existing scenes still get local reflections without authoring.

Reflections are most accurate near position; a tighter box around a distinct space (a room) parallax-corrects better than one large box. Boxes may overlap freely: a surface inside several boxes blends all of them, so reflections cross-fade smoothly as the camera moves between probes.

ReflectionProbe {
    position: [0.0, 1.7, 0.0],
    half_extents: [8.0, 4.0, 8.0],
    ..Default::default()
};

Fields

position: [f32; 3]

World-space capture point the cubemap is rendered from. Put it at roughly eye height in open space (not inside geometry) for the area it serves.

half_extents: [f32; 3]

Half-size of the influence box around position, per axis. A surface inside position plus or minus half_extents may select this probe, and the box is the parallax-correction volume. Make it span the local space the probe represents (e.g. a room’s walls).

Trait Implementations

impl Authored for ReflectionProbe

const TYPE: &'static str = "ReflectionProbe"

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

impl Clone for ReflectionProbe

fn clone(&self) -> ReflectionProbe

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for ReflectionProbe

const NAME: &'static str = "ReflectionProbe"

The registry name a world authors this component under.

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

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for ReflectionProbe

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

Formats the value using the given formatter.

impl Default for ReflectionProbe

fn default() -> ReflectionProbe

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReflectionProbe

where ReflectionProbe: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RuntimeComponent for ReflectionProbe

impl Serialize for ReflectionProbe

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.