Struct DisplayList 

pub struct DisplayList {
    pub quads: Vec<Quad>,
    pub clips: Vec<Clip>,
    pub fragments: Vec<FragmentDraw>,
    pub fragment_sources: Vec<Arc<str>>,
    pub textures: Vec<TextureDraw>,
    pub texture_pixels: Vec<TexturePixels>,
    pub dropped_textures: Vec<ImageId>,
    pub dropped_fragments: Vec<FragmentId>,
    pub viewport: Size,
    pub scale: f32,
    pub time: f32,
}

Fields

quads: Vec<Quad>

clips: Vec<Clip>

The clips the quads name, in physical pixels. One entry per distinct clip a frame reaches — a handful, even on a frame of ten thousand quads, because a clip is inherited and only a clipping node makes a new one. Empty only on a frame that drew nothing.

fragments: Vec<FragmentDraw>

One entry per QuadKind::Fragment quad, indexed by its uv[0]. Empty on a frame that draws none.

fragment_sources: Vec<Arc<str>>

The WGSL behind each entry of Self::fragments, at the same index: what a backend compiles the first time it meets a handle. It rides here rather than on FragmentDraw so that struct stays Copy and digestible; an Arc clone per fragment quad is a refcount bump, and a frame with no fragment has neither vector.

textures: Vec<TextureDraw>

One entry per QuadKind::Texture quad, indexed by its uv[0]. Empty on a frame that draws none.

texture_pixels: Vec<TexturePixels>

The pixels behind each entry of Self::textures, at the same index: what a backend uploads the first time it meets a handle, and again whenever rev has moved. Shared with the resource entry, so this is a refcount per texture quad and no copy — the reason fragment_sources rides here the same way.

dropped_textures: Vec<ImageId>

Image handles removed since the last frame whose backing was a texture: what a backend drops from its cache. Cleared with the quads, so a host that renders one list a frame sees each once — and a removal is carried by one window’s list, whichever drew next after it, since the device the cache lives on is shared by every window of the session.

dropped_fragments: Vec<FragmentId>

Fragment handles removed since the last frame: what a backend drops the pipelines it built for. Carried the same way.

viewport: Size

Physical pixels.

scale: f32

time: f32

The frame clock in seconds — the same one transitions read, as the driver last set it. A backend hands it to a fragment as FragmentIn::time; nothing else reads it. Zero when the driver never set a clock, which is what a headless frame looks like.

Implementations

impl DisplayList

pub fn clear(&mut self)

pub fn clip_of(&self, q: &Quad) -> Clip

The clip a quad names. Out of range — which a well-formed frame never is — reads as clipping nothing, so a malformed list draws rather than panics.

pub fn intern_clip(&mut self, clip: Clip) -> ClipId

Interns a clip and returns its index. See intern_clip.

Trait Implementations

impl Default for DisplayList

fn default() -> Self

Returns the “default value” for a type.