valor 0.0.0-test

Ergonomic rendering engine for games in Rust.
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

use glutin;
use gfx_window_glutin;
use gfx_text;
use Renderer;
use types::*;
use defines::pipe;

const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];

/// Configuration object for initializing `Renderer` and window systems.
pub struct ValorBuilder {
    title: &'static str,
    width: u32,
    height: u32,
    vsync: bool,
    clear_color: [f32; 4],
}

impl ValorBuilder {
    pub fn new() -> Self {
        ValorBuilder {
            title: "Valor",
            width: 640,
            height: 480,
            vsync: false,
            clear_color: BLACK,
        }
    }

    pub fn with_title(mut self, title: &'static str) -> Self {
        self.title = title;
        self
    }

    pub fn with_dimensions(mut self, width: u32, height: u32) -> Self {
        self.width = width;
        self.height = height;
        self
    }

    pub fn with_vsync(mut self, vsync: bool) -> Self {
        self.vsync = vsync;
        self
    }

    pub fn with_clear_color(mut self, clear_color: [f32; 4]) -> Self {
        self.clear_color = clear_color;
        self
    }

    pub fn finish(self) -> (glutin::GlWindow, glutin::EventsLoop, Renderer) {
        use gfx::traits::FactoryExt;

        // Prepare Glutin builders
        let events_loop = glutin::EventsLoop::new();
        let builder = glutin::WindowBuilder::new()
            .with_title(self.title)
            .with_dimensions(self.width, self.height);
        let context = glutin::ContextBuilder::new().with_vsync(self.vsync);

        // Create window- and context-dependent info
        let (window, device, mut factory, main_color, main_depth) =
            gfx_window_glutin::init::<ColorFormat, DepthFormat>(builder, context, &events_loop);

        // Create encoder, which will fill command buffer
        let encoder = factory.create_command_buffer().into();

        // Create text renderer
        let text = gfx_text::new(factory.clone()).build().unwrap();

        let pso_simple = factory
            .create_pipeline_simple(
                include_bytes!("shaders/triangle_150_vs.glsl"),
                include_bytes!("shaders/triangle_150_fs.glsl"),
                pipe::new(),
            )
            .unwrap();

        let globals = factory.create_constant_buffer(1);

        let (width, height) = match window.get_inner_size_pixels() {
            Some((w, h)) => (w, h),
            None => (0, 0),
        };

        let renderer = Renderer::new(
            factory,
            device,
            encoder,
            main_color,
            main_depth,
            self.clear_color,
            width,
            height,
            globals,
            text,
            pso_simple,
        );

        (window, events_loop, renderer)
    }
}