Struct RenderScene 

pub struct RenderScene {
    pub highlight: Vec<(String, String, bool)>,
    pub tint: Option<[f32; 4]>,
    /* private fields */
}

The scene: insertion-ordered solids + an exact name index (R8 — the getObjectByName heuristic-scoring lookup is replaced by this map).

Fields

highlight: Vec<(String, String, bool)>

A Work part’s CONTEXT scene only: the context faces drawn emphasised, (solid, face, selected) (else hovered). Set by EngineState::sync_context_highlight; the context render pass reads it.

tint: Option<[f32; 4]>

A Work part’s CONTEXT scene only: its colour and opacity (None: the default crate::render::WORK_PART_CONTEXT_RGBA). Set by EngineState::set_context_display; the context render pass reads it.

Implementations

impl RenderScene

pub fn new() -> Self

pub fn insert_solid(&mut self, solid: SolidDisplay)

Insert or replace a solid by name (replacement keeps insertion order — a boolean result reusing its target’s name stays in place).

pub fn clear(&mut self)

Drop every solid (the scene rebuild path clears then repopulates).

pub fn drain(&mut self) -> Vec<SolidDisplay>

Empty the scene, RETURNING every solid by value (the name index is cleared and the vec is mem::take-n out). The history-apply seam MOVES existing displays out this way to reinsert the reused ones without cloning their meshes — a scene-free crate::pipeline::SceneRunner delta is applied by draining then reinserting in snapshot order.

pub fn set_color_override( &mut self, name: &str, color: Option<[f32; 3]>, ) -> bool

Set (or clear) a solid’s metadata color override, bumping its revision so the renderer re-derives the base style. Returns false if unknown.

pub fn set_face_colors( &mut self, name: &str, colors: &[Option<[f32; 3]>], ) -> bool

Set the per-FACE colour overrides of solid name, face i taking colors[i] (faces past the slice are left alone), bumping the solid’s revision only when one changed. Returns false if the solid is unknown. A display-only body (the mesh import’s region view) colours its faces through this.

pub fn apply_metadata_colors( &mut self, lookup: impl Fn(&str) -> Option<[f32; 3]>, ) -> bool

Re-derive every solid’s and face’s base colour from the name-keyed metadata store — the ONE seam through which the durable color attribute reaches the display.

lookup maps an object NAME (a solid’s or a face’s) to its resolved colour. It returns None both for “no colour recorded” and for “the display setting is overriding model colours”, so this method needs to know about neither.

A SKETCH sheet’s own color_override is the synthesized crate::engine_state::SKETCH_SHEET_COLOR, not a metadata colour, and re-deriving it from a store that has no record for the sheet would blank it back to the global face colour — so it is left alone. The sketch’s color attribute (keyed by the sketch id, which is the sheet’s name) lands on the sheet’s FACES instead: a face override wins over the solid’s colour, and clearing the attribute clears the face overrides, which restores the synthesized sheet colour underneath.

A changed solid’s revision is bumped so the renderer re-uploads it — and ONLY when something actually changed. That no-op guarantee is load-bearing, not a nicety: this runs after EVERY history apply, and the R10 GPU-buffer reuse fast path keys off a stable revision.

pub fn set_visible(&mut self, name: &str, visible: bool) -> bool

Set a solid’s visibility (R11). Returns false if unknown.

pub fn visibility_revision(&self) -> u64

Monotonic counter of VISIBILITY changes — the cache key for anything derived from which bodies are shown.

Hiding a body is SESSION state: it writes no history, runs nothing, and lands no exact solid, so it moves none of the counters a derived drawing would otherwise key on. A drawing sheet draws “the solids visible in the scene” (sheets::project::sheet_solid_names), so its cached projection depends on this and nothing else could tell it.

Only a REAL change counts. EngineState::apply_view_display sets every solid’s visibility from the active PMI view’s hidden set on every activation, and almost all of those calls are no-ops; counting them would re-project the open sheet for nothing.

pub fn listing_json(&self) -> String

Scene enumeration for the host scene-tree panel (R11): names, kind, visibility, child face/edge/vertex counts — as JSON.

pub fn remove_solid(&mut self, name: &str) -> bool

Remove a solid by exact name.

pub fn solid(&self, name: &str) -> Option<&SolidDisplay>

pub fn prune_exact_solids(&mut self)

