wilhelm_renderer 0.8.0

A minimalist 2D data rendering engine
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

use std::rc::Rc;
use glam::Mat4;

use crate::core::{geometry::Geometry, shader::Shader};
use crate::core::color::Color;
use crate::core::engine::opengl::{gl_get_uniform_location, gl_uniform_4f};
use crate::core::engine::opengl::GLuint;

pub struct Mesh {
    pub geometry: Geometry,
    pub shader: Rc<Shader>,
    transform: Mat4,
    screen_offset: Option<(f32, f32)>,
    scale: f32,
    rotation: f32,
    pub color: Option<Color>,
    pub texture: Option<GLuint>,
}

impl Mesh {
    
    pub fn new(shader: Rc<Shader>, geometry: Geometry) -> Self {
        Self {
            geometry,
            shader,
            transform: Mat4::IDENTITY,
            screen_offset: None,
            scale: 1.0,
            rotation: 0.0,
            color: None,
            texture: None
        }
    }

    pub fn with_color(shader: Rc<Shader>, geometry: Geometry, color: Option<Color>) -> Self {
        Self {
            geometry,
            shader,
            transform: Mat4::IDENTITY,
            screen_offset: None,
            scale: 1.0,
            rotation: 0.0,
            color,
            texture: None
        }
    }

    pub fn with_texture(shader: Rc<Shader>, geometry: Geometry, texture: Option<GLuint>)->Self{
        Self {
            geometry,
            shader,
            transform: Mat4::IDENTITY,
            screen_offset: None,
            scale: 1.0,
            rotation: 0.0,
            color: None,
            texture
        }
    }

    // needs to go into renderer!
    pub fn set_uniform_4f(&self, location: &str, vec4: &[f32; 4]) {
        let loc = gl_get_uniform_location(self.shader.program(), location);
        gl_uniform_4f(loc, vec4[0], vec4[1], vec4[2], vec4[3]);
    }

    pub fn set_transform(&mut self, transform: Mat4) {
        self.transform = transform
    }

    pub fn transform(&self) -> Mat4 {
        self.transform
    }

    pub fn set_screen_offset(&mut self, x: f32, y: f32) {
        self.screen_offset = Some((x, y));
    }
    pub fn screen_offset(&self) -> (f32, f32) {
        self.screen_offset.unwrap_or((0.0, 0.0))
    }

    pub fn set_scale(&mut self, scale: f32) {
        self.scale = scale;
    }
    pub fn scale(&self) -> f32 {
        self.scale
    }

    pub fn set_rotation(&mut self, angle: f32) {
        self.rotation = angle;
    }
    pub fn rotation(&self) -> f32 {
        self.rotation
    }
}