hedgewars: comparison rust/lib-hedgewars-engine/src/render/gl.rs

equal deleted inserted replaced

-:12db7e435ea6
+:19122a329774
-use integral_geometry::Rect;
+use integral_geometry::Rect;
-use std::{
-mem,
+use std::{ffi, ffi::CString, mem, ptr, slice};
-slice,
-ptr,
-ffi,
-ffi::CString,
-};
 #[derive(Debug)]
 pub struct Texture2D {
 pub handle: u32,
 }
 width: u32,
 height: u32,
 internal_format: u32,
 format: u32,
 ty: u32,
-filter: u32
+filter: u32,
 ) -> Self {
 let mut handle = 0;
 unsafe {
 gl::GenTextures(1, &mut handle);
 gl::BindTexture(gl::TEXTURE_2D, handle);
 gl::PixelStorei(gl::UNPACK_ROW_LENGTH, data_stride as i32);
 gl::TexImage2D(
 gl::TEXTURE_2D,
 0,
 width as i32,
 height as i32,
 0,
 format as u32,
 ty,
-data.as_ptr() as *const _
+data.as_ptr() as *const _,
 );
 gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as i32);
 gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as i32);
 gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, filter as i32);
 gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, filter as i32);
 }
-Texture2D {
+Texture2D { handle }
-handle
-}
 }
 pub fn update(&self, region: Rect, data: &[u8], data_stride: u32, format: u32, ty: u32) {
 unsafe {
 gl::BindTexture(gl::TEXTURE_2D, self.handle);
 gl::PixelStorei(gl::UNPACK_ROW_LENGTH, data_stride as i32);
 gl::TexSubImage2D(
 gl::TEXTURE_2D,
-0, // texture level
+0,             // texture level
 region.left(), // texture region
 region.top(),
 region.width() as i32 - 1,
 region.height() as i32 - 1,
-format, // data format
+format,                    // data format
-ty, // data type
+ty,                        // data type
 data.as_ptr() as *const _, // data ptr
 );
 }
 }
 }
 handle: buffer,
 ty,
 usage,
 }
 }
