Enum MeshRef 

pub enum MeshRef {
    Procedural {
        kind: ProceduralMeshKind,
        params: [f32; 4],
        uuid: AssetUUID,
    },
    Asset(AssetUUID),
}

Authored reference to a mesh — the only serialized mesh form.

The enum is the discriminator: Procedural carries the primitive kind and its generator parameters; Asset carries the stable UUID of an imported mesh in the VFS.

Both arms carry an identity UUID — the content-derived UUID for Procedural, the stable asset UUID for Asset. The resolver compares this against the resolved handle’s UUID every tick: a mismatch (or a missing handle) means the authored reference changed and must be re-resolved. The Procedural UUID is never serialized; it is recomputed from kind + params on deserialize via MeshRef::procedural so it stays purely content-derived. Construct Procedural through MeshRef::procedural so the UUID and the parameters can never disagree.

Variants

Procedural

Procedural primitive — rebuilt from kind + params by the resolver. The uuid is content-derived; build via MeshRef::procedural.

Fields

kind: ProceduralMeshKind

Which procedural primitive to regenerate.

params: [f32; 4]

Generator parameters (kind-specific layout, padded with zeros).

uuid: AssetUUID

Content-derived identity UUID. Not serialized — recomputed on load.

Asset(AssetUUID)

Reference to an imported mesh asset in the VFS, resolved by UUID.

Implementations

impl MeshRef

pub fn procedural(kind: ProceduralMeshKind, params: [f32; 4]) -> MeshRef

Builds a Procedural reference, deriving its identity UUID from the primitive kind discriminant plus the raw parameter bytes. Identical procedural meshes get the same UUID, so they dedup to one resolved handle (and one GpuMesh). This is the SAME content hash the GPU projection keys on.

pub fn uuid(&self) -> AssetUUID

Returns the identity UUID: the content-derived UUID for Procedural, the stable asset UUID for Asset. The resolver compares this against the resolved handle’s UUID to detect an authored change.

pub fn unit_cube() -> MeshRef

A unit cube — the default authored mesh.

Trait Implementations

impl Clone for MeshRef

fn clone(&self) -> MeshRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for MeshRef

fn make_column() -> Box<dyn AnyVec>

where Self: Sized,

Creates this component’s empty storage column. Default: an AoS Vec<Self>.

fn push_into_column(self, column: &mut (dyn AnyVec + 'static))

where Self: Sized,

Appends self as a new row into its column.

fn copy_row_between( src: &(dyn AnyVec + 'static), src_row: usize, dst: &mut (dyn AnyVec + 'static), )

where Self: Sized,

Clones row src_row from src into dst (used when an entity migrates between pages on a structural change). Both columns are this component’s column type.

fn clone_from_column(column: &(dyn AnyVec + 'static), row: usize) -> Self

where Self: Sized,

Reads row row of column as an owned value — the uniform by-value access path that works for both AoS (clone the &T) and field-SoA (gather the fields) layouts. Used by World::clone_component, the Soa<T> query, and the serialization recipe.

fn set_in_column(self, column: &mut (dyn AnyVec + 'static), row: usize)

where Self: Sized,

Overwrites row row of column with self — the uniform by-value write path for both layouts (AoS assigns the slot; field-SoA scatters into the lanes). Used by World::set_component.

impl Debug for MeshRef

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

Formats the value using the given formatter.

impl From<SerializableMeshRef> for MeshRef

fn from(on_disk: SerializableMeshRef) -> MeshRef

Converts to this type from the input type.

impl PartialEq for MeshRef

fn eq(&self, other: &MeshRef) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MeshRef