Struct WaterSurface 

pub struct WaterSurface {

    pub asset_id: AssetId,
    pub centre: [f32; 3],
    pub extent: [f32; 2],
    pub subdivisions: u32,
    pub waves: Vec<WaterWave>,
    pub deep_colour: [f32; 3],
    pub shallow_colour: [f32; 3],
    pub depth_falloff_metres: f32,
    pub foam_width_metres: f32,
    pub foam_intensity: f32,
    pub fresnel_power: f32,
    pub roughness: f32,
    pub refraction_strength: f32,
    pub visible: bool,
}

A translucent animated water surface.

A flat, subdivided horizontal surface whose vertices ripple with summed waves. It refracts and reflects the scene, blends from a shallow to a deep colour with depth, and adds shoreline foam.

The surface is positioned by centre and sized by extent (XZ half-widths). The mesh itself is flat; all height variation comes from the animated waves.

WaterSurface {
    centre: [0.0, 0.4, 0.0],
    extent: [12.0, 8.0],
    subdivisions: 96,
    ..Default::default()
};

Fields

asset_id: AssetId

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

centre: [f32; 3]

World-space position of the surface’s centre.

extent: [f32; 2]

Half-width and half-depth of the surface [x, z], in world units.

subdivisions: u32

Grid subdivisions across the surface. Higher gives smoother waves. Clamped to [8, 255].

waves: Vec<WaterWave>

The waves summed to animate the surface (up to 4). Defaults to a single gentle wave.

deep_colour: [f32; 3]

Linear-space RGB colour of deep water.

shallow_colour: [f32; 3]

Linear-space RGB colour of shallow water near the shore.

depth_falloff_metres: f32

Depth over which the colour blends from shallow to deep, in metres.

foam_width_metres: f32

Width of the shoreline foam band, in metres.

foam_intensity: f32

Strength of the shoreline foam, in [0, 1].

fresnel_power: f32

Sharpness of the grazing-angle reflection. Higher confines reflections to steeper viewing angles.

roughness: f32

Surface roughness in [0, 1]. Higher gives blurrier reflections, and pushes a mirrored reflection further off its line with each wave: a near-mirror surface keeps its reflection almost still.

refraction_strength: f32

How strongly the surface bends the view of what’s beneath it.

visible: bool

When false the surface is skipped each frame.

Trait Implementations

impl Clone for WaterSurface

fn clone(&self) -> WaterSurface

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for WaterSurface

const NAME: &'static str = "WaterSurface"

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<WaterSurface, 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 WaterSurface

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for WaterSurface

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

Formats the value using the given formatter.

impl Default for WaterSurface

fn default() -> WaterSurface

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for WaterSurface

where WaterSurface: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<WaterSurface> for ComponentAsset

fn from(c: WaterSurface) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for WaterSurface

impl Serialize for WaterSurface

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.