Struct JagSurface 

pub struct JagSurface { /* private fields */ }

High-level canvas-style wrapper over Painter + PassManager.

Typical flow:

• let mut canvas = surface.begin_frame(w, h);
• canvas.clear(color);
• canvas.draw calls …
• surface.end_frame(frame, canvas);

Implementations

impl JagSurface

pub fn new( device: Arc<Device>, queue: Arc<Queue>, surface_format: TextureFormat, ) -> Self

Create a new surface wrapper using an existing device/queue and the chosen surface format.

pub fn from_device_queue( device: Arc<Device>, queue: Arc<Queue>, surface_format: TextureFormat, ) -> Self

Convenience: construct from shared device/queue handles.

pub fn device(&self) -> Arc<Device>

pub fn queue(&self) -> Arc<Queue>

pub fn surface_format(&self) -> TextureFormat

pub fn pass_manager(&mut self) -> &mut PassManager

pub fn allocator_mut(&mut self) -> &mut RenderAllocator

pub fn set_direct(&mut self, direct: bool)

Choose whether to render directly to the surface (bypass compositor).

pub fn set_preserve_surface(&mut self, preserve: bool)

Control whether to preserve existing contents on the surface.

pub fn set_use_intermediate(&mut self, use_it: bool)

Choose whether to use an intermediate texture and blit to the surface.

pub fn set_enable_smaa(&mut self, enable: bool)

Enable or disable SMAA. Disabling skips the post-process filter to keep small text crisp.

pub fn set_logical_pixels(&mut self, on: bool)

Enable or disable logical pixel interpretation.

pub fn set_dpi_scale(&mut self, scale: f32)

Set current DPI scale and propagate to passes before rendering.

pub fn set_ui_scale(&mut self, s: f32)

Set a global UI scale multiplier

pub fn set_overlay( &mut self, callback: Box<dyn FnMut(&mut PassManager, &mut CommandEncoder, &TextureView, &Queue, u32, u32)>, )

Set an overlay callback for post-render passes

pub fn clear_overlay(&mut self)

Clear the overlay callback

pub fn set_scroll_offset(&mut self, offset: [f32; 2])

Set the GPU-side scroll offset (in logical pixels, typically negative). This is written into the viewport uniform so the GPU applies the scroll transform without rebuilding geometry.

pub fn scroll_offset(&self) -> [f32; 2]

Get the current GPU-side scroll offset.

pub fn frame_cache(&self) -> Option<&CachedFrameData>

Access the cached frame data (if any) for scroll-only fast path decisions.

pub fn clear_frame_cache(&mut self)

Clear the frame cache (e.g., on resize or content change).

pub fn update_frame_cache_metadata( &mut self, scroll_at_build: (f32, f32), generation: u64, hit_index: HitIndex, )

Update the scroll position, generation, and hit index on the most recent frame cache. Called by the renderer after end_frame to supply metadata that end_frame doesn’t have direct access to.

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

Pre-allocate intermediate texture at the given size. This should be called after surface reconfiguration to avoid jitter.

pub fn begin_frame(&self, width: u32, height: u32) -> Canvas

Begin a canvas frame of the given size (in pixels).

pub fn end_frame(&mut self, frame: SurfaceTexture, canvas: Canvas) -> Result<()>

Finish the frame by rendering accumulated commands to the provided surface texture.

pub fn render_cached_frame_from_internal( &mut self, frame: SurfaceTexture, scroll_delta: [f32; 2], ) -> Result<()>

Re-render using the internally-cached frame data with an updated GPU scroll offset. This is the scroll-only fast path.

scroll_delta is the negated difference between the current scroll position and the position when the frame was originally built.

pub fn end_frame_headless( &mut self, canvas: Canvas, ) -> Result<(u32, u32, Vec<u8>)>

Finish a frame by rendering to an offscreen texture and returning the pixel data as an RGBA byte vector. This is the headless equivalent of [end_frame] and does not require a window or surface.

Returns (width, height, pixels) where pixels is tightly-packed RGBA with 4 bytes per pixel (width * height * 4 total).