Struct ViewportRenderer 

pub struct ViewportRenderer { /* private fields */ }

High-level renderer wrapping all GPU resources and providing framework-agnostic prepare() and paint() methods.

Implementations

impl ViewportRenderer

pub fn pick_scene_gpu( &mut self, device: &Device, queue: &Queue, cursor: Vec2, frame: &FrameData, ) -> Option<GpuPickHit>

GPU object-ID pick: renders the scene to an offscreen R32Uint texture and reads back the single pixel under cursor.

This is O(1) in mesh complexity : every object is rendered with a flat u32 ID, and only one pixel is read back. For triangle-level queries (barycentric scalar probe, exact world position), use the CPU crate::interaction::picking::pick_scene path instead.

The pipeline is lazily initialized on first call : zero overhead when this method is never invoked.

Arguments

• device : wgpu device
• queue : wgpu queue
• cursor : cursor position in viewport-local pixels (top-left origin)
• frame : current grouped frame data (camera, scene surfaces, viewport size)

Returns

Some(GpuPickHit) if an object is under the cursor, None if empty space.

impl ViewportRenderer

pub fn prepare(&mut self, device: &Device, queue: &Queue, frame: &FrameData)

Upload per-frame data to GPU buffers and render the shadow pass. Call before paint().

impl ViewportRenderer

pub fn paint(&self, render_pass: &mut RenderPass<'static>, frame: &FrameData)

Issue draw calls for the viewport. Call inside a wgpu::RenderPass.

This method requires a 'static render pass (as provided by egui’s CallbackTrait). For non-static render passes (iced, manual wgpu), use paint_to.

pub fn paint_to<'rp>( &'rp self, render_pass: &mut RenderPass<'rp>, frame: &FrameData, )

Issue draw calls into a render pass with any lifetime.

Identical to paint but accepts a render pass with a non-'static lifetime, making it usable from iced, raw wgpu, or any framework that creates its own render pass.

pub fn render_viewport( &mut self, device: &Device, queue: &Queue, output_view: &TextureView, id: ViewportId, frame: &FrameData, ) -> CommandBuffer

High-level HDR render for a single viewport identified by id.

Unlike render, this method does not call prepare internally. The caller must have already called prepare_scene and prepare_viewport for id before invoking this.

This is the right entry point for multi-viewport frames:

1. Call prepare_scene once.
2. Call prepare_viewport for each viewport.
3. Call render_viewport for each viewport with its own output_view.

Returns a wgpu::CommandBuffer ready to submit.

pub fn render( &mut self, device: &Device, queue: &Queue, output_view: &TextureView, frame: &FrameData, ) -> CommandBuffer

High-level HDR render method. Handles the full post-processing pipeline: scene -> HDR texture -> (bloom) -> (SSAO) -> tone map -> output_view.

When frame.post_process.enabled is false, falls back to a simple LDR render pass targeting output_view directly.

Returns a CommandBuffer ready to submit.

pub fn render_offscreen( &mut self, device: &Device, queue: &Queue, frame: &FrameData, width: u32, height: u32, ) -> Vec<u8>

Render a frame to an offscreen texture and return raw RGBA bytes.

Creates a temporary wgpu::Texture render target of the given dimensions, runs all render passes (shadow, scene, post-processing) into it via render(), then copies the result back to CPU memory.

No OS window or wgpu::Surface is required. The caller is responsible for initialising the wgpu adapter with compatible_surface: None and for constructing a valid FrameData (including viewport_size matching width/height).

Returns width * height * 4 bytes in RGBA8 layout. The caller encodes to PNG/EXR independently : no image codec dependency in this crate.

impl ViewportRenderer

pub fn new(device: &Device, target_format: TextureFormat) -> Self

Create a new renderer with default settings (no MSAA). Call once at application startup.

pub fn with_sample_count( device: &Device, target_format: TextureFormat, sample_count: u32, ) -> Self

Create a new renderer with the specified MSAA sample count (1, 2, or 4).

When using MSAA (sample_count > 1), the caller must create multisampled color and depth textures and use them as render pass attachments with the final surface texture as the resolve target.

pub fn resources(&self) -> &ViewportGpuResources

Access the underlying GPU resources (e.g. for mesh uploads).

pub fn last_frame_stats(&self) -> FrameStats

Performance counters from the last completed frame.

pub fn resources_mut(&mut self) -> &mut ViewportGpuResources

Mutable access to the underlying GPU resources (e.g. for mesh uploads).

pub fn upload_environment_map( &mut self, device: &Device, queue: &Queue, pixels: &[f32], width: u32, height: u32, )

Upload an equirectangular HDR environment map and precompute IBL textures.

pixels is row-major RGBA f32 data (4 floats per texel), width×height. This rebuilds camera bind groups so shaders immediately see the new textures.

pub fn create_viewport(&mut self, device: &Device) -> ViewportId

Create a new viewport slot and return its handle.

The returned ViewportId is stable for the lifetime of the renderer. Pass it to prepare_viewport, paint_viewport, and render_viewport each frame.

Also set CameraFrame::viewport_index to id.0 when building the FrameData for this viewport:

let id = renderer.create_viewport(&device);
let frame = FrameData {
    camera: CameraFrame::from_camera(&cam, size).with_viewport_index(id.0),
    ..Default::default()
};

pub fn destroy_viewport(&mut self, id: ViewportId)

Release the heavy GPU texture memory (HDR targets, OIT, bloom, SSAO) held by id.

The slot index is not reclaimed : future calls with this ViewportId will lazily recreate the texture resources as needed. This is useful when a viewport is hidden or minimised and you want to reduce VRAM pressure without invalidating the handle.

pub fn prepare_scene( &mut self, device: &Device, queue: &Queue, frame: &FrameData, scene_effects: &SceneEffects<'_>, )

Prepare shared scene data. Call once per frame, before any prepare_viewport calls.

frame provides the scene content (frame.scene) and the primary camera used for shadow cascade framing (frame.camera). In a multi-viewport setup use any one viewport’s FrameData here : typically the perspective view : as the shadow framing reference.

scene_effects carries the scene-global effects: lighting, environment map, and compute filters. Obtain it by constructing SceneEffects directly or via EffectsFrame::split.

pub fn prepare_viewport( &mut self, device: &Device, queue: &Queue, id: ViewportId, frame: &FrameData, )

Prepare per-viewport GPU state (camera, clip planes, overlays, axes).

Call once per viewport per frame, after prepare_scene.

id must have been obtained from create_viewport. frame.camera.viewport_index must equal id.0; use CameraFrame::with_viewport_index when building the frame.

pub fn paint_viewport( &self, render_pass: &mut RenderPass<'static>, id: ViewportId, frame: &FrameData, )

Issue draw calls for id into a 'static render pass (as provided by egui callbacks).

This is the method to use from an egui/eframe CallbackTrait::paint implementation. Call prepare_scene and prepare_viewport first (in CallbackTrait::prepare), then set the render pass viewport/scissor to confine drawing to the correct quadrant, and call this method.

For non-'static render passes (winit, iced, manual wgpu), use paint_viewport_to.

pub fn paint_viewport_to<'rp>( &'rp self, render_pass: &mut RenderPass<'rp>, id: ViewportId, frame: &FrameData, )

Issue draw calls for id into a render pass with any lifetime.

Identical to paint_viewport but accepts a render pass with a non-'static lifetime, making it usable from winit, iced, or raw wgpu where the encoder creates its own render pass.