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
79
80

#![feature(arc_new_cyclic)]
#![deny(clippy::all)]

//! 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 => {
//!                 renderer.render(|render_ctx| {
//!                     render_ctx.clear(Color::RED)
//!                 }).unwrap();
//!             },
//!             _ => ()
//!          }
//!     })
//! }
//! ```
//!
//! # Direct Usage
//!
//! To use this crate directly see [`WGPUDevice`] for how to use the renderer
//! with custom WGPU devices.

mod buffered_renderer;
mod device;
mod error;
mod renderer;
mod shader;
mod sprite;
mod sprite_atlas;
mod sprite_render_target;
mod swap_chain_target;
mod target;
mod texture;
mod window_device;

use riddle_common::*;
use riddle_image as image;
use riddle_math as math;
use riddle_platform_winit as platform;

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

use buffered_renderer::*;
pub use device::*;
pub use error::*;
pub use renderer::*;
use shader::*;
pub use sprite::*;
pub use sprite_atlas::*;
pub use sprite_render_target::*;
use swap_chain_target::*;
use target::*;
use texture::*;
pub use window_device::*;

pub use riddle_renderer_common::*;

use riddle_renderer_common::vertex::*;

pub type DefaultRenderer = Renderer<WindowWGPUDevice>;