Struct riddle_renderer_wgpu::wgpu_ext::WGPURenderer

pub struct WGPURenderer<Device: WGPUDevice> { /* fields omitted */ }

A simple 2D sprite based renderer.

A renderer can be created for a Window and holds a reference to the window, which will keep the window alive as long as the renderer is alive.

Example

use riddle::{common::Color, platform::*, renderer::*, math::*, *};
fn main() -> Result<(), RiddleError> {
    let rdl =  RiddleLib::new()?;
    let window = WindowBuilder::new().build(rdl.context())?;

    let renderer = Renderer::new_from_window(&window)?;

    let mut render_ctx /*: impl RenderContext*/ = renderer.begin_render()?;
    render_ctx.clear(Color::RED)?;

    // Change the current transform matrix, and draw a rect
    render_ctx.set_transform(glam::Mat4::from_scale(glam::vec3(2.0, 2.0, 1.0)).into())?;
    render_ctx.fill_rect(&Rect::new(vec2(0.0, 0.0), vec2(10.0, 10.0)), Color::GREEN)?;

    render_ctx.present()?;
    Ok(())
}

Implementations

impl WGPURenderer<WindowWGPUDevice>

pub fn new_from_window(
    window: &Window
) -> Result<WGPURendererHandle<WindowWGPUDevice>, RendererError>

Initialize a new Renderer, creating a WGPU device for the window.

Example

let rdl =  RiddleLib::new()?;
let window = WindowBuilder::new().build(rdl.context())?;

let renderer = Renderer::new_from_window(&window)?;

impl<Device: WGPUDevice> WGPURenderer<Device>

pub fn dimensions(&self) -> Vector2<f32>

Get the frame dimensions as reported by the WGPUDevice.

In the case of a default Window renderer, this will be the internal size of the window in logical units.

Example

let rdl =  RiddleLib::new()?;
let window = WindowBuilder::new().dimensions(300, 400).build(rdl.context())?;

let renderer = Renderer::new_from_window(&window)?;

assert_eq!(vec2(300.0, 400.0), renderer.dimensions());

pub fn begin_render(&self) -> Result<impl RenderContext + '_, RendererError>

Get a render context for the current swap chain frame.

Example

let renderer = Renderer::new_from_window(&window)?;

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

pub fn wgpu_device(&self) -> &Device

pub fn new_from_device(
    wgpu_device: Device
) -> Result<WGPURendererHandle<Device>, RendererError>

Or the renderer can be built on top of existing WGPU contexts, to allow the simple renderer to be used on top of custom renderers.

Trait Implementations

impl<T: WGPUDevice> CloneHandle for WGPURenderer<T>

type Handle = WGPURendererHandle<T>

The type which represents a strong reference, and which may be dereferenced as Self.

type WeakHandle = WGPURendererWeak<T>

The type which represents a weak reference.

fn clone_handle(&self) -> WGPURendererHandle<T>

Clone a strong handle to the object.

fn clone_weak_handle(&self) -> WGPURendererWeak<T>

Clone a weak handle to the object.