extern crate sdl2;
extern crate gl;
+extern crate image;
-//use std::ffi::CString;
-//pub mod draw;
+use sdl2::video::GLProfile;
+use gl::types::*;
+use image::GenericImageView;
-static _WIN_W : u32 = 800;
-static _WIN_H : u32 = 600;
+static WIN_W : u32 = 800;
+static WIN_H : u32 = 800;
+
+static VERTEX_DATA : [GLfloat; 12] = [
+ -0.5, -0.5,
+ 0.5, -0.5,
+ 0.5, 0.5,
+
+ -0.5, -0.5,
+ 0.5, 0.5,
+ -0.5, 0.5
+];
+
+static TEX_DATA : [GLfloat; 12] = [
+ 0.0, 1.0,
+ 1.0, 1.0,
+ 1.0, 0.0,
+
+ 0.0, 1.0,
+ 1.0, 0.0,
+ 0.0, 0.0
+];
+
+static NUM_VERTICES : GLint = 6;
+static VERTEX_LOC : u32 = 0;
+static TEX_LOC : u32 = 1;
+
+static VS : &'static str =
+"#version 130\n\
+ in vec4 pos;\n\
+ in vec2 in_tex_coord;\n\
+ out vec2 tex_coord;\n\
+ void main() {\n\
+ gl_Position = pos;\n\
+ tex_coord = in_tex_coord;\n\
+ }";
+
+static FS : &'static str =
+"#version 130\n\
+ uniform sampler2D tex;\n\
+ in vec2 tex_coord;\n\
+ out vec4 color;\n\
+ void main() {\n\
+ color = texture2D(tex, tex_coord);\n\
+ }";
+
+fn compile_sdr(src: &str, stage:GLenum) -> GLuint {
+ let shader;
+ unsafe {
+ shader = gl::CreateShader(stage);
+
+ let s = std::ffi::CString::new(src).expect("CString::new failed");;
+
+ gl::ShaderSource(shader, 1, &s.as_ptr(), std::ptr::null());
+ gl::CompileShader(shader);
+ // status
+ let mut status = gl::FALSE as GLint;
+ gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
+
+ // error handling
+ if status != (gl::TRUE as GLint) {
+ let mut len = 0;
+ gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
+
+ let mut buf: Vec<u8> = Vec::with_capacity((len + 1) as usize);
+ buf.extend([b' '].iter().cycle().take(len as usize));
+ let err: std::ffi::CString = std::ffi::CString::from_vec_unchecked(buf);
+
+ gl::GetShaderInfoLog(shader, len, std::ptr::null_mut(),
+ err.as_ptr() as *mut GLchar);
+ println!("{}", err.to_str().unwrap());
+
+ }
+ }
+ shader
+}
+
+fn link_sdr_prog(vs: GLuint, fs: GLuint) -> GLuint {
+ unsafe {
+ let sdr_prog = gl::CreateProgram();
+ gl::AttachShader(sdr_prog, vs);
+ gl::AttachShader(sdr_prog, fs);
+ gl::LinkProgram(sdr_prog);
+
+ let mut status = gl::FALSE as GLint;
+ gl::GetProgramiv(sdr_prog, gl::LINK_STATUS, &mut status);
+ if status != (gl::TRUE as GLint) {
+ let mut len: GLint = 0;
+ gl::GetProgramiv(sdr_prog, gl::INFO_LOG_LENGTH, &mut len);
+
+
+ let mut buf: Vec<u8> = Vec::with_capacity((len + 1) as usize);
+ buf.extend([b' '].iter().cycle().take(len as usize));
+ let err: std::ffi::CString = std::ffi::CString::from_vec_unchecked(buf);
+
+ gl::GetProgramInfoLog(sdr_prog, len, std::ptr::null_mut(), err.as_ptr() as *mut GLchar);
+ println!("{}", err.to_str().unwrap());
+ }
+ sdr_prog
+ }
+}
+
+fn gen_tex(fname : String, _id : &mut GLuint) {
+ let img : image::DynamicImage = image::open(&std::path::Path::new(&fname)).ok().expect("Can't open image.\n");
+ let (_w, _h) = img.dimensions();
+
+ unsafe {
+ gl::GenTextures(1, _id);
+ gl::BindTexture(gl::TEXTURE_2D, *_id);
+ gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::REPEAT as i32);
+ gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::REPEAT as i32);
+ gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as i32);
+ gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as i32);
+ gl::TexImage2D(gl::TEXTURE_2D, 0, gl::RGBA as i32,
+ _w as i32, _h as i32, 0,
+ gl::RGBA, gl::UNSIGNED_BYTE,
+ img.to_rgba().into_raw().as_ptr() as *const std::ffi::c_void);
+ gl::BindTexture(gl::TEXTURE_2D, 0);
+ }
+}
fn main() {
- let _sdl = sdl2::init().unwrap();
- let _video = _sdl.video().unwrap();
- let _win = _video
- .window("foobar", _WIN_W, _WIN_H)
+ //TODO FIXME init
+ let sdl_ctx = sdl2::init().unwrap();
+ let vid_sys = sdl_ctx.video().unwrap();
+ let gl_attr = vid_sys.gl_attr();
+
+ gl_attr.set_context_profile(GLProfile::Core);
+
+ let win = vid_sys
+ .window("foobar", WIN_W, WIN_H)
.opengl() // add opengl flag
.resizable()
.build()
.unwrap();
- let _gl_ctx = _win.gl_create_context().unwrap();
- let _gl = gl::load_with(|s| _video.gl_get_proc_address(s) as
+ let _gl_ctx = win.gl_create_context().unwrap();
+ let _gl = gl::load_with(|s| vid_sys.gl_get_proc_address(s) as
*const std::os::raw::c_void);
-// let _vsdr = draw::Shader::load_vs_code(&CString::new(include_str!("data/quad.v.glsl").unwrap.unrap();
-// let _fsdr = draw::Shader::load_fs_code(&CString::new(include_str!("data/quad.f.glsl").unwrap.unrap();
-// let sdr_prog = draw::Program::from_shaders(&[vsdr, fsdr]).unwrap();
+ let mut vao = 1;
+ let mut vbo_pos = 1;
+ let mut vbo_tex = 2;
+ let sprog;
+
+ let fs;
+ let vs;
+
+ let mut tex_igalia : GLuint = 1;
+ let mut tex_guadec : GLuint = 2;
+ let mut tex_sel = tex_igalia;
+
+ let mut uloc_stex : GLint = -1;
+
+ gen_tex("data/igalia.png".to_string(), &mut tex_igalia);
+ gen_tex("data/guadec.png".to_string(), &mut tex_guadec);
unsafe {
- gl::ClearColor(0.3, 0.1, 0.1, 1.0);
+ gl::ClearColor(0.0, 0.0, 0.0, 1.0);
+ gl::Enable(gl::BLEND);
+ gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
+ gl::GenVertexArrays(1, &mut vao);
+ gl::BindVertexArray(vao);
+
+ gl::GenBuffers(1, &mut vbo_pos);
+ gl::BindBuffer(gl::ARRAY_BUFFER, vbo_pos);
+ gl::BufferData(gl::ARRAY_BUFFER, (VERTEX_DATA.len() * std::mem::size_of::<GLfloat>()) as GLsizeiptr,
+ std::mem::transmute(&VERTEX_DATA[0]),
+ gl::STATIC_DRAW);
+ gl::BindBuffer(gl::ARRAY_BUFFER, 0);
+ gl::GenBuffers(1, &mut vbo_tex);
+ gl::BindBuffer(gl::ARRAY_BUFFER, vbo_tex);
+ gl::BufferData(gl::ARRAY_BUFFER, (TEX_DATA.len() * std::mem::size_of::<GLfloat>()) as GLsizeiptr,
+ std::mem::transmute(&TEX_DATA[0]),
+ gl::STATIC_DRAW);
+ gl::BindBuffer(gl::ARRAY_BUFFER, 0);
+
+ vs = compile_sdr(VS, gl::VERTEX_SHADER);
+ fs = compile_sdr(FS, gl::FRAGMENT_SHADER);
+
+ sprog = link_sdr_prog(vs, fs);
+
+ gl::UseProgram(sprog);
}
- let mut event_pump = _sdl.event_pump().unwrap();
+ let mut event_pump = sdl_ctx.event_pump().unwrap();
'main: loop {
- for _event in event_pump.poll_iter() {
+ for event in event_pump.poll_iter() {
// handle user input here
- match _event {
+ match event {
sdl2::event::Event::Quit {..} |
sdl2::event::Event::KeyDown {keycode:
Some(sdl2::keyboard::Keycode::Escape), ..} =>
break 'main,
+ sdl2::event::Event::KeyDown {keycode:
+ Some(sdl2::keyboard::Keycode::I), ..} =>
+ tex_sel = tex_igalia,
+ sdl2::event::Event::KeyDown {keycode:
+ Some(sdl2::keyboard::Keycode::G), ..} =>
+ tex_sel = tex_guadec,
_ => {},
}
}
+ //TODO FIXME: display
unsafe {
+ let uni_str = std::ffi::CString::new("tex").unwrap();
+ uloc_stex = gl::GetUniformLocation(sprog, uni_str.as_ptr());
+ if uloc_stex > -1 {
+ gl::Uniform1i(uloc_stex, tex_sel as i32);
+ }
+
gl::Clear(gl::COLOR_BUFFER_BIT);
- gl::Viewport(0, 0, _WIN_W as i32, _WIN_H as i32);
+ gl::Viewport(0, 0, WIN_W as i32, WIN_H as i32);
+
+ /* pos */
+ gl::EnableVertexAttribArray(VERTEX_LOC);
+ gl::BindBuffer(gl::ARRAY_BUFFER, vbo_pos);
+ gl::VertexAttribPointer(VERTEX_LOC, 2,
+ gl::FLOAT, gl::FALSE,
+ 0 as i32, std::ptr::null());
+
+ /* tex coords */
+ gl::EnableVertexAttribArray(TEX_LOC);
+ gl::BindBuffer(gl::ARRAY_BUFFER, vbo_tex);
+ gl::VertexAttribPointer(TEX_LOC, 2,
+ gl::FLOAT, gl::FALSE,
+ 0 as i32, std::ptr::null());
+
+ gl::ActiveTexture(gl::TEXTURE0 + tex_sel);
+ gl::BindTexture(gl::TEXTURE_2D, tex_sel);
+
+ gl::DrawArrays(gl::TRIANGLES, 0, NUM_VERTICES);
}
- _win.gl_swap_window();
+ win.gl_swap_window();
+ }
+
+ //TODO FIXME: cleanup
+ unsafe {
+ gl::DeleteProgram(sprog);
+ gl::DeleteShader(vs);
+ gl::DeleteShader(fs);
+ gl::DeleteBuffers(1, &vbo_pos);
+ gl::DeleteBuffers(1, &vbo_tex);
+ gl::DeleteVertexArrays(1, &vao);
+ gl::DeleteTextures(1, &tex_igalia);
+ gl::DeleteTextures(1, &tex_guadec);
}
}
projects / rust_hw / blobdiff