oml-game 0.40.2-alpha

Game foundation extracted from Fiiish-RS to remove boilerplate for future procjects.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::renderer::{
	gl,
	//	Debug,
	BlendFactor,
	Program,
	ShaderType,
};
use crate::system::System;

#[derive(Debug)]
pub struct Effect {
	id: u16,
	name: String,
	program: Program,
	cull_face: bool,
	depth_test: bool,
	blend_source_factor: gl::types::GLenum,
	blend_destination_factor: gl::types::GLenum,
}

/*
	gl::Enable(gl::CULL_FACE);
	gl::Disable(gl::DEPTH_TEST);
*/
impl Effect {
	pub fn create(
		system: &mut System,
		id: u16,
		name: &str,
		vertex_shader_name: &str,
		fragment_shader_name: &str,
	) -> Self {
		Effect::new(system, id, name, vertex_shader_name, fragment_shader_name)
	}
	fn new(
		system: &mut System,
		id: u16,
		name: &str,
		vertex_shader_name: &str,
		fragment_shader_name: &str,
	) -> Self {
		let mut program = Program::new();

		let mut vsf = system.default_filesystem_mut().open(vertex_shader_name);
		let vs = vsf.read_as_string();

		let mut fsf = system.default_filesystem_mut().open(fragment_shader_name);
		let fs = fsf.read_as_string();

		program.add_shader(ShaderType::Vertex, &vs);
		program.add_shader(ShaderType::Fragment, &fs);
		program.link();

		Self {
			id,
			name: name.to_string(),
			program,
			cull_face: true,
			depth_test: false,
			blend_source_factor: gl::SRC_ALPHA,
			blend_destination_factor: gl::ONE_MINUS_SRC_ALPHA,
		}
	}

	pub fn id(&self) -> u16 {
		self.id
	}

	pub fn r#use(&mut self) {
		unsafe {
			if self.cull_face {
				gl::Enable(gl::CULL_FACE);
			} else {
				gl::Disable(gl::CULL_FACE);
			}
			if self.depth_test {
				gl::Enable(gl::DEPTH_TEST);
			} else {
				gl::Disable(gl::DEPTH_TEST);
			}

			gl::BlendFunc(self.blend_source_factor, self.blend_destination_factor);
		}

		self.program.r#use();
	}

	pub fn name(&self) -> &str {
		&self.name
	}

	pub fn program(&self) -> &Program {
		&self.program
	}

	pub fn with_cull_face(mut self, cull_face: bool) -> Self {
		self.cull_face = cull_face;
		self
	}
	pub fn set_cull_face(&mut self, cull_face: bool) {
		self.cull_face = cull_face;
	}
	pub fn with_depth_test(mut self, depth_test: bool) -> Self {
		self.depth_test = depth_test;
		self
	}
	pub fn with_blend_func(
		mut self,
		source_factor: BlendFactor,
		destination_factor: BlendFactor,
	) -> Self {
		self.blend_source_factor = source_factor.into();
		self.blend_destination_factor = destination_factor.into();
		self
	}

	pub fn set_blend_func(&mut self, source_factor: BlendFactor, destination_factor: BlendFactor) {
		self.blend_source_factor = source_factor.into();
		self.blend_destination_factor = destination_factor.into();
	}
}