Struct Room 

pub struct Room {
    pub asset_id: AssetId,
    pub half_width: f32,
    pub half_depth: f32,
    pub ceiling_height: f32,
    pub texture: Option<TextureHandle>,
    pub wall_texture: Option<TextureHandle>,
    pub floor_texture: Option<TextureHandle>,
    pub ceiling_texture: Option<TextureHandle>,
    pub locator: Option<PayloadLocator>,
}

A self-contained room (floor, ceiling, four walls), with optional texturing.

Prefer Room over a ProceduralMesh (generator "room") + Prop pair for a shorter declaration. The room is placed at the world origin.

Dimensions can be given as size: [width, depth, height] (full extents) or as half_width, half_depth, and ceiling_height individually.

texture, wall_texture, floor_texture, and ceiling_texture are checked in that order; the first set value wins. Generator names such as "brick" or "concrete" resolve to a matching Texture at build time.

Fields

asset_id: AssetId

Assigned by the loader; not authored.

half_width: f32

Half the room’s width in world units.

half_depth: f32

Half the room’s depth in world units.

ceiling_height: f32

Floor-to-ceiling height in world units.

texture: Option<TextureHandle>

Texture applied to every surface unless a surface overrides it.

wall_texture: Option<TextureHandle>

Texture for the four walls.

floor_texture: Option<TextureHandle>

Texture for the floor.

ceiling_texture: Option<TextureHandle>

Texture for the ceiling.

locator: Option<PayloadLocator>

The generated geometry’s place in the blob, injected at load.

Implementations

impl Room

pub fn effective_texture(&self) -> Option<TextureHandle>

Returns the first set texture reference across all texture fields.

impl Room

pub fn bake(args: Room) -> Self

Translate the authored args into the runtime room: resolve the size shorthand into half extents. Run by cook at build time (the baked blob record carries the result).

Trait Implementations

impl Component for Room

const NAME: &'static str = "Room"

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_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 Room

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 Room

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Room

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Room> for ComponentAsset

fn from(c: Room) -> Self

Converts to this type from the input type.

impl RuntimeComponent for Room

impl Serialize for Room

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

where __S: Serializer,

Serialize this value into the given Serde serializer.