Struct DrawPass 

pub struct DrawPass<'a> { /* private fields */ }

Implementations

impl DrawPass<'_>

pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>)

pub fn draw_indexed( &mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>, )

pub fn set_viewport( &mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32, )

pub fn set_scissor_rect(&mut self, x: u32, y: u32, w: u32, h: u32)

pub fn set_blend_constant(&mut self, color: Color)

pub fn set_stencil_reference(&mut self, reference: u32)

pub fn set_pipeline(&mut self, pipeline: &RenderPipeline)

pub fn set_vertex_buffer( &mut self, slot: u32, buffer: &Buffer, offset: u64, size: u64, )

pub fn set_index_buffer( &mut self, buffer: &Buffer, format: IndexFormat, offset: u64, size: u64, )

pub fn set_bind_group( &mut self, group: u32, bind_group: &BindGroup, offsets: &[u32], )

pub fn push_debug_group(&mut self, label: &str)

pub fn pop_debug_group(&mut self)

pub fn insert_debug_marker(&mut self, label: &str)

impl DrawPass<'_>

pub fn draw_rect( &mut self, x: f32, y: f32, w: f32, h: f32, thickness: f32, color: Color, )

pub fn draw_line( &mut self, x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32, color: Color, )

pub fn draw_ellipse( &mut self, cx: f32, cy: f32, rx: f32, ry: f32, segments: u32, thickness: f32, color: Color, )

pub fn draw_world_line( &mut self, camera: &Camera, p0: Vec3, p1: Vec3, thickness: f32, color: Color, )

A line between two world-space points, projected through camera. Unlike draw_model/ draw_world_sprite, not depth-tested — for editor-only gizmos that should always draw on top. No-ops if an endpoint is behind the camera (w <= 0) rather than drawing a folded-back bogus line.

pub fn draw_ui_sprite( &mut self, x: f32, y: f32, w: f32, h: f32, src_x: f32, src_y: f32, src_w: f32, src_h: f32, tex_w: f32, tex_h: f32, color: Color, model: Mat4, bind_group: &BindGroup, )

Draws a sprite in screen space (pixel coordinates), ignoring the camera. Use for UI/HUD elements.

model transforms the quad in the sprite’s local space, where the origin is the top-left corner and the quad spans (0, 0)..(w, h). The result is then offset by (x, y). Only the XY components of the transform are used.

pub fn draw_world_sprite( &mut self, x: f32, y: f32, z: f32, w: f32, h: f32, src_x: f32, src_y: f32, src_w: f32, src_h: f32, tex_w: f32, tex_h: f32, color: Color, highlight: Color, model: Mat4, bind_group: &BindGroup, )

Draws a sprite as a quad in world space (on the XY plane at depth z), transformed by the camera’s view-projection matrix.

model transforms the quad in the sprite’s local space, where the origin is the bottom-left corner and the quad spans (0, 0)..(w, h). The result is then offset by (x, y, z), so a rotation about Z spins the quad in place rather than orbiting the world origin.

pub fn draw_world_sprite_outline( &mut self, x: f32, y: f32, z: f32, w: f32, h: f32, model: Mat4, )

Draws a solid-blue selection outline behind a world sprite: a flat quad matching draw_world_sprite’s own quad but enlarged (in the sprite’s local XY plane) by a margin proportional to its size. Coplanar with the real sprite, so it relies on draw order — call this before DrawPass::draw_world_sprite for the same sprite — rather than depth testing to stay confined to a border: the real sprite drawn afterward fully covers its own footprint (and partially-transparent texture pixels let a thin rim of the outline show through at the edges).

pub fn draw_model(&mut self, model: &Model)

Draws a loaded Model in world space, transformed by the camera and the model’s own transform. Each mesh is drawn with its assigned material’s texture bound.

pub fn draw_model_outline(&mut self, model: &Model)

Draws a solid-blue selection outline around model (see create_model_outline_pipeline for the technique). Intended to be called right after DrawPass::draw_model for the same model, e.g. by editor-style tooling highlighting the selected entity.