Trait riddle_renderer_wgpu::wgpu_ext::WGPUDevice[−][src]

pub trait WGPUDevice {
    fn begin_frame(&self) -> Result<(), RendererError>;

    fn end_frame(&self);

    fn viewport_dimensions(&self) -> Vector2<f32>;

    fn with_device_info<R, F: FnOnce(&WGPUDeviceInfo<'_>) -> Result<R, RendererError>>(
        &self, 
        f: F
    ) -> Result<R, RendererError>;

    fn with_frame<R, F: FnOnce(&SwapChainFrame) -> Result<R, RendererError>>(
        &self, 
        f: F
    ) -> Result<R, RendererError>;
}

A WGPURenderer compatible WGPU device.

A default implementation exists for riddle_platform_winit::Window in WindowWGPUDevice.

The application may implement this trait to layer the renderer on top of custom WGPU renderer.

Example

use std::sync::Arc;
use riddle::{common::Color, platform::*, renderer::{wgpu_ext::*, *}, *};

#[derive(Clone)]
struct ACustomRendererHandle {
    // [..]
}

impl ACustomRendererHandle {
    // [..]
}

impl WGPUDevice for ACustomRendererHandle {
    // [..]
}

fn main() -> Result<(), RiddleError> {
    let rdl =  RiddleLib::new()?;
    let window = WindowBuilder::new().build(rdl.context())?;

    let custom_renderer = ACustomRendererHandle::new();

    let renderer = WGPURenderer::new_from_device(custom_renderer.clone())?;

    rdl.run(move |rdl| match rdl.event() {
        Event::Platform(PlatformEvent::WindowClose(_)) => rdl.quit(),
        Event::ProcessFrame => {
            custom_renderer.start_render();
            custom_renderer.render_3d_scene();

            let mut render_ctx = renderer.begin_render().unwrap();
            render_ctx.clear(Color::RED);
            render_ctx.present();

            custom_renderer.end_render();
        }
        _ => (),
    })
}

Required methods

fn begin_frame(&self) -> Result<(), RendererError>[src]

Called when the WGPURenderer begins rendering to the swap chain frame.

Invoked through WGPURenderer::begin_render

fn end_frame(&self)[src]

When the renderer is done renderering to the swap chain frame.

Invoked by a RenderContext::present call on the context returned from WGPURenderer::begin_render.

fn viewport_dimensions(&self) -> Vector2<f32>[src]

The viewport dimensions of the swapchain frame.

This controls the projection matrix used by the sprite renderer.

fn with_device_info<R, F: FnOnce(&WGPUDeviceInfo<'_>) -> Result<R, RendererError>>(
    &self,
    f: F
) -> Result<R, RendererError>[src]

Provides a reference to the set of wgpu device state for use by the renderer.

fn with_frame<R, F: FnOnce(&SwapChainFrame) -> Result<R, RendererError>>(
    &self,
    f: F
) -> Result<R, RendererError>[src]

Provide a reference to the current swap chain frame for use by the renderer.

Loading content...

Implementors

impl WGPUDevice for WindowWGPUDevice[src]

Loading content...