Struct riddle_renderer_wgpu::Renderer

pub struct Renderer { /* 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 Renderer

pub fn new_from_window(window: &Window) -> Result<RendererHandle, 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)?;

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

Get the frame dimensions as reported by the RendererWGPUDevice.

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<'a>(
    &'a self
) -> Result<impl RenderContext + 'a, 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();

Trait Implementations

impl CloneHandle for Renderer

type Handle = RendererHandle

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

type WeakHandle = RendererWeak

The type which represents a weak reference.

fn clone_handle(&self) -> RendererHandle

Clone a strong handle to the object.

fn clone_weak_handle(&self) -> RendererWeak

Clone a weak handle to the object.

impl RendererWGPU for Renderer

fn wgpu_device(&self) -> &dyn RendererWGPUDevice

The WGPU device which the renderer was constructed with

fn new_from_device(
    wgpu_device: Box<dyn RendererWGPUDevice>
) -> Result<RendererHandle, 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.