Struct GlassPanel 

pub struct GlassPanel {
    pub asset_id: AssetId,
    pub centre: [f32; 3],
    pub normal: [f32; 3],
    pub half_size: [f32; 2],
    pub tint: [f32; 3],
    pub opacity: f32,
    pub refraction_strength: f32,
    pub fresnel_power: f32,
    pub visible: bool,
}

A flat translucent panel of coloured glass. A fixed-orientation rectangular quad that refracts and tints the scene behind it and brightens the grazing-angle rim with a Fresnel highlight.

Unlike WaterSurface it has no animation, no surface displacement, and no depth-based colour. It’s a simple building block for translucent surfaces such as windows, ice, holograms, or force fields.

The panel is positioned by centre, oriented by normal (the facing direction), and sized by half_size (half-width along the panel’s tangent, half-height along its bitangent).

GlassPanel {
    centre: [0.0, 2.0, -3.0],
    normal: [0.0, 0.0, 1.0],
    half_size: [2.0, 1.5],
    tint: [0.6, 0.85, 0.9],
    opacity: 0.45,
    refraction_strength: 0.04,
    ..Default::default()
};

Fields

asset_id: AssetId

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

centre: [f32; 3]

World-space position of the panel’s centre.

normal: [f32; 3]

Facing direction of the panel. Normalised on load; defaults to +Z when degenerate.

half_size: [f32; 2]

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

tint: [f32; 3]

Linear-space RGB colour the glass tints the scene behind it.

opacity: f32

How opaque the glass is, in [0, 1]. 0 = clear, 1 = fully opaque tint.

refraction_strength: f32

How strongly the glass bends the view of what’s behind it. 0 = no refraction.

fresnel_power: f32

Sharpness of the grazing-angle rim highlight. Higher values confine the brightening to steeper viewing angles.

visible: bool

When false the panel is skipped each frame.

Trait Implementations

impl Clone for GlassPanel

fn clone(&self) -> GlassPanel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for GlassPanel

const NAME: &'static str = "GlassPanel"

The registry name a world authors this component under.

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

impl ComponentSlot for GlassPanel

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 GlassPanel

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

Formats the value using the given formatter.

impl Default for GlassPanel

fn default() -> GlassPanel

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GlassPanel

where GlassPanel: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<GlassPanel> for ComponentAsset

fn from(c: GlassPanel) -> Self

Converts to this type from the input type.

impl GlassPanelGeometry for GlassPanel

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

Unit-length facing direction, falling back to +Z when the authored normal is degenerate. The build-time quad generator and the runtime shader both rely on a usable normal.

impl RuntimeComponent for GlassPanel

impl Serialize for GlassPanel

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.