Struct SpriteBatch 

pub struct SpriteBatch { /* private fields */ }

Per-frame snapshot batch. Send + Sync so it can cross into the compositor thread via repose_render_wgpu::Callback.

Each batch id owns its pipelines/instances in CallbackResources (like FullscreenPass’s id map). Re-keying the atlas (a new BatchDesc or uploads_gen) drops its contents; the game re-fills it with the uploads that came with the new descriptor.

Implementations

impl SpriteBatch

pub fn new(desc: BatchDesc) -> Self

pub fn with_id(id: impl Into<String>, desc: BatchDesc) -> Self

pub fn id(&self) -> &str

pub fn clear(&mut self)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn set_camera(&mut self, view_proj: Mat4)

View-projection matrix, y-down screen convention (see screen_camera).

pub fn upload(&mut self, upload: AtlasUpload)

Queue atlas uploads, applied in the next prepare.

pub fn extend_uploads(&mut self, uploads: impl IntoIterator<Item = AtlasUpload>)

Queue several uploads at once (per-frame atlas drains).

pub fn set_light_source(&mut self, id: impl Into<String>)

Light every sprite in this batch from the light map of the Light2dPass with this id.

The pass and the batch must share one camera (set_camera on both); the light map is published as a world-space rect, so a batch drawn into any rectangle of the same target lines up without further setup. A batch whose pass has not prepared yet draws unlit for that frame.

pub fn clear_light_source(&mut self)

Draw unlit: the identity light map, modulation ignored.

pub fn set_light_modulate(&mut self, rgb: [f32; 3])

Scene darkness for this batch: multiplies every sprite’s colour before the light map adds light. [1.0; 3] (default) is neutral and [0.0; 3] is black; a batch with no light source ignores it. Values are clamped to 0.. and a non-finite channel falls back to 1.0, so one bad frame cannot blacken or NaN the whole batch.

pub fn push( &mut self, center: [f32; 2], size: [f32; 2], rotation: f32, anchor: [f32; 2], flip_x: bool, flip_y: bool, uv_min: [f32; 2], uv_max: [f32; 2], tint: [f32; 4], page: u32, )

Push one textured quad.

pub fn push_masked( &mut self, center: [f32; 2], size: [f32; 2], rotation: f32, anchor: [f32; 2], flip_x: bool, flip_y: bool, uv_min: [f32; 2], uv_max: [f32; 2], tint: [f32; 4], page: u32, light_mask: u32, )

Push one textured quad on an explicit light layer.

pub fn push_blended( &mut self, center: [f32; 2], size: [f32; 2], rotation: f32, anchor: [f32; 2], flip_x: bool, flip_y: bool, uv_min: [f32; 2], uv_max: [f32; 2], tint: [f32; 4], page: u32, z: f32, blend: SpriteBlend, )

Push with explicit z + blend; lit by layer 0 (light mask 1). Use Self::push_blended_masked to put the sprite on another layer.

pub fn push_blended_masked( &mut self, center: [f32; 2], size: [f32; 2], rotation: f32, anchor: [f32; 2], flip_x: bool, flip_y: bool, uv_min: [f32; 2], uv_max: [f32; 2], tint: [f32; 4], page: u32, z: f32, blend: SpriteBlend, light_mask: u32, )

Push with explicit z, blend, and light layer bits.

pub fn push_sprite(&mut self, s: &SpriteInstance)

Bridge a snapshot sprite into the batch.

The atlas and the render target are both Rgba8UnormSrgb, so the sampled texel and the written pixel are already in linear space and the tint has to be linearized here; Self::push takes one directly.

impl SpriteBatch

pub fn resolve_lightmap( &self, device: &Device, queue: &Queue, resources: &mut CallbackResources, )

Point this batch at the light map the renderer’s finish_prepare hook makes visible after every prepare has run, so scene order between a light pass and its consumers does not matter.

Runs on the renderer’s finish_prepare; also safe to call directly.

pub fn prepare_with_uploads( &self, device: &Device, queue: &Queue, _encoder: &mut CommandEncoder, screen: &ScreenDescriptor, resources: &mut CallbackResources, uploads: &[AtlasUpload], ) -> Vec<CommandBuffer>

Game-owned passes can drive this batch into their OWN render target instead.

Trait Implementations

impl WgpuCallback for SpriteBatch

fn resource_key(&self) -> Option<&str>

fn resource_type_id(&self) -> TypeId

fn prepare( &self, device: &Device, queue: &Queue, encoder: &mut CommandEncoder, screen: &ScreenDescriptor, resources: &mut CallbackResources, ) -> Vec<CommandBuffer>

Called before the main repose render pass, with access to device/queue/encoder for buffer uploads. Can return extra command buffers to be submitted.

fn finish_prepare( &self, device: &Device, queue: &Queue, _encoder: &mut CommandEncoder, _screen: &ScreenDescriptor, resources: &mut CallbackResources, ) -> Vec<CommandBuffer>

Called after all prepare calls, before paint. For cross-callback sync.

fn paint( &self, _info: PaintCallbackInfo, rpass: &mut CallbackRenderPass<'_, '_>, resources: &CallbackResources, )