Struct SceneFrame 

#[non_exhaustive]
pub struct SceneFrame {

    pub generation: u64,
    pub surfaces: SurfaceSubmission,
    pub point_clouds: Vec<PointCloudItem>,
    pub point_cloud_refs: Vec<PointCloudRefItem>,
    pub glyphs: Vec<GlyphItem>,
    pub glyph_set_refs: Vec<GlyphSetRefItem>,
    pub polylines: Vec<PolylineItem>,
    pub polyline_refs: Vec<PolylineRefItem>,
    pub volumes: Vec<VolumeItem>,
    pub isolines: Vec<IsolineItem>,
    pub streamtube_items: Vec<StreamtubeItem>,
    pub streamtube_refs: Vec<StreamtubeRefItem>,
    pub screen_images: Vec<ScreenImageItem>,
    pub gpu_implicit: Vec<GpuImplicitItem>,
    pub gpu_mc_jobs: Vec<GpuMarchingCubesJob>,
    pub volume_meshes: Vec<VolumeMeshItem>,
    pub tube_items: Vec<TubeItem>,
    pub tube_refs: Vec<TubeRefItem>,
    pub image_slices: Vec<ImageSliceItem>,
    pub tensor_glyphs: Vec<TensorGlyphItem>,
    pub tensor_glyph_set_refs: Vec<TensorGlyphSetRefItem>,
    pub ribbon_items: Vec<RibbonItem>,
    pub ribbon_refs: Vec<RibbonRefItem>,
    pub volume_surface_slices: Vec<VolumeSurfaceSliceItem>,
    pub sprite_items: Vec<SpriteItem>,
    pub sprite_set_refs: Vec<SpriteSetRefItem>,
    pub sprite_instance_set_refs: Vec<SpriteInstanceSetRefItem>,
    pub mesh_instances: Vec<MeshInstanceItem>,
    pub gpu_particle_systems: Vec<GpuParticleSystemItem>,
    pub gaussian_splats: Vec<GaussianSplatItem>,
    pub decals: Vec<DecalItem>,
    pub scatter_volumes: Vec<ScatterVolumeItem>,
    pub lights: Vec<LightSource>,
    pub plugin_items: HashMap<&'static str, Box<dyn PluginItemCollection>>,
}

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.

point_cloud_refs: Vec<PointCloudRefItem>

References to pre-uploaded point clouds.

glyphs: Vec<GlyphItem>

Instanced glyph items to render this frame.

glyph_set_refs: Vec<GlyphSetRefItem>

References to pre-uploaded glyph sets.

polylines: Vec<PolylineItem>

Polyline (streamline) items to render this frame.

polyline_refs: Vec<PolylineRefItem>

References to pre-uploaded polylines (one entry per draw). Each PolylineRefItem carries a handle into the renderer’s polyline store plus a per-frame model matrix and item settings.

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.

streamtube_refs: Vec<StreamtubeRefItem>

References to pre-uploaded streamtubes.

screen_images: Vec<ScreenImageItem>

Screen-space image overlay items to render this frame.

gpu_implicit: Vec<GpuImplicitItem>

GPU implicit surface items to render this frame.

gpu_mc_jobs: Vec<GpuMarchingCubesJob>

GPU marching cubes jobs to dispatch this frame.

volume_meshes: Vec<VolumeMeshItem>

Unstructured volume meshes submitted this frame.

Each VolumeMeshItem renders either as a boundary surface (default, through the standard mesh pipeline) or as a volumetric draw through projected tetrahedra (when VolumeMeshItem::transparency is set and the item was uploaded via upload_volume_mesh_with_transparency). Cell-level picking, selection outlines, and wireframe overlays are driven from this collection regardless of mode.

tube_items: Vec<TubeItem>

General tube items to render this frame.

tube_refs: Vec<TubeRefItem>

References to pre-uploaded tubes.

image_slices: Vec<ImageSliceItem>

2D image slice items to render this frame.

tensor_glyphs: Vec<TensorGlyphItem>

Tensor glyph items to render this frame.

tensor_glyph_set_refs: Vec<TensorGlyphSetRefItem>

References to pre-uploaded tensor glyph sets.

ribbon_items: Vec<RibbonItem>

Ribbon items to render this frame.

ribbon_refs: Vec<RibbonRefItem>

References to pre-uploaded ribbons.

volume_surface_slices: Vec<VolumeSurfaceSliceItem>

Volume surface slice items to render this frame.

sprite_items: Vec<SpriteItem>

Billboard sprite items to render this frame.

sprite_set_refs: Vec<SpriteSetRefItem>

References to pre-uploaded sprite sets (static billboards).

sprite_instance_set_refs: Vec<SpriteInstanceSetRefItem>

References to pre-uploaded sprite instance sets (entity sprites).

mesh_instances: Vec<MeshInstanceItem>

Mesh-instance batches to render this frame (mesh-based particles).

gpu_particle_systems: Vec<GpuParticleSystemItem>

GPU particle systems to advance and draw this frame.

gaussian_splats: Vec<GaussianSplatItem>

Gaussian splat items to render this frame.

decals: Vec<DecalItem>

Screen-space decal items to render this frame (D1).

scatter_volumes: Vec<ScatterVolumeItem>

Participating-media volumes (fog, smoke, clouds) to render this frame.

lights: Vec<LightSource>

Scene-graph light sources to union with EffectsFrame::lighting.lights.

Populate via crate::scene::scene::Scene::collect_lights. The renderer chains these with the frame-data lights before building the GPU uniform; consumers that use only EffectsFrame::lighting leave this empty.

plugin_items: HashMap<&'static str, Box<dyn PluginItemCollection>>

Plugin item collections, keyed by ItemTypePlugin::type_name.

Populated via Self::submit_plugin_items. Empty by default; the renderer iterates this map during prepare / paint and dispatches to the matching registered plugin. Entries whose type_name is not registered on the renderer are silently ignored.

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.

The frame’s generation defaults to 0. If items change every frame (e.g. from physics writeback or snapshot interpolation), chain with_generation to supply a value that changes with the content – otherwise the renderer’s instance-buffer cache will treat every frame as identical after the first upload:

// Static scene -- generation 0 is fine, items never change.
SceneFrame::from_surface_items(items)

// Dynamic scene -- pass a value that increments when content changes.
// scene.version() is the right source when writeback drives the items.
SceneFrame::from_surface_items(items).with_generation(scene.version())

pub fn with_generation(self, generation: u64) -> Self

Override the generation stamp on a scene frame.

The renderer compares generation against the previous frame to decide whether to rebuild and re-upload the instance buffer. A generation of 0 (the default for from_surface_items) causes the cache to hit on every frame after the first, freezing rendered objects even if item transforms have changed.

Pass any value that changes when content changes. scene.version() is the natural choice when items are derived from scene writeback.

pub fn submit_plugin_items<C: PluginItemCollection>( &mut self, type_name: &'static str, items: C, )

Submit a plugin item collection under type_name.

The renderer dispatches per-frame work and draw calls to the matching ItemTypePlugin registered with the same type_name. Submitting under a name that has no registered plugin is a no-op.

Calling this twice with the same name replaces the previous submission.

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.