feat(engine): add mesh usage option to renderer::Command::CreateMeshHEADmaster

3 files changed, 48 insertions, 15 deletions

diff --git a/engine/src/renderer.rs b/engine/src/renderer.rs
index 725f208..d7ce02e 100644
--- a/engine/src/renderer.rs
+++ b/engine/src/renderer.rs
@@ -177,6 +177,8 @@ pub enum Command
         /// If `obj_id` is [`ObjectId::Asset`], this mesh data will be used instead of
         /// the mesh data stored in the asset.
         mesh: Option<Mesh>,
+
+        usage: MeshUsage,
     },
     DrawMesh(ObjectId),
     SetPolygonModeConfig(PolygonModeConfig),
@@ -191,6 +193,19 @@ bitflags! {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum MeshUsage
+{
+    /// The mesh data is set only once and used by the GPU at most a few times.
+    Stream,
+
+    /// The mesh data is set only once and used many times.
+    Static,
+
+    /// The mesh data is changed a lot and used many times.
+    Dynamic,
+}
+
 /// Renderer command FIFO queue.
 ///
 /// This component is present in renderer context entities.
@@ -428,6 +443,7 @@ pub fn add_main_render_passes(
                     render_pass.commands.push(Command::CreateMesh {
                         obj_id: ObjectId::Asset(mesh_asset.id()),
                         mesh: None,
+                        usage: MeshUsage::Static,
                     });
                 }
 
diff --git a/engine/src/renderer/opengl.rs b/engine/src/renderer/opengl.rs
index 2419f67..911a155 100644
--- a/engine/src/renderer/opengl.rs
+++ b/engine/src/renderer/opengl.rs
@@ -924,7 +924,11 @@ fn handle_commands(
                         tracing::error!("Failed to create texture object: {err}");
                     }
                 }
-                RendererCommand::CreateMesh { obj_id: mesh_object_id, mesh } => {
+                RendererCommand::CreateMesh {
+                    obj_id: mesh_object_id,
+                    mesh,
+                    usage: mesh_usage,
+                } => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
                         tracing::error!("No GL context is current");
                         continue;
@@ -989,14 +993,18 @@ fn handle_commands(
                         }
                     };
 
-                    let graphics_mesh =
-                        match GraphicsMesh::new(&curr_gl_ctx, &mesh, &vertex_desc) {
-                            Ok(graphics_mesh) => graphics_mesh,
-                            Err(err) => {
-                                tracing::error!("Failed to create mesh: {err}");
-                                continue;
-                            }
-                        };
+                    let graphics_mesh = match GraphicsMesh::new(
+                        &curr_gl_ctx,
+                        &mesh,
+                        mesh_usage,
+                        &vertex_desc,
+                    ) {
+                        Ok(graphics_mesh) => graphics_mesh,
+                        Err(err) => {
+                            tracing::error!("Failed to create mesh: {err}");
+                            continue;
+                        }
+                    };
 
                     graphics_ctx_objects.insert(
                         key,
diff --git a/engine/src/renderer/opengl/graphics_mesh.rs b/engine/src/renderer/opengl/graphics_mesh.rs
index 7c7412c..3cf9181 100644
--- a/engine/src/renderer/opengl/graphics_mesh.rs
+++ b/engine/src/renderer/opengl/graphics_mesh.rs
@@ -9,6 +9,7 @@ use opengl_bindings::vertex_array::{
 };
 
 use crate::mesh::{Mesh, VertexAttrType};
+use crate::renderer::MeshUsage;
 use crate::shader::VertexDescription as ShaderVertexDescription;
 
 #[derive(Debug)]
@@ -27,18 +28,17 @@ impl GraphicsMesh
     pub fn new(
         current_context: &GlCurrentContextWithFns<'_>,
         mesh: &Mesh,
+        mesh_usage: MeshUsage,
         vertex_desc: &ShaderVertexDescription,
     ) -> Result<Self, Error>
     {
+        let buffer_usage = mesh_usage_to_gl_buffer_usage(mesh_usage);
+
         let vertex_arr = GlVertexArray::new(current_context);
         let vertex_buffer = GlBuffer::new(current_context);
 
         vertex_buffer
-            .store(
-                current_context,
-                mesh.vertex_buf().as_bytes(),
-                GlBufferUsage::Static,
-            )
+            .store(current_context, mesh.vertex_buf().as_bytes(), buffer_usage)
             .map_err(Error::StoreVerticesFailed)?;
 
         let vertex_buf_binding_index = 0;
@@ -115,7 +115,7 @@ impl GraphicsMesh
             let index_buffer = GlBuffer::new(current_context);
 
             index_buffer
-                .store(current_context, indices, GlBufferUsage::Static)
+                .store(current_context, indices, buffer_usage)
                 .map_err(Error::StoreIndicesFailed)?;
 
             vertex_arr.bind_element_buffer(current_context, &index_buffer);
@@ -163,3 +163,12 @@ pub enum Error
     #[error("Failed to store indices in index buffer")]
     StoreIndicesFailed(#[source] opengl_bindings::buffer::Error),
 }
+
+fn mesh_usage_to_gl_buffer_usage(mesh_usage: MeshUsage) -> GlBufferUsage
+{
+    match mesh_usage {
+        MeshUsage::Stream => GlBufferUsage::Stream,
+        MeshUsage::Static => GlBufferUsage::Static,
+        MeshUsage::Dynamic => GlBufferUsage::Dynamic,
+    }
+}