1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#![feature(arc_new_cyclic)]

/*!

Riddle simple sprite-based renderer built on `wgpu`.

The renderer can be used by itself as the only renderer in your application,
or it can be constructed on top of existing WGPU devices to provide simple
2D rendering.

# Riddle Example

The **recommended** way to use this crate is through the main `riddle` crate.
Riddle exposes this crate through `riddle::renderer`. The following example
lets this crate take full ownership over creating the WGPU device.

```no_run
use riddle::{common::Color, platform::*, renderer::*, *};

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

    rdl.run(move |rdl| {
        match rdl.event() {
            Event::Platform(PlatformEvent::WindowClose(_)) => rdl.quit(),
            Event::ProcessFrame => {
                let mut render_ctx = renderer.begin_render().unwrap();
                render_ctx.clear(Color::RED);
                render_ctx.present();
            },
            _ => ()
         }
    })
}
```

# Direct Usage

To use this crate directly see [`ext::RendererWGPUDevice`] for how to use the renderer
with custom WGPU devices.

*/

mod buffered_renderer;
mod error;
mod render_context;
mod renderer;
mod shader;
mod sprite;
mod sprite_atlas;
mod sprite_render_target;
mod swap_chain_target;
mod texture;
mod vertex;

pub mod ext;

pub use error::*;
pub use render_context::*;
pub use renderer::*;
pub use sprite::*;
pub use sprite_atlas::*;
pub use sprite_render_target::*;
pub use texture::*;

use buffered_renderer::*;
use riddle_common::*;
use shader::*;
use swap_chain_target::*;
use vertex::*;

use riddle_image as image;
use riddle_math as math;
use riddle_platform_winit as platform;

type Result<R> = std::result::Result<R, RendererError>;