bowtie 0.2.0

2D Game engine with messaging system
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
105
106
107

use crate::math::matrix::Matrix;

use super::gl_translation::{DataType, ToGl};

pub trait SettableUniform<T> {
  fn set_uniform(&self, loc: i32);
  fn get_name(&self) -> String;
}

pub struct UniformFloatVector {
  pub name: String,
  pub count: i8,
  pub values: Vec<f32>,
  data_type: DataType,
}

impl UniformFloatVector {
  pub fn new(name: &str, count: i8, values: Vec<f32>) -> UniformFloatVector {
    UniformFloatVector {
      name: String::from(name),
      count,
      values,
      data_type: DataType::Float32,
    }
  }
}

impl SettableUniform<Vec<f32>> for UniformFloatVector {
  fn get_name(&self) -> String {
    self.name.to_owned()
  }
  fn set_uniform(&self, loc: i32) {
    match self.count {
      3 => {
        unsafe {
          gl::Uniform3f(
            loc,
            self.values[0].into(),
            self.values[1].into(),
            self.values[2].into(),
          );
        };
      }
      _ => {
        panic!(
          "Uniform for vector of {} values not implemented",
          self.count
        )
      }
    }
  }
}

pub struct UniformInteger {
  pub name: String,
  pub value: i32,
  data_type: DataType,
}

impl UniformInteger {
  pub fn new(name: &str, value: i32) -> UniformInteger {
    UniformInteger {
      name: String::from(name),
      value,
      data_type: DataType::Int,
    }
  }
}

impl SettableUniform<i32> for UniformInteger {
  fn get_name(&self) -> String {
    self.name.to_owned()
  }

  fn set_uniform(&self, loc: i32) {
    unsafe {
      gl::Uniform1i(loc, self.value);
    }
  }
}

pub struct UniformMatrixFloat {
  pub name: String,
  pub value: Matrix<f32>,
  data_type: DataType,
}

impl UniformMatrixFloat {
  pub fn new(name: &str, value: Matrix<f32>) -> UniformMatrixFloat {
    UniformMatrixFloat {
      name: String::from(name),
      value,
      data_type: DataType::Float32,
    }
  }
}

impl SettableUniform<Matrix<f32>> for UniformMatrixFloat {
  fn get_name(&self) -> String {
    self.name.to_owned()
  }
  fn set_uniform(&self, loc: i32) {
    unsafe {
      gl::UniformMatrix4fv(loc, 1, gl::TRUE, &self.value.get_inner_ptr()[0])
    }
  }
}