Struct Scene 

pub struct Scene {
    pub draws: Vec<DrawEntry>,
    pub viewport: Option<ViewportRect>,
}

A frame’s worth of draws.

The order of DrawEntrys is the order they are recorded in. Recording compares every set_* against the state the previous draw left behind, so consecutive draws that share a pipeline or bind group skip the redundant call: ordering draws by pipeline, and then so that neighbours share their bind groups, minimizes state changes without changing what is drawn. A caller is also free to order the draws for opaque-then-transparent compositing, which is a correctness requirement rather than a performance one; across scenes, DrawOrder and Scene::record_composited take that job over.

Fields

draws: Vec<DrawEntry>

The draws to run, in order.

viewport: Option<ViewportRect>

The region of the target every draw is recorded into, or None to leave the pass’s own viewport alone.

Whole-scene state rather than per-draw: wgpu’s viewport has no reset call, so a scene that letterboxes itself states one here and a scene that draws full-target states none.

Implementations

impl Scene

pub fn new() -> Self

An empty scene.

fn resolved_viewport( &self, fallback: Option<ViewportRect>, ) -> Option<ViewportRect>

The region the scene records into when fallback may stand in for the viewport the scene itself states.

Split out from Scene::record so the choice is testable without a render pass: the recording needs a real one, and which region a scene ends up with is the rule that matters.

pub fn record(&self, pass: &mut RenderPass<'_>, fallback: Option<ViewportRect>)

Record the scene into pass, drawing into fallback when the scene states no viewport of its own.

wgpu has no call that resets a viewport, so a caller recording several scenes into one pass has to pass the whole target as fallback: a scene that states none would otherwise inherit the region the previous scene set. None leaves the pass’s region exactly as it is, for a caller that set one itself.

pub fn record_composited( pass: &mut RenderPass<'_>, scenes: &[&Scene], fallback: Option<ViewportRect>, )

Record the draws of several scenes into pass as one composite, drawing into fallback where a scene states no viewport of its own.

The scenes’ draws are grouped by their DrawOrder rather than kept in scene order: the sequenced ones of every scene first, then the depth-sorted ones of every scene pooled together back-to-front, then the trailing ones. The pool spanning scenes is what lets blended geometry from one source composite by depth against another’s, instead of by which scene recorded first. A scene whose draws state no order keeps its place, so a caller that never tags a draw sees the frame Scene::record would have given.

Every draw draws into the region its own scene resolves to — the scene’s Scene::viewport or fallback — so the pool interleaving scenes never moves a draw out of its scene’s letterbox; the deduplicated set_* recording keeps the repeated regions from repeating the calls.

Trait Implementations

impl Clone for Scene

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Scene

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

Formats the value using the given formatter.

impl Default for Scene

fn default() -> Self

Returns the “default value” for a type.