-fn with_data(
+fn with_data(ty: u32, usage: u32, data: &[u8]) -> Buffer {
-ty: u32,
-usage: u32,
-data: &[u8]
-) -> Buffer {
 let mut buffer = 0;
 unsafe {
 gl::GenBuffers(1, &mut buffer);
 gl::BindBuffer(ty, buffer);
 }
 Buffer {
 handle: buffer,
 ty,
-usage
+usage,
 }
 }
 pub fn ty(&self) -> u32 {
 self.ty
 self.handle
 }
 pub fn write_typed<T>(&self, data: &[T]) {
 unsafe {
-let data = slice::from_raw_parts(
+let data =
-data.as_ptr() as *const u8,
+slice::from_raw_parts(data.as_ptr() as *const u8, data.len() * mem::size_of::<T>());
-data.len() * mem::size_of::<T>(),
+gl::BindBuffer(self.ty, self.handle);
+gl::BufferData(
+self.ty,
+data.len() as isize,
+data.as_ptr() as *const _ as *const _,
+self.usage,
 );
+}
+}
+pub fn write(&self, data: &[u8]) {
+unsafe {
 gl::BindBuffer(self.ty, self.handle);
-gl::BufferData(self.ty, data.len() as isize, data.as_ptr() as *const _ as *const _, self.usage);
+gl::BufferData(
-}
+self.ty,
-}
+data.len() as isize,
+data.as_ptr() as *const _ as *const _,
-pub fn write(&self, data: &[u8]) {
+self.usage,
-unsafe {
+);
-gl::BindBuffer(self.ty, self.handle);
-gl::BufferData(self.ty, data.len() as isize, data.as_ptr() as *const _ as *const _, self.usage);
 }
 }
 }
 impl Drop for Buffer {
 impl Shader {
 pub fn new<'a>(
 vs: &str,
 ps: Option<&str>,
-bindings: &[VariableBinding<'a>]
+bindings: &[VariableBinding<'a>],
 ) -> Result<Self, String> {
 unsafe fn compile_shader(ty: u32, shdr: &str) -> Result<u32, String> {
 let shader = gl::CreateShader(ty);
 let len = shdr.len() as i32;
 let shdr = shdr.as_ptr() as *const i8;
 Err(String::from_utf8_unchecked(log))
 } else {
 Ok(shader)
 }
 }
 let vs = unsafe { compile_shader(gl::VERTEX_SHADER, vs)? };
 let ps = if let Some(ps) = ps {
 Some(unsafe { compile_shader(gl::FRAGMENT_SHADER, ps)? })
 } else {
 None
 };
 unsafe {
 let program = gl::CreateProgram();
 gl::AttachShader(program, vs);
 if let Some(ps) = ps {
 gl::AttachShader(program, ps);
 }
 for bind in bindings {
 match bind {
 &VariableBinding::Attribute(ref name, id) => {
 let c_str = CString::new(name.as_bytes()).unwrap();
-gl::BindAttribLocation(program, id, c_str.to_bytes_with_nul().as_ptr() as *const _);
+gl::BindAttribLocation(
-},
+program,
+id,
+c_str.to_bytes_with_nul().as_ptr() as *const _,
+);
+}
 _ => {}
 }
 }
 gl::LinkProgram(program);
 // after linking we setup sampler bindings as specified in the shader
 for bind in bindings {
 match bind {
 VariableBinding::Uniform(name, id) => {
 let c_str = CString::new(name.as_bytes()).unwrap();
-let index = gl::GetUniformLocation(program, c_str.to_bytes_with_nul().as_ptr() as *const _);
+let index = gl::GetUniformLocation(
+program,
+c_str.to_bytes_with_nul().as_ptr() as *const _,
+);
 // TODO: impl for block?
-},
+}
 VariableBinding::UniformBlock(name, id) => {
 let c_str = CString::new(name.as_bytes()).unwrap();
-let index = gl::GetUniformBlockIndex(program, c_str.to_bytes_with_nul().as_ptr() as *const _);
+let index = gl::GetUniformBlockIndex(
+program,
+c_str.to_bytes_with_nul().as_ptr() as *const _,
+);
 gl::UniformBlockBinding(program, index, *id);
 }
 VariableBinding::Sampler(name, id) => {
 let c_str = CString::new(name.as_bytes()).unwrap();
-let index = gl::GetUniformLocation(program, c_str.to_bytes_with_nul().as_ptr() as *const _);
+let index = gl::GetUniformLocation(
+program,
+c_str.to_bytes_with_nul().as_ptr() as *const _,
+);
 gl::Uniform1i(index, *id as i32);
-},
+}
 _ => {}
 }
 }
-Ok(Shader {
+Ok(Shader { program })
-program
-})
 }
 }
 pub fn bind(&self) {
 unsafe {
 }
 pub fn set_matrix(&self, name: &str, matrix: *const f32) {
 unsafe {
 let c_str = CString::new(name).unwrap();
-let index = gl::GetUniformLocation(self.program, c_str.to_bytes_with_nul().as_ptr() as *const _);
+let index = gl::GetUniformLocation(
+self.program,
+c_str.to_bytes_with_nul().as_ptr() as *const _,
+);
 gl::UniformMatrix4fv(index, 1, gl::FALSE, matrix);
 }
 }
 pub fn bind_texture_2d(&self, index: u32, texture: &Texture2D) {
 self.bind();
 unsafe {
 gl::ActiveTexture(gl::TEXTURE0 + index);
 gl::BindTexture(gl::TEXTURE_2D, texture.handle);
 }
 }
 pub components: u32,
 pub stride: u32,
 pub offset: u32,
 }
 // TODO:
 pub struct InputLayout {
 pub elements: Vec<InputElement>,
 }
 pub struct LayoutGuard {
-vao: u32
+vao: u32,
 }
 impl Drop for LayoutGuard {
 fn drop(&mut self) {
 unsafe {
 }
 }
 impl InputLayout {
 pub fn new(elements: Vec<InputElement>) -> Self {
-InputLayout {
+InputLayout { elements }
-elements,
+}
-}
-}
+pub fn bind(
+&mut self,
-pub fn bind(&mut self, buffers: &[(u32, &Buffer)], index_buffer: Option<&Buffer>) -> LayoutGuard {
+buffers: &[(u32, &Buffer)],
+index_buffer: Option<&Buffer>,
+) -> LayoutGuard {
 let mut vao = 0;
 unsafe {
 gl::GenVertexArrays(1, &mut vao);
 gl::BindVertexArray(vao);
 }
 for &(slot, ref buffer) in buffers {
 unsafe {
 gl::BindBuffer(buffer.ty(), buffer.handle());
 }
 for attr in self.elements.iter().filter(|a| a.buffer_slot == slot) {
 unsafe {
 gl::EnableVertexAttribArray(attr.shader_slot);
 match attr.format {
 InputFormat::Float(fmt, normalized) => {
 gl::VertexAttribPointer(
 attr.shader_slot,
 attr.components as i32,
 fmt,
-if normalized {
+if normalized { gl::TRUE } else { gl::FALSE },
-gl::TRUE
-} else {
-gl::FALSE
-},
 attr.stride as i32,
-attr.offset as *const _
+attr.offset as *const _,
 );
 }
 InputFormat::Integer(fmt) => {
 gl::VertexAttribIPointer(
 attr.shader_slot,
 attr.components as i32,
 fmt,
 attr.stride as i32,
-attr.offset as *const _
+attr.offset as *const _,
 );
 }
 }
 }
 }
 }
 if let Some(buf) = index_buffer {
 unsafe {
 gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, buf.handle());
 }
 }
-LayoutGuard {
+LayoutGuard { vao }
-vao
+}
 }
-}
-}

changeset 14705	19122a329774
parent 14702	29dbe9ce8b7d
child 14707	5237b4c44d11