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

equal deleted inserted replaced

-:ff1432e873bd
+:e7eb0cd5b0e4
 data: &[u8],
 data_stride: Option<NonZeroU32>,
 size: Size,
 internal_format: TextureInternalFormat,
 format: TextureFormat,
-ty: TextureDataType,
+data_type: TextureDataType,
 filter: TextureFilter,
 ) -> Self {
 if is_out_of_bounds(data, data_stride, size) {
 return Self { handle: None, size };
 }
 internal_format as i32,
 size.width as i32,
 size.height as i32,
 0,
 format as u32,
-ty as u32,
+data_type as u32,
 data.as_ptr() as *const _,
 )
 }
 tex_params(filter);
 &self,
 region: Rect,
 data: &[u8],
 data_stride: Option<NonZeroU32>,
 format: TextureFormat,
-ty: TextureDataType,
+data_type: TextureDataType,
 ) {
 if is_out_of_bounds(data, data_stride, self.size) {
 return;
 }
 region.left(),
 region.top(),
 region.width() as i32,
 region.height() as i32,
 format as u32,
-ty as u32,
+data_type as u32,
 data.as_ptr() as *const _,
 );
 }
 }
 }
 }
 }
 }
 }
+#[derive(Clone, Copy, Debug)]
+#[repr(u32)]
+pub enum BufferType {
+Array = gl::ARRAY_BUFFER,
+ElementArray = gl::ELEMENT_ARRAY_BUFFER,
+}
+#[derive(Clone, Copy, Debug)]
+#[repr(u32)]
+pub enum BufferUsage {
+DynamicDraw = gl::DYNAMIC_DRAW,
+}
 #[derive(Debug)]
 pub struct Buffer {
-pub handle: u32,
+pub handle: Option<NonZeroU32>,
-pub ty: u32,
+pub buffer_type: BufferType,
-pub usage: u32,
+pub usage: BufferUsage,
 }
 impl Buffer {
-pub fn empty(
+pub fn empty(buffer_type: BufferType, usage: BufferUsage) -> Buffer {
-ty: u32,
-usage: u32,
-//size: isize
-) -> Buffer {
 let mut buffer = 0;
 unsafe {
 gl::GenBuffers(1, &mut buffer);
-gl::BindBuffer(ty, buffer);
-//gl::BufferData(ty, size, ptr::null_mut(), usage);
 }
 Buffer {
-handle: buffer,
+handle: NonZeroU32::new(buffer),
-ty,
+buffer_type: buffer_type,
 usage,
 }
 }
-fn with_data(ty: u32, usage: u32, data: &[u8]) -> Buffer {
+fn with_data(buffer_type: BufferType, usage: BufferUsage, data: &[u8]) -> Buffer {
 let mut buffer = 0;
 unsafe {
 gl::GenBuffers(1, &mut buffer);
-gl::BindBuffer(ty, buffer);
+if buffer != 0 {
-gl::BufferData(ty, data.len() as isize, data.as_ptr() as _, usage);
+gl::BindBuffer(buffer_type as u32, buffer);
+gl::BufferData(
+buffer_type as u32,
+data.len() as isize,
+data.as_ptr() as _,
+usage as u32,
+);
+}
 }
 Buffer {
-handle: buffer,
+handle: NonZeroU32::new(buffer),
-ty,
+buffer_type,
 usage,
 }
 }
-pub fn ty(&self) -> u32 {
+pub fn ty(&self) -> BufferType {
-self.ty
+self.buffer_type
 }
-pub fn handle(&self) -> u32 {
+pub fn handle(&self) -> Option<NonZeroU32> {
 self.handle
 }
 pub fn write_typed<T>(&self, data: &[T]) {
-unsafe {
+if let Some(handle) = self.handle {
-let data =
+unsafe {
-slice::from_raw_parts(data.as_ptr() as *const u8, data.len() * mem::size_of::<T>());
+gl::BindBuffer(self.buffer_type as u32, handle.get());
+gl::BufferData(
-gl::BindBuffer(self.ty, self.handle);
+self.buffer_type as u32,
-gl::BufferData(
+(data.len() * mem::size_of::<T>()) as isize,
-self.ty,
+data.as_ptr() as *const _,
-data.len() as isize,
+self.usage as u32,
-data.as_ptr() as *const _ as *const _,
+);
-self.usage,
+}
-);
 }
 }
 pub fn write(&self, data: &[u8]) {
-unsafe {
+if let Some(handle) = self.handle {
-gl::BindBuffer(self.ty, self.handle);
+unsafe {
-gl::BufferData(
+gl::BindBuffer(self.buffer_type as u32, handle.get());
-self.ty,
+gl::BufferData(
-data.len() as isize,
+self.buffer_type as u32,
-data.as_ptr() as *const _ as *const _,
+data.len() as isize,
-self.usage,
+data.as_ptr() as *const _,
-);
+self.usage as u32,
+);
+}
 }
 }
 }
 impl Drop for Buffer {
 fn drop(&mut self) {
-unsafe {
+if let Some(handle) = self.handle {
-gl::DeleteBuffers(1, &self.handle);
+let handle = handle.get();
+unsafe {
+gl::DeleteBuffers(1, &handle);
+}
 }
 }
 }
 #[derive(Debug)]
 pub fn new<'a>(
 vs: &str,
 ps: Option<&str>,
 bindings: &[VariableBinding<'a>],
 ) -> Result<Self, String> {
-unsafe fn compile_shader(ty: u32, shdr: &str) -> Result<u32, String> {
+unsafe fn compile_shader(shader_type: u32, shader_code: &str) -> Result<u32, String> {
-let shader = gl::CreateShader(ty);
+let shader = gl::CreateShader(shader_type);
-let len = shdr.len() as i32;
+let len = shader_code.len() as i32;
-let shdr = shdr.as_ptr() as *const i8;
+let code_strings = shader_code.as_ptr() as *const i8;
-gl::ShaderSource(shader, 1, &shdr, &len);
+gl::ShaderSource(shader, 1, &code_strings, &len);
 gl::CompileShader(shader);
 let mut success = 0i32;
 gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut success as _);
 gl::GenVertexArrays(1, &mut vao);
 gl::BindVertexArray(vao);
 }
 for &(slot, ref buffer) in buffers {
-unsafe {
+if let Some(handle) = buffer.handle() {
-gl::BindBuffer(buffer.ty(), buffer.handle());
+unsafe {
+gl::BindBuffer(buffer.ty() as u32, handle.get());
+}
 }
 for attr in self.elements.iter().filter(|a| a.buffer_slot == slot) {
 unsafe {
 gl::EnableVertexAttribArray(attr.shader_slot);
 }
 }
 }
 if let Some(buf) = index_buffer {
-unsafe {
+if let Some(handle) = buf.handle() {
-gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, buf.handle());
+unsafe {
+gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, handle.get());
+}
 }
 }
 LayoutGuard { vao }
 }

changeset 15761	e7eb0cd5b0e4
parent 15760	ff1432e873bd
child 15762	84c07aa94b61