Struct Scene 

pub struct Scene {
    pub graph: Option<RenderGraph>,
    /* private fields */
}

The retained render graph of a window together with the hit targets built from it.

Fields

graph: Option<RenderGraph>

The retained render graph, or None before the first build.

Implementations

impl Scene

pub fn new() -> Scene

Creates an empty scene with no graph and no hit targets.

pub fn diagnostics(&self) -> &RenderDiagnostics

The diagnostics shared by the scene and its hit targets.

pub fn rebuild_from_applier(&mut self, applier: &MemoryApplier, root: NodeId)

Rebuilds the retained graph from the applier, reusing storage from the previous graph. The hit targets follow the new graph.

pub fn hit_targets(&self) -> Vec<HitRegion>

The hit targets in draw order, the last drawn at the end.

pub fn hit_storage(&self) -> HitStorage

How much storage the hit targets take.

pub fn update_from_applier( &mut self, applier: &MemoryApplier, root: NodeId, updates: &[(NodeId, NodeUpdate)], )

Applies content and layer-property changes to the retained graph. Empty updates or an unavailable scoped update rebuild the scene. The hit targets follow the graph when the update changed a hit target or the geometry above one: each updated layer compares its hit state, and the layers beneath one built again, before and after.

pub fn replace_graph(&mut self, graph: RenderGraph)

Replaces the retained render graph and leaves the hit targets as they are.

Trait Implementations

impl Default for Scene

fn default() -> Scene

Returns the “default value” for a type.

impl HitGraphSink for Scene

fn push_hit( &mut self, node_id: NodeId, capture_path: &[NodeId], geometry: HitGeometry<'_>, hit: &HitTestNode, )

Records an interactive node. capture_path lists the node first and then its pointer-input ancestors from the nearest outward, and geometry is in window space.

impl RenderScene for Scene

type HitTarget = HitRegion

The hit target type that hit testing returns.

fn clear(&mut self)

Removes the render graph and all hit targets.

fn hit_test(&self, x: f32, y: f32) -> Vec<<Scene as RenderScene>::HitTarget>

Performs hit testing at the given coordinates. Returns hit targets ordered by z-index (top-to-bottom).

fn hit_test_near( &self, x: f32, y: f32, ) -> Option<<Scene as RenderScene>::HitTarget>

The one target a press reaches when it misses every target but lands inside a small target grown to the minimum touch size: the nearest such target, and none when the point is outside every grown target.

fn find_target( &self, node_id: NodeId, ) -> Option<<Scene as RenderScene>::HitTarget>

Finds a hit target by NodeId with fresh geometry from the current scene.

fn hit_test_ray( &self, scene: NodeId, ray: Ray, ) -> Vec<<Scene as RenderScene>::HitTarget>

The hit targets on the mesh surfaces of the scene the node scene shows that ray reaches, in the space the scene’s eye stands in, ordered by z-index (top-to-bottom): a controller’s, a hand’s or a gaze’s, which need not start at the eye.

fn surface_windows(&self, visit: &mut dyn FnMut(NodeId, ProjectiveTransform))

Visits each mesh surface the eyes of the window’s scenes see, by its node, with the map from its content to the window as the eye shows it, through the doorways it lies behind: where the nodes on it show.

fn surface_window_bounds(&self, node_id: NodeId) -> Option<Rect>

Where the hit target of node_id shows in the window when it lies on a mesh surface of a 3D scene: its bounds as the scene’s camera shows them, also through a doorway and for an eye that walked through one. None for a flat target, a target behind the eye or no target.

fn node_window_bounds(&self, visit: &mut dyn FnMut(NodeId, Rect))

Visits each layout node the scene draws with the bounds of its rect in the window, through the graphics layers above it and its own, and on a mesh surface as the scene’s camera shows it: where it shows.

fn layer_moves(&self) -> u64

A count that grows when an update moves a layer in its parent without a layout pass, as an animated graphics layer or offset_with does: what read Self::node_window_bounds reads them again when it changes.

fn collect_retained_visual_observation_nodes( &self, nodes: &mut HashSet<NodeId, RandomState>, ) -> bool

Replaces the set with retained visual observation owners, preserving its capacity. Returns whether the scene provides this information.

fn hit_test_nodes(&self, x: f32, y: f32) -> Vec<NodeId>

Returns NodeIds of all hit regions at the given coordinates. This is a convenience method equivalent to hit_test().map(|h| h.node_id()).