Struct SceneFrame 

#[non_exhaustive]
pub struct SceneFrame {

    pub generation: u64,
    pub surfaces: SurfaceSubmission,
    pub point_clouds: Vec<PointCloudItem>,
    pub glyphs: Vec<GlyphItem>,
    pub polylines: Vec<PolylineItem>,
    pub volumes: Vec<VolumeItem>,
    pub isolines: Vec<IsolineItem>,
    pub streamtube_items: Vec<StreamtubeItem>,
    pub camera_frustums: Vec<CameraFrustumItem>,
    pub screen_images: Vec<ScreenImageItem>,
    pub gpu_implicit: Vec<GpuImplicitItem>,
    pub gpu_mc_jobs: Vec<GpuMarchingCubesJob>,
    pub lic_items: Vec<SurfaceLICItem>,
    pub transparent_volume_meshes: Vec<TransparentVolumeMeshItem>,
    pub volume_mesh_items: Vec<VolumeMeshItem>,
    pub tube_items: Vec<TubeItem>,
    pub image_slices: Vec<ImageSliceItem>,
    pub tensor_glyphs: Vec<TensorGlyphItem>,
    pub ribbon_items: Vec<RibbonItem>,
    pub volume_surface_slices: Vec<VolumeSurfaceSliceItem>,
    pub sprite_items: Vec<SpriteItem>,
    pub gaussian_splats: Vec<GaussianSplatItem>,
}

World-space scene content for one frame.

Groups all renderable world-space content submitted to the renderer. Surfaces are submitted through SurfaceSubmission; scientific visualization primitives sit alongside them.

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.

generation: u64

Scene version counter from Scene::version(). Default: 0 (triggers rebuild on first frame).

The renderer uses this to skip batch rebuild and GPU upload when scene content has not changed since the previous frame.

surfaces: SurfaceSubmission

Surface geometry submission (opaque and transparent meshes).

point_clouds: Vec<PointCloudItem>

Point cloud items to render this frame.

glyphs: Vec<GlyphItem>

Instanced glyph items to render this frame.

polylines: Vec<PolylineItem>

Polyline (streamline) items to render this frame.

volumes: Vec<VolumeItem>

Volume items to render this frame via GPU ray-marching.

isolines: Vec<IsolineItem>

Isoline (contour line) items to render on mesh surfaces.

streamtube_items: Vec<StreamtubeItem>

Streamtube items to render this frame.

camera_frustums: Vec<CameraFrustumItem>

Camera frustum wireframe items to render this frame (Phase 10).

screen_images: Vec<ScreenImageItem>

Screen-space image overlay items to render this frame (Phase 10).

gpu_implicit: Vec<GpuImplicitItem>

GPU implicit surface items to render this frame (Phase 16).

gpu_mc_jobs: Vec<GpuMarchingCubesJob>

GPU marching cubes jobs to dispatch this frame (Phase 17).

lic_items: Vec<SurfaceLICItem>

Surface LIC items to render this frame (Phase 4).

transparent_volume_meshes: Vec<TransparentVolumeMeshItem>

Transparent unstructured volume meshes rendered via projected tetrahedra (Phase 6).

volume_mesh_items: Vec<VolumeMeshItem>

Opaque volume mesh items submitted for cell-level picking.

Each entry enables SubObjectRef::Cell hits from renderer.pick() and renderer.pick_rect() for the mesh identified by pick_id. The item’s face_to_cell map (from upload_volume_mesh_data) converts surface triangle hits to originating cell indices.

Rendering still goes through surfaces; submit the SceneRenderItem from VolumeMeshItem::to_render_item() there as normal.

tube_items: Vec<TubeItem>

General tube items to render this frame (Phase 3).

image_slices: Vec<ImageSliceItem>

2D image slice items to render this frame (Phase 3).

tensor_glyphs: Vec<TensorGlyphItem>

Tensor glyph items to render this frame (Phase 5).

ribbon_items: Vec<RibbonItem>

Ribbon items to render this frame (Phase 8.1).

volume_surface_slices: Vec<VolumeSurfaceSliceItem>

Volume surface slice items to render this frame (Phase 10).

sprite_items: Vec<SpriteItem>

Billboard sprite items to render this frame.

gaussian_splats: Vec<GaussianSplatItem>

Gaussian splat items to render this frame.

Implementations

impl SceneFrame

pub fn new(surfaces: SurfaceSubmission) -> Self

Build a scene frame from a surface submission.

pub fn from_surface_items(items: Vec<SceneRenderItem>) -> Self

Build a scene frame from a flat list of surface render items.

The Vec is converted to an Arc<[SceneRenderItem]> so callers that submit the same list repeatedly can cheaply clone the Arc instead of cloning the underlying data.

pub fn from_shared_items(items: Arc<[SceneRenderItem]>, generation: u64) -> Self

Build a scene frame from an already-allocated shared slice.

Use this variant when you cache render items across frames:

// First frame / on change: rebuild the Arc once.
self.items_arc = Arc::from(scene.collect_render_items(&sel));

// Every frame: zero-cost clone.
SceneFrame::from_shared_items(Arc::clone(&self.items_arc), scene.version())

pub fn from_scene(scene: &mut Scene, selection: &Selection) -> Self

Build a scene frame by collecting render items from a Scene.

Calls Scene::collect_render_items and stamps generation with the current scene version so the renderer can skip batch rebuilds on unchanged frames.

This is the preferred constructor for the common single-viewport path. Use SceneFrame::from_surface_items when you need to assemble render items manually.

Trait Implementations

impl Default for SceneFrame

fn default() -> Self

Returns the “default value” for a type.