Struct VolumeMeshItem 

#[non_exhaustive]
pub struct VolumeMeshItem {
    pub boundary_mesh_id: MeshId,
    pub face_to_cell: Vec<u32>,
    pub projected_tet_id: Option<ProjectedTetId>,
    pub volume_mesh_data: Option<Arc<VolumeMeshData>>,
    pub model: [[f32; 4]; 4],
    pub settings: ItemSettings,
    pub material: Material,
    pub active_attribute: Option<AttributeRef>,
    pub scalar_range: Option<(f32, f32)>,
    pub colourmap_id: Option<ColourmapId>,
    pub transparency: Option<VolumeTransparency>,
}

An unstructured volume mesh submitted for one frame.

A volume mesh has two render modes that share the same source data (VolumeMeshData):

1. Boundary surface (default). transparency: None. The renderer draws the extracted boundary as a standard surface mesh: full Material support (shading, textures, shadows), per-frame colourmap lookup, selection outline, face- and cell-level picking. This is the cheap and most common mode.
2. Volumetric (transparent). transparency: Some(VolumeTransparency { .. }). The renderer rasterises every interior cell through the projected-tetrahedra pipeline and integrates Beer-Lambert opacity along view rays. Use this when you need to see through the volume. Requires the item to have been uploaded via upload_volume_mesh_with_transparency so projected_tet_id is populated; otherwise the transparency request is silently ignored.

Typical usage:

// Cheap path: boundary only.
let item = resources.upload_volume_mesh(&device, &data)?;
scene.volume_meshes.push(item);

// Volumetric path: opt in to transparency support at upload time.
let mut item = resources.upload_volume_mesh_with_transparency(
    &device, &queue, data, "pressure",
)?;
item.transparency = Some(VolumeTransparency { density: 2.0, ..Default::default() });
scene.volume_meshes.push(item);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

boundary_mesh_id: MeshId

GPU mesh slot for the extracted boundary surface.

Always populated. Used for the opaque draw, the selection-outline mask, and face- or cell-level picking via face_to_cell.

face_to_cell: Vec<u32>

Maps each boundary triangle to its originating cell index.

face_to_cell[face_index] is the cell index in the original VolumeMeshData::cells array. Used to convert a SubObjectRef::Face pick hit into a cell index.

projected_tet_id: Option<ProjectedTetId>

Projected-tet GPU handle. None for items uploaded via upload_volume_mesh (boundary-only path); Some(_) for items uploaded via upload_volume_mesh_with_transparency.

Transparency requires this to be Some. The handle is crate-internal, produced by the upload helper.

volume_mesh_data: Option<Arc<VolumeMeshData>>

CPU-side volume mesh data used for interior-inclusive cell picking when transparency is active.

Populated by upload_volume_mesh_with_transparency. Without it, transparent items still render but cell-level picking via renderer.pick() falls back to face-on-boundary hits only.

model: [[f32; 4]; 4]

World-space model matrix. Default: identity.

settings: ItemSettings

Per-item render settings (visibility, opacity, pick identity, selection state).

material: Material

Per-object material. Consumed only by the boundary-surface render path. The projected-tet path uses the colourmap LUT and ignores Material.

active_attribute: Option<AttributeRef>

Named scalar or colour attribute to colour the boundary surface by.

scalar_range: Option<(f32, f32)>

Explicit scalar range (min, max). None = use the range computed at upload. Applies to both render paths.

colourmap_id: Option<ColourmapId>

Colourmap. Used by the boundary-surface path when active_attribute is set, and by the projected-tet path for the volumetric LUT lookup.

transparency: Option<VolumeTransparency>

Volumetric render mode. None = render the boundary as a surface mesh (default); Some(_) = render through the interior via projected tetrahedra (requires projected_tet_id to be set).

Implementations

impl VolumeMeshItem

pub fn new(boundary_mesh_id: MeshId, face_to_cell: Vec<u32>) -> Self

Construct a boundary-only volume mesh item.

Prefer using upload_volume_mesh which returns a fully populated item. This constructor is provided for host code that already has a MeshId and face_to_cell map (for example after a clipped re-upload).

pub fn to_render_item(&self) -> SceneRenderItem

Build the SceneRenderItem that the boundary-surface pipeline consumes.

Used internally by the renderer when transparency is None, and by selection-outline / wireframe passes regardless of render mode. Host code does not usually need to call this.

pub fn cell_for_face(&self, face_index: u32) -> Option<u32>

Look up the cell index for a boundary face hit.

Returns None if face_index is out of range.

pub fn update_mesh(&mut self, boundary_mesh_id: MeshId, face_to_cell: Vec<u32>)

Replace the boundary mesh ID and face-to-cell map, for example after a clipped re-upload via replace_clipped_volume_mesh.

Trait Implementations

impl Clone for VolumeMeshItem

fn clone(&self) -> VolumeMeshItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.