use std::marker::PhantomData; use std::mem::size_of_val; use crate::opengl::currently_bound::CurrentlyBound; #[derive(Debug)] pub struct Buffer { buf: gl::types::GLuint, _pd: PhantomData<(Item, ModeT)>, } impl Buffer { pub fn new() -> Self { let mut buffer = gl::types::GLuint::default(); unsafe { gl::GenBuffers(1, &mut buffer); }; Self { buf: buffer, _pd: PhantomData } } #[allow(clippy::inline_always)] #[inline(always)] pub fn bind(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>)) { unsafe { gl::BindBuffer(ModeT::GL_ENUM, self.buf); } // SAFETY: The buffer object is bound above let currently_bound = unsafe { CurrentlyBound::new() }; cb(currently_bound); } /// Stores items in the currently bound buffer. pub fn store(_currently_bound: &CurrentlyBound, items: &[Item], usage: Usage) { unsafe { #[allow(clippy::cast_possible_wrap)] gl::BufferData( ModeT::GL_ENUM, size_of_val(items) as gl::types::GLsizeiptr, items.as_ptr().cast(), usage.into_gl(), ); } } } impl Drop for Buffer { fn drop(&mut self) { #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)] unsafe { gl::DeleteBuffers(1, &self.buf); } } } /// Buffer usage. #[derive(Debug)] #[allow(dead_code)] pub enum Usage { /// The buffer data is set only once and used by the GPU at most a few times. Stream, /// The buffer data is set only once and used many times. Static, /// The buffer data is changed a lot and used many times. Dynamic, } impl Usage { fn into_gl(self) -> gl::types::GLenum { match self { Self::Stream => gl::STREAM_DRAW, Self::Static => gl::STATIC_DRAW, Self::Dynamic => gl::DYNAMIC_DRAW, } } } /// Buffer mode. pub trait Mode { #[doc(hidden)] const GL_ENUM: gl::types::GLenum; } /// Array buffer kind. #[derive(Debug)] pub struct ArrayKind; impl Mode for ArrayKind { const GL_ENUM: gl::types::GLenum = gl::ARRAY_BUFFER; } /// Element array buffer kind. #[derive(Debug)] pub struct ElementArrayKind; impl Mode for ElementArrayKind { const GL_ENUM: gl::types::GLenum = gl::ELEMENT_ARRAY_BUFFER; }