Drop every kept B-rep whose display is gone or now comes from a different handle. Called after a run’s displays are reconciled, so “the display’s handle” is that run’s.

pub fn set_exact_solid( &mut self, name: &str, handle: u32, solid: BrepSolid, ) -> bool

Record the B-rep the runner sent for name, when handle is still the one its display was tessellated from; false (and nothing kept) when the display has moved on since the request went out.

pub fn drop_exact_solid(&mut self, name: &str)

Forget the B-rep of name: its geometry changed under the SAME handle (an assembly solve re-poses a resident solid in place), so the next projection must ask again.

pub fn clear_exact_solids(&mut self)

Forget every B-rep: the handles they were keyed by belong to a runner that is gone (a cancel restarts its registry, which counts from one again) or to a document that was replaced.

pub fn exact_revision(&self) -> u64

See Self::exact’s revision counter.

pub fn exact_solid(&self, name: &str) -> Option<&BrepSolid>

The B-rep the displayed solid name was tessellated from, or None when the scene holds none for its CURRENT handle — a synthesized sketch sheet, or a solid whose topology did not reach this thread.

pub fn exact_solid_fingerprinted(&self, name: &str) -> Option<(&BrepSolid, u64)>

Self::exact_solid with its content fingerprint.

pub fn solid_mut(&mut self, name: &str) -> Option<&mut SolidDisplay>

pub fn solids(&self) -> &[SolidDisplay]

Insertion-ordered iteration (deterministic — drives draw order).

pub fn edge_polyline_world(&self, name: &str) -> Option<Vec<[f64; 3]>>

The world-space polyline of the first display edge named name across all solids (widened to f64), or None when no edge carries that exact name. The engine-native sketch pickEdges tool (S6b-2) uses this to fetch a picked scene edge’s geometry for projection into the sketch plane. There is no name index for edges (only solids), so this is a linear scan — fine for the interactive per-click use.

pub fn edge_solid_name(&self, name: &str) -> Option<&str>

The name of the solid owning the first display edge named name, or None (the companion of edge_polyline_world — the pickEdges tool stores it as external-ref metadata).

pub fn face_plane_world(&self, name: &str) -> Option<([f64; 3], [f64; 3])>

The world plane of the first display face named name across all solids, as (centroid, unit outward normal): the area-weighted centroid of the face’s mesh triangles and the normalized sum of their cross products. The watertight tessellation winds every face’s triangles by same_sense, so the cross-product sum IS the outward normal (the stored per-vertex normals are shading normals and can be blended at shared boundary vertices). This is what lets an extrude/revolve whose profile is a resident solid FACE (not a sketch) anchor its dimension gizmo — the engine’s dimension refs fall back to it (EngineState::lookup_profile_plane). Hidden solids count too: a hidden source solid still anchors the gizmo. None when no face carries that exact name, it has no triangles, or the triangles are degenerate (zero area). Linear scan like edge_polyline_world.

pub fn face_is_planar(&self, name: &str) -> bool

Whether the display face named name is PLANAR: every one of its mesh triangles’ normals is parallel to the face’s summed normal (within 1e-4 in the sine). A cylinder, cone or freeform face fails this; a face with no triangles is not planar either. Linear scan like face_plane_world — the 3D sketch editor asks this once per reference pick, never per frame.

pub fn is_empty(&self) -> bool

pub fn bbox(&self) -> Aabb

World bbox over every VISIBLE solid.

impl RenderScene

pub fn set_entity_visible( &mut self, solid: &str, kind: EntityKind, index: usize, visible: bool, ) -> bool

Show/hide ONE face/edge/vertex of a solid. False if the solid is unknown.

pub fn set_group_visible( &mut self, solid: &str, kind: EntityKind, visible: bool, ) -> bool

Show/hide a whole group (all faces / all edges / all vertices) of a solid. False if the solid is unknown.

pub fn entity_visible( &self, solid: &str, kind: EntityKind, index: usize, ) -> Option<bool>

Whether entity index of kind on solid is shown (None if unknown).

pub fn group_visibility( &self, solid: &str, kind: EntityKind, ) -> Option<GroupState>

The group tristate for solid’s kind (None if the solid is unknown).

Trait Implementations

impl Debug for RenderScene

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

Formats the value using the given formatter.

impl Default for RenderScene

fn default() -> Self

Returns the “default value” for a type.