radiant-rs 0.15.0

Thread-safe Rust sprite rendering engine with a friendly API and custom shader support
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::core::{Display, Monitor, Point2, Context, Result};

/// A display builder.
///
/// Obtained from [`Display::builder()`](../struct.Display.html#method.builder).
///
/// # Examples
///
/// ```rust
/// # use radiant_rs::*;
/// let display = Display::builder().dimensions((640, 480)).vsync().title("Window!").build().unwrap();
/// ```
#[must_use]
#[derive(Clone)]
pub struct DisplayBuilder {
    pub(crate) width       : u32,
    pub(crate) height      : u32,
    pub(crate) title       : String,
    pub(crate) transparent : bool,
    pub(crate) decorations : bool,
    pub(crate) monitor     : Option<Monitor>,
    pub(crate) vsync       : bool,
    pub(crate) visible     : bool,
    pub(crate) context     : Option<Context>,
}

impl DisplayBuilder {
    /// Sets a width for the display.
    pub fn width(mut self: Self, width: u32) -> Self {
        self.width = width;
        self
    }
    /// Sets a height for the display.
    pub fn height(mut self: Self, height: u32) -> Self {
        self.height = height;
        self
    }
    /// Sets dimensions for the display.
    pub fn dimensions<T>(mut self: Self, dimensions: T) -> Self where Point2<u32>: From<T> {
        let dimensions = Point2::<u32>::from(dimensions);
        self.width = dimensions.0;
        self.height = dimensions.1;
        self
    }
    /// Sets a title for the display.
    pub fn title(mut self: Self, title: &str) -> Self {
        self.title = title.to_string();
        self
    }
    /// Flags the display to be transparent.
    pub fn transparent(mut self: Self) -> Self {
        self.transparent = true;
        self
    }
    /// Flags the display to be borderless.
    pub fn borderless(mut self: Self) -> Self {
        self.decorations = false;
        self
    }
    /// Sets the monitor to create the display on.
    pub fn monitor(mut self: Self, monitor: Monitor) -> Self {
        self.monitor = Some(monitor);
        self
    }
    /// Flags the display to use vsync.
    pub fn vsync(mut self: Self) -> Self {
        self.vsync = true;
        self
    }
    /// Use an existing context with this display.
    pub fn context(mut self: Self, context: &Context) -> Self {
        self.context = Some(context.clone());
        self
    }
    /// Flags the display to be initialially hidden.
    pub fn hidden(mut self: Self) -> Self {
        self.visible = false;
        self
    }
    /// Returns the constructed display instance.
    pub fn build(self: Self) -> Result<Display> {
        Display::new(self)
    }
    /// Creates a new DisplayBuilder instance.
    pub(crate) fn new() -> Self {
        DisplayBuilder { ..DisplayBuilder::default() }
    }
}

impl Default for DisplayBuilder {
    fn default() -> DisplayBuilder {
        DisplayBuilder {
            width       : 640,
            height      : 480,
            title       : "".to_string(),
            transparent : false,
            decorations : true,
            monitor     : None,
            vsync       : false,
            visible     : true,
            context     : None,
        }
   }
}