rein 0.1.0

rein 3D Rendering Library
Documentation 
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
81
82
83
84

//! Frame input/output types
//!
//! Types for passing data to and from the render loop callback.

use crate::context::WgpuContext;
use crate::core::texture::DepthTexture;
use crate::window::event::Event;

/// Viewport information.
#[derive(Debug, Clone, Copy)]
pub struct Viewport {
    pub x: u32,
    pub y: u32,
    pub width: u32,
    pub height: u32,
}

impl Viewport {
    /// Get the aspect ratio.
    pub fn aspect(&self) -> f32 {
        self.width as f32 / self.height as f32
    }
}

/// Input data for a frame.
pub struct FrameInput<'a> {
    /// Events that occurred since the last frame.
    pub events: Vec<Event>,
    /// Time elapsed since the start of the application in seconds.
    pub elapsed_time: f64,
    /// Time elapsed since the last frame in seconds.
    pub delta_time: f64,
    /// The viewport dimensions.
    pub viewport: Viewport,
    /// The wgpu context.
    pub ctx: &'a WgpuContext,
    /// The surface texture view to render to.
    pub surface_view: &'a wgpu::TextureView,
    /// The depth texture.
    pub depth_texture: &'a DepthTexture,
    /// The surface format.
    pub surface_format: wgpu::TextureFormat,
}

impl<'a> FrameInput<'a> {
    /// Get the viewport width.
    pub fn width(&self) -> u32 {
        self.viewport.width
    }

    /// Get the viewport height.
    pub fn height(&self) -> u32 {
        self.viewport.height
    }

    /// Get the aspect ratio.
    pub fn aspect(&self) -> f32 {
        self.viewport.aspect()
    }

    /// Get the surface format.
    pub fn format(&self) -> wgpu::TextureFormat {
        self.surface_format
    }
}

/// Output data from a frame.
#[derive(Debug, Clone, Default)]
pub struct FrameOutput {
    /// Whether to exit the application.
    pub exit: bool,
}

impl FrameOutput {
    /// Create a new frame output that doesn't exit.
    pub fn new() -> Self {
        Self { exit: false }
    }

    /// Create a frame output that exits the application.
    pub fn exit() -> Self {
        Self { exit: true }
    }
}