Struct riddle_renderer_wgpu::Renderer

pub struct Renderer<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)?;

    renderer.render(|render_ctx| {
        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)
    })?;
    Ok(())
}

Implementations

impl Renderer<WindowWGPUDevice>

pub fn new_from_window(window: &Window) -> Result<Self, WGPURendererError>

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> Renderer<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 wgpu_device(&self) -> &Device

pub fn new_from_device(wgpu_device: Device) -> Result<Self, WGPURendererError>

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<D: WGPUDevice> Clone for Renderer<D>

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Device: WGPUDevice> CommonRenderer for Renderer<Device>

type RenderContext = BufferedRenderer<Device, SwapChainFrameTarget<Device>>

type Sprite = Sprite<Device>

type Texture = Texture

type Shader = Shader

type SpriteFont = SpriteFont<Self>

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

fn render<R, F>(&self, f: F) -> Result<R, RendererError> where
    F: FnOnce(&mut Self::RenderContext) -> Result<R, RendererError>, 

impl<Device: WGPUDevice> CommonSprite<Renderer<Device>> for Sprite<Device>

fn new_from_image(
    renderer: &Renderer<Device>,
    img: &Image,
    init_args: &SpriteInitArgs
) -> Result<Self, RendererError>

Construct a new sprite from an image. The image contents are copied to a texture in RGBA8 format. The entire image will be used

fn subsprite(&self, source_rect: &Rect<f32>) -> Self

Build a sprite that shares the same underlying texture but represents a different portion of the texture.

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

Get the dimensions of the sprite

fn render_regions<Ctx: RenderContext<Renderer<Device>> + ?Sized>(
    &self,
    render_ctx: &mut Ctx,
    args: &SpriteRenderArgs,
    parts: &[(Rect<f32>, Vector2<f32>)]
) -> Result<(), RendererError>

Render multiple sub regions of the sprite at once.

pub fn render<Ctx>(
    &self,
    render_ctx: &mut Ctx,
    args: &SpriteRenderArgs
) -> Result<(), RendererError> where
    Ctx: RenderContext<R>, 

Render the entire sprite.

pub fn render_at<Ctx>(
    &self,
    render_ctx: &mut Ctx,
    location: Vector2<f32>
) -> Result<(), RendererError> where
    Ctx: RenderContext<R>, 

Utility function to simply render the sprite at a given location