use std::cell::{RefCell, UnsafeCell}; use std::ffi::{c_void, CStr}; use std::mem; use std::mem::MaybeUninit; use std::sync::Arc; use imgui::{DrawCmd, DrawCmdParams, DrawData, DrawIdx, DrawVert}; use crate::common::{Color, Rect}; use crate::framework::backend::{BackendRenderer, BackendShader, BackendTexture, SpriteBatchCommand, VertexData}; use crate::framework::error::GameError::RenderError; use crate::framework::error::GameResult; use crate::framework::gl; use crate::framework::gl::types::*; use crate::framework::graphics::BlendMode; pub struct GLContext { pub gles2_mode: bool, pub get_proc_address: unsafe fn(user_data: &mut *mut c_void, name: &str) -> *const c_void, pub swap_buffers: unsafe fn(user_data: &mut *mut c_void), pub user_data: *mut c_void, } pub struct OpenGLTexture { width: u16, height: u16, texture_id: u32, framebuffer_id: u32, locs: Locs, program: GLuint, vbo: GLuint, vertices: Vec, context_active: Arc>, } impl BackendTexture for OpenGLTexture { fn dimensions(&self) -> (u16, u16) { (self.width, self.height) } fn add(&mut self, command: SpriteBatchCommand) { let (tex_scale_x, tex_scale_y) = (1.0 / self.width as f32, 1.0 / self.height as f32); match command { SpriteBatchCommand::DrawRect(src, dest) => { let vertices = [ VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.left, dest.top), uv: (src.left * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.bottom), uv: (src.right * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, ]; self.vertices.extend_from_slice(&vertices); } SpriteBatchCommand::DrawRectFlip(mut src, dest, flip_x, flip_y) => { if flip_x { std::mem::swap(&mut src.left, &mut src.right); } if flip_y { std::mem::swap(&mut src.top, &mut src.bottom); } let vertices = [ VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.left, dest.top), uv: (src.left * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color: (255, 255, 255, 255), }, VertexData { position: (dest.right, dest.bottom), uv: (src.right * tex_scale_x, src.bottom * tex_scale_y), color: (255, 255, 255, 255), }, ]; self.vertices.extend_from_slice(&vertices); } SpriteBatchCommand::DrawRectTinted(src, dest, color) => { let color = color.to_rgba(); let vertices = [ VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color, }, VertexData { position: (dest.left, dest.top), uv: (src.left * tex_scale_x, src.top * tex_scale_y), color, }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color, }, VertexData { position: (dest.left, dest.bottom), uv: (src.left * tex_scale_x, src.bottom * tex_scale_y), color, }, VertexData { position: (dest.right, dest.top), uv: (src.right * tex_scale_x, src.top * tex_scale_y), color, }, VertexData { position: (dest.right, dest.bottom), uv: (src.right * tex_scale_x, src.bottom * tex_scale_y), color, }, ]; self.vertices.extend_from_slice(&vertices); } } } fn clear(&mut self) { self.vertices.clear(); } fn draw(&mut self) -> GameResult { unsafe { if let Some(gl) = GL_PROC.as_ref() { if self.texture_id == 0 { return Ok(()); } if gl.gl.BindSampler.is_loaded() { gl.gl.BindSampler(0, 0); } gl.gl.Enable(gl::TEXTURE_2D); gl.gl.Enable(gl::BLEND); gl.gl.Disable(gl::DEPTH_TEST); gl.gl.BindTexture(gl::TEXTURE_2D, self.texture_id); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.vbo); gl.gl.UseProgram(self.program); gl.gl.EnableVertexAttribArray(self.locs.position); gl.gl.EnableVertexAttribArray(self.locs.uv); gl.gl.EnableVertexAttribArray(self.locs.color); gl.gl.VertexAttribPointer( self.locs.position, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.position) as _, ); gl.gl.VertexAttribPointer( self.locs.uv, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.uv) as _, ); gl.gl.VertexAttribPointer( self.locs.color, 4, gl::UNSIGNED_BYTE, gl::TRUE, mem::size_of::() as _, field_offset::(|v| &v.color) as _, ); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.vbo); gl.gl.BufferData( gl::ARRAY_BUFFER, (self.vertices.len() * mem::size_of::()) as _, self.vertices.as_ptr() as _, gl::STREAM_DRAW, ); gl.gl.DrawArrays(gl::TRIANGLES, 0, self.vertices.len() as _); gl.gl.BindTexture(gl::TEXTURE_2D, 0); gl.gl.BindBuffer(gl::ARRAY_BUFFER, 0); Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } } } impl Drop for OpenGLTexture { fn drop(&mut self) { if *self.context_active.as_ref().borrow() { unsafe { if let Some(gl) = GL_PROC.as_ref() { if self.texture_id != 0 { let texture_id = &self.texture_id; gl.gl.DeleteTextures(1, texture_id as *const _); } if self.framebuffer_id != 0 {} } } } } } fn check_shader_compile_status(shader: u32, gl: &Gl) -> bool { unsafe { let mut status: GLint = 0; gl.gl.GetShaderiv(shader, gl::COMPILE_STATUS, (&mut status) as *mut _); if status == (gl::FALSE as GLint) { let mut max_length: GLint = 0; let mut msg_length: GLsizei = 0; gl.gl.GetShaderiv(shader, gl::INFO_LOG_LENGTH, (&mut max_length) as *mut _); let mut data: Vec = vec![0; max_length as usize]; gl.gl.GetShaderInfoLog( shader, max_length as GLsizei, (&mut msg_length) as *mut _, data.as_mut_ptr() as *mut _, ); let data = String::from_utf8_lossy(&data); log::error!("Failed to compile shader {}: {}", shader, data); return false; } } true } const VERTEX_SHADER_BASIC: &str = r" #version 110 uniform mat4 ProjMtx; attribute vec2 Position; attribute vec2 UV; attribute vec4 Color; varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { Frag_UV = UV; Frag_Color = Color; gl_Position = ProjMtx * vec4(Position.xy, 0.0, 1.0); } "; const FRAGMENT_SHADER_TEXTURED: &str = r" #version 110 uniform sampler2D Texture; varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st); } "; const FRAGMENT_SHADER_COLOR: &str = r" #version 110 varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { gl_FragColor = Frag_Color; } "; const VERTEX_SHADER_BASIC_GLES: &str = r" #version 100 precision mediump float; uniform mat4 ProjMtx; attribute vec2 Position; attribute vec2 UV; attribute vec4 Color; varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { Frag_UV = UV; Frag_Color = Color; gl_Position = ProjMtx * vec4(Position.xy, 0.0, 1.0); } "; const FRAGMENT_SHADER_TEXTURED_GLES: &str = r" #version 100 precision mediump float; uniform sampler2D Texture; varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st); } "; const FRAGMENT_SHADER_COLOR_GLES: &str = r" #version 100 precision mediump float; varying vec2 Frag_UV; varying vec4 Frag_Color; void main() { gl_FragColor = Frag_Color; } "; #[derive(Copy, Clone)] struct Locs { texture: GLint, proj_mtx: GLint, position: GLuint, uv: GLuint, color: GLuint, } struct ImguiData { initialized: bool, program_tex: GLuint, program_fill: GLuint, tex_locs: Locs, fill_locs: Locs, vbo: GLuint, ebo: GLuint, font_texture: GLuint, font_tex_size: (f32, f32), } impl ImguiData { fn new() -> Self { ImguiData { initialized: false, program_tex: 0, program_fill: 0, tex_locs: Locs { texture: 0, proj_mtx: 0, position: 0, uv: 0, color: 0 }, fill_locs: Locs { texture: 0, proj_mtx: 0, position: 0, uv: 0, color: 0 }, vbo: 0, ebo: 0, font_texture: 0, font_tex_size: (1.0, 1.0), } } fn init(&mut self, gles2_mode: bool, imgui: &mut imgui::Context, gl: &Gl) { self.initialized = true; let vshdr_basic = if gles2_mode { VERTEX_SHADER_BASIC_GLES } else { VERTEX_SHADER_BASIC }; let fshdr_tex = if gles2_mode { FRAGMENT_SHADER_TEXTURED_GLES } else { FRAGMENT_SHADER_TEXTURED }; let fshdr_fill = if gles2_mode { FRAGMENT_SHADER_COLOR_GLES } else { FRAGMENT_SHADER_COLOR }; let vert_sources = [vshdr_basic.as_ptr() as *const GLchar]; let frag_sources_tex = [fshdr_tex.as_ptr() as *const GLchar]; let frag_sources_fill = [fshdr_fill.as_ptr() as *const GLchar]; let vert_sources_len = [vshdr_basic.len() as GLint - 1]; let frag_sources_tex_len = [fshdr_tex.len() as GLint - 1]; let frag_sources_fill_len = [fshdr_fill.len() as GLint - 1]; unsafe { self.program_tex = gl.gl.CreateProgram(); self.program_fill = gl.gl.CreateProgram(); let vert_shader = gl.gl.CreateShader(gl::VERTEX_SHADER); let frag_shader_tex = gl.gl.CreateShader(gl::FRAGMENT_SHADER); let frag_shader_fill = gl.gl.CreateShader(gl::FRAGMENT_SHADER); gl.gl.ShaderSource(vert_shader, 1, vert_sources.as_ptr(), vert_sources_len.as_ptr()); gl.gl.ShaderSource(frag_shader_tex, 1, frag_sources_tex.as_ptr(), frag_sources_tex_len.as_ptr()); gl.gl.ShaderSource(frag_shader_fill, 1, frag_sources_fill.as_ptr(), frag_sources_fill_len.as_ptr()); gl.gl.CompileShader(vert_shader); gl.gl.CompileShader(frag_shader_tex); gl.gl.CompileShader(frag_shader_fill); if !check_shader_compile_status(vert_shader, gl) { gl.gl.DeleteShader(vert_shader); } if !check_shader_compile_status(frag_shader_tex, gl) { gl.gl.DeleteShader(frag_shader_tex); } if !check_shader_compile_status(frag_shader_fill, gl) { gl.gl.DeleteShader(frag_shader_fill); } gl.gl.AttachShader(self.program_tex, vert_shader); gl.gl.AttachShader(self.program_tex, frag_shader_tex); gl.gl.LinkProgram(self.program_tex); gl.gl.AttachShader(self.program_fill, vert_shader); gl.gl.AttachShader(self.program_fill, frag_shader_fill); gl.gl.LinkProgram(self.program_fill); self.tex_locs = Locs { texture: gl.gl.GetUniformLocation(self.program_tex, b"Texture\0".as_ptr() as _), proj_mtx: gl.gl.GetUniformLocation(self.program_tex, b"ProjMtx\0".as_ptr() as _), position: gl.gl.GetAttribLocation(self.program_tex, b"Position\0".as_ptr() as _) as _, uv: gl.gl.GetAttribLocation(self.program_tex, b"UV\0".as_ptr() as _) as _, color: gl.gl.GetAttribLocation(self.program_tex, b"Color\0".as_ptr() as _) as _, }; self.fill_locs = Locs { texture: gl.gl.GetUniformLocation(self.program_fill, b"Texture\0".as_ptr() as _), proj_mtx: gl.gl.GetUniformLocation(self.program_fill, b"ProjMtx\0".as_ptr() as _), position: gl.gl.GetAttribLocation(self.program_fill, b"Position\0".as_ptr() as _) as _, uv: gl.gl.GetAttribLocation(self.program_fill, b"UV\0".as_ptr() as _) as _, color: gl.gl.GetAttribLocation(self.program_fill, b"Color\0".as_ptr() as _) as _, }; self.vbo = return_param(|x| gl.gl.GenBuffers(1, x)); self.ebo = return_param(|x| gl.gl.GenBuffers(1, x)); let mut current_texture = 0; gl.gl.GetIntegerv(gl::TEXTURE_BINDING_2D, &mut current_texture); self.font_texture = return_param(|x| gl.gl.GenTextures(1, x)); gl.gl.BindTexture(gl::TEXTURE_2D, self.font_texture); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as _); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as _); //gl.gl.PixelStorei(gl::UNPACK_ROW_LENGTH, 0); { let mut atlas = imgui.fonts(); let texture = atlas.build_rgba32_texture(); self.font_tex_size = (texture.width as _, texture.height as _); gl.gl.TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA as _, texture.width as _, texture.height as _, 0, gl::RGBA, gl::UNSIGNED_BYTE, texture.data.as_ptr() as _, ); atlas.tex_id = (self.font_texture as usize).into(); } gl.gl.BindTexture(gl::TEXTURE_2D, current_texture as _); } } } pub struct Gl { pub gl: gl::Gles2, } static mut GL_PROC: Option = None; pub fn load_gl(gl_context: &mut GLContext) -> &'static Gl { unsafe { if let Some(gl) = GL_PROC.as_ref() { return gl; } let gl = gl::Gles2::load_with(|ptr| (gl_context.get_proc_address)(&mut gl_context.user_data, ptr)); let version = unsafe { let p = gl.GetString(gl::VERSION); if p.is_null() { "unknown".to_owned() } else { let data = CStr::from_ptr(p as *const _).to_bytes().to_vec(); String::from_utf8(data).unwrap() } }; log::info!("OpenGL version {}", version); GL_PROC = Some(Gl { gl }); GL_PROC.as_ref().unwrap() } } pub struct OpenGLRenderer { refs: GLContext, imgui: UnsafeCell, imgui_data: ImguiData, context_active: Arc>, def_matrix: [[f32; 4]; 4], curr_matrix: [[f32; 4]; 4], } impl OpenGLRenderer { pub fn new(refs: GLContext, imgui: UnsafeCell) -> OpenGLRenderer { OpenGLRenderer { refs, imgui, imgui_data: ImguiData::new(), context_active: Arc::new(RefCell::new(true)), def_matrix: [[0.0; 4]; 4], curr_matrix: [[0.0; 4]; 4], } } fn get_context(&mut self) -> Option<(&mut GLContext, &'static Gl)> { let imgui = unsafe { &mut *self.imgui.get() }; let gles2 = self.refs.gles2_mode; let gl = load_gl(&mut self.refs); if !self.imgui_data.initialized { self.imgui_data.init(gles2, imgui, gl); } Some((&mut self.refs, gl)) } } fn field_offset FnOnce(&'a T) -> &'a U>(f: F) -> usize { unsafe { let instance = MaybeUninit::uninit().assume_init(); let offset = { let field: &U = f(&instance); field as *const U as usize - &instance as *const T as usize }; mem::forget(instance); offset } } fn return_param(f: F) -> T where F: FnOnce(&mut T), { let mut val = unsafe { mem::zeroed() }; f(&mut val); val } impl BackendRenderer for OpenGLRenderer { fn renderer_name(&self) -> String { if self.refs.gles2_mode { "OpenGL ES 2.0".to_string() } else { "OpenGL 3".to_string() } } fn clear(&mut self, color: Color) { if let Some((_, gl)) = self.get_context() { unsafe { gl.gl.ClearColor(color.r, color.g, color.b, color.a); gl.gl.Clear(gl::COLOR_BUFFER_BIT); } } } fn present(&mut self) -> GameResult { { let mutex = crate::GAME_SUSPENDED.lock().unwrap(); if *mutex { return Ok(()); } } if let Some((context, gl)) = self.get_context() { unsafe { gl.gl.Finish(); (context.swap_buffers)(&mut context.user_data); } } Ok(()) } fn prepare_draw(&mut self, width: f32, height: f32) -> GameResult { if let Some((_, gl)) = self.get_context() { unsafe { gl.gl.ActiveTexture(gl::TEXTURE0); gl.gl.BlendEquation(gl::FUNC_ADD); gl.gl.BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA); gl.gl.Viewport(0, 0, width as _, height as _); self.def_matrix = [ [2.0 / width, 0.0, 0.0, 0.0], [0.0, 2.0 / -height, 0.0, 0.0], [0.0, 0.0, -1.0, 0.0], [-1.0, 1.0, 0.0, 1.0], ]; self.curr_matrix = self.def_matrix; gl.gl.BindBuffer(gl::ARRAY_BUFFER, 0); gl.gl.BindBuffer(gl::ELEMENT_ARRAY_BUFFER, 0); gl.gl.UseProgram(self.imgui_data.program_fill); gl.gl.UniformMatrix4fv(self.imgui_data.fill_locs.proj_mtx, 1, gl::FALSE, self.def_matrix.as_ptr() as _); gl.gl.UseProgram(self.imgui_data.program_tex); gl.gl.Uniform1i(self.imgui_data.tex_locs.texture, 0); gl.gl.UniformMatrix4fv(self.imgui_data.tex_locs.proj_mtx, 1, gl::FALSE, self.def_matrix.as_ptr() as _); } Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } fn create_texture_mutable(&mut self, width: u16, height: u16) -> GameResult> { if let Some((_, gl)) = self.get_context() { unsafe { let data = vec![0u8; width as usize * height as usize * 4]; let current_texture_id = return_param(|x| gl.gl.GetIntegerv(gl::TEXTURE_BINDING_2D, x)) as u32; let texture_id = return_param(|x| gl.gl.GenTextures(1, x)); gl.gl.BindTexture(gl::TEXTURE_2D, texture_id); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as _); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as _); gl.gl.TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA as _, width as _, height as _, 0, gl::RGBA, gl::UNSIGNED_BYTE, data.as_ptr() as _, ); gl.gl.BindTexture(gl::TEXTURE_2D, current_texture_id); let framebuffer_id = return_param(|x| gl.gl.GenFramebuffers(1, x)); gl.gl.BindFramebuffer(gl::FRAMEBUFFER, framebuffer_id); gl.gl.FramebufferTexture2D(gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, texture_id, 0); let draw_buffers = [gl::COLOR_ATTACHMENT0]; gl.gl.DrawBuffers(1, draw_buffers.as_ptr() as _); gl.gl.Viewport(0, 0, width as _, height as _); gl.gl.BindFramebuffer(gl::FRAMEBUFFER, 0); // todo error checking: glCheckFramebufferStatus() Ok(Box::new(OpenGLTexture { texture_id, framebuffer_id, width, height, vertices: Vec::new(), locs: self.imgui_data.tex_locs, program: self.imgui_data.program_tex, vbo: self.imgui_data.vbo, context_active: self.context_active.clone(), })) } } else { Err(RenderError("No OpenGL context available!".to_string())) } } fn create_texture(&mut self, width: u16, height: u16, data: &[u8]) -> GameResult> { if let Some((_, gl)) = self.get_context() { unsafe { let current_texture_id = return_param(|x| gl.gl.GetIntegerv(gl::TEXTURE_BINDING_2D, x)) as u32; let texture_id = return_param(|x| gl.gl.GenTextures(1, x)); gl.gl.BindTexture(gl::TEXTURE_2D, texture_id); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as _); gl.gl.TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as _); gl.gl.TexImage2D( gl::TEXTURE_2D, 0, gl::RGBA as _, width as _, height as _, 0, gl::RGBA, gl::UNSIGNED_BYTE, data.as_ptr() as _, ); gl.gl.BindTexture(gl::TEXTURE_2D, current_texture_id); Ok(Box::new(OpenGLTexture { texture_id, framebuffer_id: 0, width, height, vertices: Vec::new(), locs: self.imgui_data.tex_locs, program: self.imgui_data.program_tex, vbo: self.imgui_data.vbo, context_active: self.context_active.clone(), })) } } else { Err(RenderError("No OpenGL context available!".to_string())) } } fn set_blend_mode(&mut self, blend: BlendMode) -> GameResult { if let Some((_, gl)) = self.get_context() { match blend { BlendMode::Add => unsafe { gl.gl.BlendEquation(gl::FUNC_ADD); gl.gl.BlendFunc(gl::ONE, gl::ONE); }, BlendMode::Alpha => unsafe { gl.gl.BlendEquation(gl::FUNC_ADD); gl.gl.BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA); }, BlendMode::Multiply => unsafe { gl.gl.BlendEquation(gl::FUNC_ADD); gl.gl.BlendFuncSeparate(gl::ZERO, gl::SRC_COLOR, gl::ZERO, gl::SRC_ALPHA); }, } Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } fn set_render_target(&mut self, texture: Option<&Box>) -> GameResult { if let Some((_, gl)) = self.get_context() { unsafe { if let Some(texture) = texture { let gl_texture: &Box = std::mem::transmute(texture); self.curr_matrix = [ [2.0 / (gl_texture.width as f32), 0.0, 0.0, 0.0], [0.0, 2.0 / (gl_texture.height as f32), 0.0, 0.0], [0.0, 0.0, -1.0, 0.0], [-1.0, -1.0, 0.0, 1.0], ]; gl.gl.UseProgram(self.imgui_data.program_fill); gl.gl.UniformMatrix4fv(self.imgui_data.fill_locs.proj_mtx, 1, gl::FALSE, self.curr_matrix.as_ptr() as _); gl.gl.UseProgram(self.imgui_data.program_tex); gl.gl.Uniform1i(self.imgui_data.tex_locs.texture, 0); gl.gl.UniformMatrix4fv(self.imgui_data.tex_locs.proj_mtx, 1, gl::FALSE, self.curr_matrix.as_ptr() as _); gl.gl.BindFramebuffer(gl::FRAMEBUFFER, gl_texture.framebuffer_id); } else { self.curr_matrix = self.def_matrix; gl.gl.UseProgram(self.imgui_data.program_fill); gl.gl.UniformMatrix4fv( self.imgui_data.fill_locs.proj_mtx, 1, gl::FALSE, self.def_matrix.as_ptr() as _, ); gl.gl.UseProgram(self.imgui_data.program_tex); gl.gl.Uniform1i(self.imgui_data.tex_locs.texture, 0); gl.gl.UniformMatrix4fv( self.imgui_data.tex_locs.proj_mtx, 1, gl::FALSE, self.def_matrix.as_ptr() as _, ); gl.gl.BindFramebuffer(gl::FRAMEBUFFER, 0); } } Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } fn draw_rect(&mut self, rect: Rect, color: Color) -> GameResult { unsafe { if let Some(gl) = GL_PROC.as_ref() { let color = color.to_rgba(); let mut uv = self.imgui_data.font_tex_size; uv.0 = 0.0 / uv.0; uv.1 = 0.0 / uv.1; let vertices = [ VertexData { position: (rect.left as _, rect.bottom as _), uv, color }, VertexData { position: (rect.left as _, rect.top as _), uv, color }, VertexData { position: (rect.right as _, rect.top as _), uv, color }, VertexData { position: (rect.left as _, rect.bottom as _), uv, color }, VertexData { position: (rect.right as _, rect.top as _), uv, color }, VertexData { position: (rect.right as _, rect.bottom as _), uv, color }, ]; if gl.gl.BindSampler.is_loaded() { gl.gl.BindSampler(0, 0); } gl.gl.UseProgram(self.imgui_data.program_fill); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.position); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.uv); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.color); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.position, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.position) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.uv, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.uv) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.color, 4, gl::UNSIGNED_BYTE, gl::TRUE, mem::size_of::() as _, field_offset::(|v| &v.color) as _, ); gl.gl.BindTexture(gl::TEXTURE_2D, self.imgui_data.font_texture); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.BufferData( gl::ARRAY_BUFFER, (vertices.len() * mem::size_of::()) as _, vertices.as_ptr() as _, gl::STREAM_DRAW, ); gl.gl.DrawArrays(gl::TRIANGLES, 0, vertices.len() as _); gl.gl.BindTexture(gl::TEXTURE_2D, 0); gl.gl.BindBuffer(gl::ARRAY_BUFFER, 0); Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } } fn draw_outline_rect(&mut self, rect: Rect, line_width: usize, color: Color) -> GameResult { Ok(()) } fn imgui(&self) -> GameResult<&mut imgui::Context> { unsafe { Ok(&mut *self.imgui.get()) } } fn render_imgui(&mut self, draw_data: &DrawData) -> GameResult { // https://github.com/michaelfairley/rust-imgui-opengl-renderer if let Some((_, gl)) = self.get_context() { unsafe { gl.gl.ActiveTexture(gl::TEXTURE0); gl.gl.Enable(gl::BLEND); gl.gl.BlendEquation(gl::FUNC_ADD); gl.gl.BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA); gl.gl.Disable(gl::CULL_FACE); gl.gl.Disable(gl::DEPTH_TEST); gl.gl.Enable(gl::SCISSOR_TEST); let imgui = self.imgui()?; let [width, height] = imgui.io().display_size; let [scale_w, scale_h] = imgui.io().display_framebuffer_scale; let fb_width = width * scale_w; let fb_height = height * scale_h; gl.gl.Viewport(0, 0, fb_width as _, fb_height as _); let matrix = [ [2.0 / width as f32, 0.0, 0.0, 0.0], [0.0, 2.0 / -(height as f32), 0.0, 0.0], [0.0, 0.0, -1.0, 0.0], [-1.0, 1.0, 0.0, 1.0], ]; gl.gl.UseProgram(self.imgui_data.program_tex); gl.gl.Uniform1i(self.imgui_data.tex_locs.texture, 0); gl.gl.UniformMatrix4fv(self.imgui_data.tex_locs.proj_mtx, 1, gl::FALSE, matrix.as_ptr() as _); if gl.gl.BindSampler.is_loaded() { gl.gl.BindSampler(0, 0); } // let vao = return_param(|x| gl.gl.GenVertexArrays(1, x)); //gl.gl.BindVertexArray(vao); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.position); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.uv); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.color); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.position, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.pos) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.uv, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.uv) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.color, 4, gl::UNSIGNED_BYTE, gl::TRUE, mem::size_of::() as _, field_offset::(|v| &v.col) as _, ); for draw_list in draw_data.draw_lists() { let vtx_buffer = draw_list.vtx_buffer(); let idx_buffer = draw_list.idx_buffer(); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.BufferData( gl::ARRAY_BUFFER, (vtx_buffer.len() * mem::size_of::()) as _, vtx_buffer.as_ptr() as _, gl::STREAM_DRAW, ); gl.gl.BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.imgui_data.ebo); gl.gl.BufferData( gl::ELEMENT_ARRAY_BUFFER, (idx_buffer.len() * mem::size_of::()) as _, idx_buffer.as_ptr() as _, gl::STREAM_DRAW, ); for cmd in draw_list.commands() { match cmd { DrawCmd::Elements { count, cmd_params: DrawCmdParams { clip_rect: [x, y, z, w], texture_id, idx_offset, .. }, } => { gl.gl.BindTexture(gl::TEXTURE_2D, texture_id.id() as _); gl.gl.Scissor( (x * scale_w) as GLint, (fb_height - w * scale_h) as GLint, ((z - x) * scale_w) as GLint, ((w - y) * scale_h) as GLint, ); let idx_size = if mem::size_of::() == 2 { gl::UNSIGNED_SHORT } else { gl::UNSIGNED_INT }; gl.gl.DrawElements( gl::TRIANGLES, count as _, idx_size, (idx_offset * mem::size_of::()) as _, ); } DrawCmd::ResetRenderState => {} DrawCmd::RawCallback { .. } => {} } } } gl.gl.Disable(gl::SCISSOR_TEST); //gl.gl.DeleteVertexArrays(1, &vao); } } Ok(()) } fn draw_triangle_list( &mut self, vertices: Vec, texture: Option<&Box>, shader: BackendShader, ) -> GameResult<()> { unsafe { self.draw_arrays(gl::TRIANGLES, vertices, texture, shader) } } fn supports_vertex_draw(&self) -> bool { true } } impl OpenGLRenderer { unsafe fn draw_arrays( &mut self, vert_type: GLenum, vertices: Vec, texture: Option<&Box>, shader: BackendShader, ) -> GameResult<()> { if vertices.len() == 0 { return Ok(()); } if let Some(gl) = GL_PROC.as_ref() { match shader { BackendShader::Fill => { gl.gl.UseProgram(self.imgui_data.program_fill); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.position); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.uv); gl.gl.EnableVertexAttribArray(self.imgui_data.fill_locs.color); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.position, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.position) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.uv, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.uv) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.fill_locs.color, 4, gl::UNSIGNED_BYTE, gl::TRUE, mem::size_of::() as _, field_offset::(|v| &v.color) as _, ); } BackendShader::Texture => { gl.gl.UseProgram(self.imgui_data.program_tex); gl.gl.BindBuffer(gl::ARRAY_BUFFER, self.imgui_data.vbo); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.position); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.uv); gl.gl.EnableVertexAttribArray(self.imgui_data.tex_locs.color); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.position, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.position) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.uv, 2, gl::FLOAT, gl::FALSE, mem::size_of::() as _, field_offset::(|v| &v.uv) as _, ); gl.gl.VertexAttribPointer( self.imgui_data.tex_locs.color, 4, gl::UNSIGNED_BYTE, gl::TRUE, mem::size_of::() as _, field_offset::(|v| &v.color) as _, ); } } let texture_id = if let Some(texture) = texture { let gl_texture: &Box = std::mem::transmute(texture); gl_texture.texture_id } else { 0 }; gl.gl.BindTexture(gl::TEXTURE_2D, texture_id); gl.gl.BufferData( gl::ARRAY_BUFFER, (vertices.len() * mem::size_of::()) as _, vertices.as_ptr() as _, gl::STREAM_DRAW, ); gl.gl.DrawArrays(vert_type, 0, vertices.len() as _); gl.gl.BindTexture(gl::TEXTURE_2D, 0); gl.gl.BindBuffer(gl::ARRAY_BUFFER, 0); Ok(()) } else { Err(RenderError("No OpenGL context available!".to_string())) } } } impl Drop for OpenGLRenderer { fn drop(&mut self) { *self.context_active.as_ref().borrow_mut() = false; } }