Struct Gfx 

pub struct Gfx {
    pub present: Present,
    pub used: bool,
    /* private fields */
}

Fields

present: Present

how video_present frames are shown (filter, integer scaling)

used: bool

set by the guest calling any gfx draw API this frame (suppresses the 2D blit)

Implementations

impl Gfx

pub fn null() -> Gfx

No GPU: ids and validation only (headless runs without screenshots, CI).

pub fn for_window(window: Arc<Window>) -> Result<Gfx, String>

Render into a window.

pub fn offscreen(width: u32, height: u32) -> Result<Gfx, String>

Render into an RGBA texture that can be read back (headless screenshots).

pub fn size(&self) -> (u32, u32)

pub fn resize(&mut self, width: u32, height: u32)

pub fn destroy(&mut self, h: u32) -> Result<(), String>

Release an object: the handle becomes a tombstone (never reused). wgpu keeps the resource alive while bind groups or a recorded pass use it.

pub fn create_shader(&mut self, wgsl: &str) -> Result<u32, String>

pub fn create_buffer(&mut self, size: u32, usage: u32) -> Result<u32, String>

pub fn write_buffer( &mut self, h: u32, offset: u32, data: &[u8], ) -> Result<(), String>

pub fn create_pipeline(&mut self, json: &str) -> Result<u32, String>

pub fn create_bind_group(&mut self, json: &str) -> Result<u32, String>

pub fn create_bind_group_layout(&mut self, json: &str) -> Result<u32, String>

pub fn create_texture(&mut self, json: &str) -> Result<u32, String>

pub fn write_texture( &mut self, h: u32, mip: u32, x: u32, y: u32, w: u32, ht: u32, data: &[u8], ) -> Result<(), String>

pub fn create_sampler(&mut self, json: &str) -> Result<u32, String>

pub fn begin_frame( &mut self, clear: [f32; 4], show: bool, ) -> Result<bool, String>

Start a frame. show: whether the runner will display it.

pub fn set_pipeline(&mut self, h: u32) -> Result<(), String>

pub fn set_bind_group(&mut self, index: u32, h: u32) -> Result<(), String>

pub fn set_bind_group_offsets( &mut self, index: u32, h: u32, offsets: &[u32], ) -> Result<(), String>

pub fn set_viewport( &mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32, ) -> Result<(), String>

pub fn set_scissor_rect( &mut self, x: u32, y: u32, w: u32, h: u32, ) -> Result<(), String>

pub fn set_vertex_buffer( &mut self, slot: u32, h: u32, offset: u32, ) -> Result<(), String>

pub fn set_index_buffer( &mut self, h: u32, format: u32, offset: u32, ) -> Result<(), String>

pub fn draw(&mut self, vc: u32, ic: u32, fv: u32, fi: u32) -> Result<(), String>

pub fn draw_indexed( &mut self, ic: u32, inst: u32, first: u32, base: i32, fi: u32, ) -> Result<(), String>

pub fn end_frame(&mut self) -> Result<(), String>

End the frame: submit (inside an error scope, so GPU validation errors trap) and present.

pub fn present_video( &mut self, rgba: &[u8], w: u32, h: u32, aspect: Option<(u32, u32)>, )

Show an RGBA frame in the window, letterboxed and filtered (self.present).

pub fn render_video( &mut self, rgba: &[u8], w: u32, h: u32, aspect: Option<(u32, u32)>, size: (u32, u32), ) -> Option<(u32, u32, Vec<u8>)>

Render an RGBA frame as the window would show it at size and read it back (headless --screenshot-filtered). None without a GPU.

pub fn read_offscreen(&self) -> Option<(u32, u32, Vec<u8>)>

Read back the offscreen target as tightly packed RGBA8 (headless screenshots).