Struct PaintEnvelope 

pub struct PaintEnvelope {
    pub engine: EngineId,
    pub viewport: DeviceIntSize,
    pub generation: u64,
    pub commands: Vec<PaintCmd>,
    pub fonts: Vec<FontResource>,
    pub images: Vec<ImageResource>,
}

Wire shape for transporting a PaintList across IPC, fixture files, or any boundary where the producer’s concrete PaintList impl can’t be carried by name. PM-3 doc proposed enum { Genet(GenetPaintList), Nematic(...), Scrying(...) }; implementation went with a flat struct + EngineId discriminant because none of the concrete impls carry engine-specific extra fields beyond what the trait already exposes, and the enum shape would force paint-api to depend on every engine crate.

Same closed-set property as the doc’s enum (EngineId is closed), without the dep inversion. If a future engine grows truly engine-specific transport fields, switch to the enum then.

Fields

engine: EngineId

Which engine produced this. Receivers route on this discriminant.

viewport: DeviceIntSize

Viewport the commands were computed against.

generation: u64

Producer-rolled semantic-equivalence epoch. Same value asserts identical paint output across resends.

commands: Vec<PaintCmd>

Paint command stream in paint order.

fonts: Vec<FontResource>

Font resources referenced by DrawText commands. See FontResource.

images: Vec<ImageResource>

Image resources referenced by DrawImage / DrawRepeatingImage commands. See ImageResource.

Implementations

impl PaintEnvelope

pub fn from_list<L: PaintList>(list: &L) -> Self

Package any PaintList impl into the wire form. Clones the command + font slices — the envelope owns its payload once constructed. Callers that need zero-copy transport can build the envelope manually with Vec::from/Cow patterns as usage shapes emerge.

Trait Implementations

impl Clone for PaintEnvelope

fn clone(&self) -> PaintEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PaintEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PaintEnvelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PaintList for PaintEnvelope

fn engine_id(&self) -> EngineId

Which engine produced this list. Receivers downstream of the transport envelope match on the envelope variant directly; this accessor exists for diagnostics and for in-process callers that hold a concrete &L: PaintList. The trait is not dyn-compatible (the supertrait bounds aren’t object-safe) — engine-agnostic code dispatches on the envelope, not on a trait object.

fn viewport(&self) -> DeviceIntSize

Final viewport this paint output is computed against. Renderers use this for culling and for setting the render-target size.

fn generation_id(&self) -> u64

Producer-rolled semantic-equivalence epoch. Same (source_id, generation_id) asserts identical paint output and resource references; the renderer may use this to skip relowering (PaintList → Scene). Not a tile-cache invalidation key — tile-cache correctness still derives from SceneOp content hashing post-lowering.

fn commands(&self) -> &[PaintCmd]

Paint commands in paint order. Push-order is paint-order. The return type is a slice rather than an iterator on the assumption that paint output is built-then-shipped, not streamed; revisit if a streaming consumer surfaces.

fn fonts(&self) -> &[FontResource]

Font resources referenced by DrawText commands in this list. Each FontResource carries the font bytes + the FontInstanceKey that TextRunItem::font_instance points at; the renderer registers these into its font palette and resolves each text run’s key to a concrete font. Default is empty — only lists that emit text populate it.

fn images(&self) -> &[ImageResource]

Image resources referenced by DrawImage / DrawRepeatingImage commands. Each ImageResource carries decoded RGBA8 pixels + the ImageKey that ImageItem::image_key points at; the renderer registers these into its image atlas and resolves each image item’s key to a concrete texture. Default is empty.

impl Serialize for PaintEnvelope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.