e2r 0.10.0

experimental rendering engine 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

extern crate gl;
extern crate glutin;
extern crate rand;

extern crate e2rcore;

use std::fs::File;
use std::io::BufReader;
use std::str::FromStr;
use std::io::Read;
use std::str;
use rand::Rng;

use self::glutin::GlContext;

use self::e2rcore::interface::i_window::IWindow;
use self::e2rcore::implement::window::winglutin::WinGlutin;

use self::e2rcore::implement::capability::capability_gl;
use self::e2rcore::implement::render::util_gl;

pub fn file_open( file_path: & str ) -> Option<String> {
    let path = File::open( file_path ).expect("file path open invalid");
    let mut buf_reader = BufReader::new(path);
    let mut contents = String::new();
    match buf_reader.read_to_string( & mut contents ) {
        Err( e ) => { println!("{}", e ); return None },
        _ => (),
    }
    Some(contents)
}

#[allow(unused)]
fn main() {
    
    let geom_vs_src = file_open( "core/example/shading/deferred_geometry_pass.vs" ).expect("geometry vertex shader not retrieved");
    let geom_fs_src = file_open( "core/example/shading/deferred_geometry_pass.fs" ).expect("geometry fragment shader not retrieved");
    let light_vs_src = file_open( "core/example/shading/deferred_light_pass.vs" ).expect("light vertex shader not retrieved");
    let light_fs_src = file_open( "core/example/shading/deferred_light_pass.fs" ).expect("light fragment shader not retrieved");

    
    let mut window : WinGlutin = IWindow::init( 500, 500 );
    window.make_current().expect("window make_current failed");

    let cap = capability_gl::query_gl();
    println!( "{}", cap );

    unsafe {
        gl::Enable( gl::DEPTH_TEST );
    }

    let geom_vs = match util_gl::load_and_compile_shader( geom_vs_src.as_str(), util_gl::ShaderType::VERTEX ) { Ok( o ) => o, Err( o ) => { panic!( "{}", o ); } };
    let geom_fs = match util_gl::load_and_compile_shader( geom_fs_src.as_str(), util_gl::ShaderType::FRAGMENT ) { Ok( o ) => o, Err( o ) => { panic!( "{}", o ); } };

    let light_vs = match util_gl::load_and_compile_shader( light_vs_src.as_str(), util_gl::ShaderType::VERTEX ) { Ok( o ) => o, Err( o ) => { panic!( "{}", o ); } };
    let light_fs = match util_gl::load_and_compile_shader( light_fs_src.as_str(), util_gl::ShaderType::FRAGMENT ) { Ok( o ) => o, Err( o ) => { panic!( "{}", o ); } };

    //camera
    let cam_pos = [ 0f32, 0f32, 5f32 ];

    //rendering quad
    let mut quad_vao : u32 = 0;
    let mut quad_vbo : u32 = 0;
    
    let mut gl_program_geom = 0;
    let mut gl_program_light = 0;
    //render buffers
    let mut g_buffer = 0;
    let mut g_position = 0;
    let mut g_normal = 0;
    let mut g_albedo_spec = 0;
    unsafe {
        gl_program_geom = util_gl::create_program_from_shaders( &[ geom_vs, geom_fs ] );
        gl_program_light = util_gl::create_program_from_shaders( &[ light_vs, light_fs ] );

        gl::UseProgram( gl_program_geom );
        util_gl::check_last_op();
        gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );
        
        //todo: deferred shading
        gl::GenFramebuffers(1, & mut g_buffer);
        gl::BindFramebuffer(gl::FRAMEBUFFER, g_buffer);
        // unsigned int g_position, g_normal, gColorSpec;

        // - position color buffer
        gl::GenTextures( 1, & mut g_position );
        gl::BindTexture( gl::TEXTURE_2D, g_position );
        gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGB16F as i32, 500, 500, 0, gl::RGB, gl::FLOAT, std::ptr::null() );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as i32 );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as i32 );
        gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, g_position, 0 );

        // - normal color buffer
        gl::GenTextures( 1, & mut g_normal );
        gl::BindTexture( gl::TEXTURE_2D, g_normal );
        gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGB16F as i32, 500, 500, 0, gl::RGB, gl::FLOAT, std::ptr::null() );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as i32 );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as i32 );
        gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT1, gl::TEXTURE_2D, g_normal, 0);

        // - color + specular color buffer
        gl::GenTextures( 1, & mut g_albedo_spec );
        gl::BindTexture( gl::TEXTURE_2D, g_albedo_spec );
        gl::TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA as i32, 500, 500, 0, gl::RGBA, gl::UNSIGNED_BYTE, std::ptr::null() );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as i32 );
        gl::TexParameteri( gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as i32 );
        gl::FramebufferTexture2D( gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT2, gl::TEXTURE_2D, g_albedo_spec, 0 );

        // - tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
        let attachments : [u32;3] = [ gl::COLOR_ATTACHMENT0, gl::COLOR_ATTACHMENT1, gl::COLOR_ATTACHMENT2 ];
        gl::DrawBuffers( 3, &attachments[0] );

        //create depth buffer
        let mut rbo_depth_stencil = 0;
        gl::GenRenderbuffers( 1, & mut rbo_depth_stencil );
        gl::BindRenderbuffer( gl::RENDERBUFFER, rbo_depth_stencil );
        gl::RenderbufferStorage( gl::RENDERBUFFER, gl::DEPTH_COMPONENT32F, 500, 500 );
        gl::FramebufferRenderbuffer( gl::FRAMEBUFFER, gl::DEPTH_ATTACHMENT, gl::RENDERBUFFER, rbo_depth_stencil );
        if gl::FRAMEBUFFER_COMPLETE != gl::CheckFramebufferStatus( gl::FRAMEBUFFER ) {
            panic!("frambuffer incomplete");
        }
    }

    //create lights
    let mut light_position_colour : Vec<[f32;6]> = vec![];
    let mut rng = rand::thread_rng();
    for i in 0..50 {
        let pos_x = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 3f32;
        let pos_y = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 4f32;
        let pos_z = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 3f32;
        let colour_r = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 3f32;
        let colour_g = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 4f32;
        let colour_b = ( (rng.gen::<u8>() % 100) as f32 / 100f32 ) * 6f32 - 3f32;
        light_position_colour.push( [ pos_x, pos_y, pos_z, colour_r, colour_g, colour_b ] );
    }
    //configure shader parameters for lights
    unsafe {
        gl::UseProgram( gl_program_light );
        gl::Uniform1i( gl::GetUniformLocation( gl_program_light, "g_position".as_ptr() as * const i8 ), 0 );
        gl::Uniform1i( gl::GetUniformLocation( gl_program_light, "g_normal".as_ptr() as * const i8 ), 1 );
        gl::Uniform1i( gl::GetUniformLocation( gl_program_light, "g_albedo_spec".as_ptr() as * const i8 ), 2 );
    }

    
    //todo: create renderable objects; put this in a reusable module
    //create or load model object with data for vert pos, vert normal, vert tex coord, vert tangent, vert bitangent
    unsafe {
        //create vertex array object and vertex  buffer objects to store model data
        let mut obj_vao = 0;
        let mut obj_vbo = 0;
        gl::GenVertexArrays( 1, & mut obj_vao );
        gl::GenBuffers( 1, & mut obj_vbo );
        //gl::GenBuffers( 1, &obj_ebo ); //optional
        gl::BindVertexArray( obj_vao );
        gl::BindBuffer( gl::ARRAY_BUFFER, obj_vbo );

        let data_ptr = [ -1f32, -1f32, -1f32, 1f32, -1f32, -1f32, -1f32, 1f32, -1f32,
                          1f32,  1f32, -1f32, -1f32, 1f32, -1f32, 1f32, -1f32, -1f32 ];
        
        let data_length =  data_ptr.len() * std::mem::size_of::<f32>();
                          
        gl::BufferData( gl::ARRAY_BUFFER, data_length as isize, data_ptr.as_ptr() as _, gl::STATIC_DRAW );
        //EBO stuff //optional
        gl::EnableVertexAttribArray( 0 );
        
        // gl::VertexAttribPointer( 0, 3, gl::FLOAT, gl::FALSE, stride, offset_position ); //position
        // gl::EnableVertexAttribArray( 1 );
        // gl::VertexAttribPointer( 1, 3, gl::FLOAT, gl::FALSE, stride, offset_normal ); //normal
        // gl::EnableVertexAttribArray( 2 );
        //gl::VertexAttribPointer( 2, 2, gl::FLOAT, gl::FALSE, stride, offset_tc ); //texture coordinates
        //gl::EnableVertexAttribArray( 3 );
        //gl::VertexAttribPointer( 3, 3, gl::FLOAT, gl::FALSE, stride, offset_tangent ); //tangent
        //gl::EnableVertexAttribArray( 4 );
        //gl::VertexAttribPointer( 4, 3, gl::FLOAT, gl::FALSE, stride, offset_bitangent ); //bitangent
        gl::BindVertexArray( 0 );
    }

    //create multiple model instances with positional offset
    let mut obj_pos : Vec<[f32;3]> = vec![];
    obj_pos.push( [-3f32, -3f32, -3f32] );
    obj_pos.push( [ 0f32, -3f32, -3f32] );
    obj_pos.push( [ 3f32, -3f32, -3f32] );
    obj_pos.push( [-3f32, -3f32,  0f32] );
    obj_pos.push( [ 0f32, -3f32,  0f32] );
    obj_pos.push( [ 3f32, -3f32,  0f32] );
    obj_pos.push( [-3f32, -3f32,  3f32] );
    obj_pos.push( [ 0f32, -3f32,  3f32] );
    obj_pos.push( [ 3f32, -3f32,  3f32] );
    
    let mut running = true;
    while running {
        let mut new_win_dim = None;
        window.handle_events( |event| {
            match event {
                glutin::Event::WindowEvent{ event, .. } => match event {
                    glutin::WindowEvent::Closed => running = false,
                    glutin::WindowEvent::Resized(w, h) => new_win_dim = Some( (w,h) ),
                    glutin::WindowEvent::KeyboardInput {
                        input: glutin::KeyboardInput {
                            state: glutin::ElementState::Pressed,
                            virtual_keycode: Some( glutin::VirtualKeyCode::Q ),
                            ..
                        }, ..
                    } => running = false,
                    _ => (),
                },
                _ => ()
            }
        } );
        if let Some( ( w, h ) ) = new_win_dim {
            window._win._wingl.resize(w, h);
        }
        unsafe {
            gl::ClearColor( 0.3, 0.3, 0.3, 1.0 );
            gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);

            // 1. geometry pass
            gl::BindFramebuffer( gl::FRAMEBUFFER, g_buffer );
            {
                gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
                //todo: calculate projection matrix
                //todo: calculate view matrix
                //todo: calculate model matrix
                
                gl::UseProgram( gl_program_geom );
                //todo: set uniforms
                for ( i, v ) in obj_pos.iter().enumerate() {
                    //model = Identity4x4;
                    //model = model.translate( v );
                    //model = model.scale( Vec3( ... ) );
                    //gl::UniformMatrix4fv( gl::GetUniformLocation( gl_program_geom, "model", 1, gl::FALSE, &model[0] );
                    //draw object mesh
                    //gl::BindVertexArray(VAO);
                    //gl::DrawElements or gl::DrawArrays on model data
                    //gl::BindVertexArray(0);
                    //gl::ActiveTexture( gl::TEXTURE0 );
                }
            }
            gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );

            //2. lighting pass
            {
                gl::Clear( gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT );

                gl::UseProgram( gl_program_light );
                
                // Bind AllbGBuffer Textures
                gl::ActiveTexture( gl::TEXTURE0 );
                gl::BindTexture( gl::TEXTURE_2D, g_position );
                gl::ActiveTexture( gl::TEXTURE1 );
                gl::BindTexture( gl::TEXTURE_2D, g_normal );
                gl::ActiveTexture( gl::TEXTURE2 );
                gl::BindTexture( gl::TEXTURE_2D, g_albedo_spec );

                //set light uniforms
                for ( i, v ) in light_position_colour.iter().enumerate() {
                    let mut uniform_light_pos = "lights[".to_owned();
                    uniform_light_pos.push_str( i.to_string().as_str() );
                    uniform_light_pos.push_str( String::from_str("].Position").unwrap().as_str() );
                    gl::Uniform3fv( gl::GetUniformLocation( gl_program_light, uniform_light_pos.as_ptr() as * const i8 ), 1, &v[0] );

                    let mut uniform_name_colour = "lights[".to_owned();
                    uniform_name_colour.push_str( i.to_string().as_str() );
                    uniform_name_colour.push_str( String::from_str("].Colour").unwrap().as_str() );
                    gl::Uniform3fv( gl::GetUniformLocation( gl_program_light, uniform_name_colour.as_ptr() as * const i8 ), 1, &v[0] );

                    let light_atten_const = 1.0;
                    let light_atten_linear = 0.7;
                    let light_atten_quadratic = 1.8;

                    let mut uniform_name_linear = "lights[".to_owned();
                    uniform_name_linear.push_str( i.to_string().as_str() );
                    uniform_name_linear.push_str( String::from_str("].Linear").unwrap().as_str() );
                    gl::Uniform3fv( gl::GetUniformLocation( gl_program_light, uniform_name_linear.as_ptr() as * const i8 ), 1, &v[0] );

                    let mut uniform_name_quadratic = "lights[".to_owned();
                    uniform_name_quadratic.push_str( i.to_string().as_str() );
                    uniform_name_quadratic.push_str( String::from_str("].Quadratic").unwrap().as_str() );
                    gl::Uniform3fv( gl::GetUniformLocation( gl_program_light, uniform_name_quadratic.as_ptr() as * const i8 ), 1, &v[0] );
                }
                gl::Uniform3fv( gl::GetUniformLocation( gl_program_light, "viewPos".as_ptr() as * const i8 ), 1, &cam_pos[0] );
            }
            //render quad
            {
                if quad_vao == 0 {
                    let quad_vertices = [ -1f32, 1f32, 0f32, 0f32, 1f32,
                                         -1f32, -1f32, 0f32, 0f32, 0f32,
                                          1f32, 1f32, 0f32, 1f32, 1f32,
                                          1f32, -1f32, 0f32, 1f32, 0f32, ];
                    gl::GenVertexArrays( 1, & mut quad_vao );
                    gl::GenBuffers( 1, & mut quad_vbo );
                    gl::BindVertexArray( quad_vao );
                    gl::BindBuffer( gl::ARRAY_BUFFER, quad_vbo );
                    gl::BufferData( gl::ARRAY_BUFFER, ( quad_vertices.len() * std::mem::size_of::<f32>() ) as isize, quad_vertices[..].as_ptr().offset(0) as _, gl::STATIC_DRAW );
                    gl::EnableVertexAttribArray( 0 );
                    gl::VertexAttribPointer( 0, 3, gl::FLOAT, gl::FALSE, ( 5 * std::mem::size_of::<f32>() ) as i32, std::ptr::null() );
            gl::EnableVertexAttribArray( 1 );
                    gl::VertexAttribPointer( 1, 2, gl::FLOAT, gl::FALSE, ( 5 * std::mem::size_of::<f32>() ) as i32, ( 3 * std::mem::size_of::<f32>() ) as * const std::os::raw::c_void );
                }
                gl::BindVertexArray( quad_vao );
                gl::DrawArrays( gl::TRIANGLE_STRIP, 0, 4 );
                gl::BindVertexArray( 0 );
            }

            let buf_width = 500;
            let buf_height = 500;
            //copy content of geometry depth buffer to default framebuffer's depth buffer
            gl::BindFramebuffer( gl::READ_FRAMEBUFFER, g_buffer );
            gl::BindFramebuffer( gl::DRAW_FRAMEBUFFER, 0 );
            //blit from g_buffer to default framebuffer
            gl::BlitFramebuffer( 0, 0, buf_width, buf_height, 0, 0, buf_width, buf_height, gl::DEPTH_BUFFER_BIT, gl::NEAREST );
            gl::BindFramebuffer( gl::FRAMEBUFFER, 0 );
            
            //3. render emissive light objects in the scene
            //todo
        }
        window.swap_buf();
    }
}