Struct RectAreaLight 

pub struct RectAreaLight {
    pub centre: [f32; 3],
    pub normal: [f32; 3],
    pub half_size: [f32; 2],
    pub color: [f32; 3],
    pub intensity: f32,
    pub range: f32,
    pub two_sided: bool,
}

A rectangular area light: a glowing panel that lights the scene from its whole surface rather than from a single point.

Unlike a PointLight or SpotLight, the softness of the shadow terminator and the shape of the specular highlight follow the panel’s real dimensions, so a wide softbox wraps light around a surface and leaves a stretched rectangular reflection on glossy materials. Use it for windows, ceiling panels, screens, and practical lights.

The panel is positioned by centre, oriented by normal (the direction it emits), and sized by half_size, matching GlassPanel.

RectAreaLight {
    centre: [0.0, 3.0, -4.0],
    normal: [0.0, 0.0, 1.0],
    half_size: [1.5, 1.0],
    color: [1.0, 0.95, 0.85],
    intensity: 12.0,
    range: 18.0,
    ..Default::default()
};

Fields

centre: [f32; 3]

World-space position of the panel’s centre.

normal: [f32; 3]

Direction the panel emits. Normalised on load; defaults to +Z when degenerate.

half_size: [f32; 2]

Half-width and half-height of the panel, in world units.

color: [f32; 3]

Linear-space RGB colour of the light.

intensity: f32

Intensity multiplier applied to the colour.

range: f32

Maximum reach in world units; attenuation is zero at this distance.

two_sided: bool

When true the panel emits from both faces. A one-sided panel lights only the half-space its normal points into.

Trait Implementations

impl Clone for RectAreaLight

fn clone(&self) -> RectAreaLight

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RectAreaLight

const NAME: &'static str = "RectAreaLight"

The registry name a world authors this component under.

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

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for RectAreaLight

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

Formats the value using the given formatter.

impl Default for RectAreaLight

fn default() -> RectAreaLight

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RectAreaLight

where RectAreaLight: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<RectAreaLight> for ComponentAsset

fn from(c: RectAreaLight) -> ComponentAsset

Converts to this type from the input type.

impl RectAreaLightGeometry for RectAreaLight

fn unit_normal(&self) -> [f32; 3]

Unit-length emission direction, falling back to straight down when the authored normal is degenerate (the panel default emits downward).

impl RuntimeComponent for RectAreaLight

impl Serialize for RectAreaLight

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.