feat(model): enhance model handling with combined mesh generation and draw command struct

Author: AhmedAmrNabil

src/common/mesh/mesh.hpp

@@ -22,6 +22,8 @@ namespace our {
         // We need to remember the number of elements that will be draw by glDrawElements
         GLsizei elementCount;
         GLsizei vertexCount;
+        std::vector<Vertex> vertices;  // Store vertices for potential future use (e.g., collision, CPU-side processing)
+        std::vector<unsigned int> indices;  // Store indices for potential future use
 
     public:
         GLsizei getVertexCount() const {
@@ -90,6 +92,8 @@ namespace our {
 
             elementCount = static_cast<GLsizei>(elements.size());
             vertexCount = static_cast<GLsizei>(vertices.size());
+            this->vertices = vertices;
+            this->indices = elements;
         }
 
         // this function should render the mesh
@@ -105,6 +109,14 @@ namespace our {
             glDeleteVertexArrays(1, &VAO);
         }
 
+        std::vector<Vertex> getVertices() const {
+            return vertices;
+        }
+
+        std::vector<unsigned int> getIndices() const {
+            return indices;
+        }
+
         Mesh(Mesh const&) = delete;
         Mesh& operator=(Mesh const&) = delete;
     };

src/common/model/model.cpp

@@ -13,23 +13,20 @@
 namespace our {
     int Model::ID_COUNTER = 0;
 
-    void Model::draw(const glm::mat4& VP, const glm::mat4& modelMatrix, const std::vector<our::LightRenderData>& lights,
-                     const glm::vec3& cameraPosition) const {
-        glm::mat4 MVP = VP * modelMatrix;
+    void Model::generateDrawCommands(std::vector<RenderCommand>& modelCommands,
+                                     std::vector<RenderCommand>& transparentCommands,
+                                     const glm::mat4& modelMatrix) const {
         for (const auto& submesh : submeshes) {
-            // this dynamic cast will always pass
-            // as we only make LitMaterials when loading the model
-            if (LitMaterial* litMaterial = dynamic_cast<LitMaterial*>(submesh->material)) {
-                litMaterial->setup(lights);
-                litMaterial->shader->set("cameraPos", cameraPosition);
-                litMaterial->shader->set("model", modelMatrix * submesh->transform);
-                litMaterial->shader->set("transform", MVP * submesh->transform);
-            } else if (submesh->material) {
-                submesh->material->setup();
-                submesh->material->shader->set("model", modelMatrix * submesh->transform);
-                submesh->material->shader->set("transform", MVP * submesh->transform);
+            RenderCommand cmd;
+            cmd.localToWorld = modelMatrix * submesh->transform;
+            cmd.center = glm::vec3(cmd.localToWorld * glm::vec4(0, 0, 0, 1));
+            cmd.mesh = submesh->mesh;
+            cmd.material = submesh->material;
+            if (submesh->material->transparent) {
+                transparentCommands.push_back(cmd);
+            } else {
+                modelCommands.push_back(cmd);
             }
-            submesh->mesh->draw();
         }
     }
 
@@ -69,6 +66,7 @@ namespace our {
         loadMaterialsFromScene(scene);
         glm::mat4 identity(1.0f);
         processNode(scene->mRootNode, scene, identity);
+        generateCombinedMesh();
     }
 
     void Model::processNode(aiNode* node, const aiScene* scene, glm::mat4& parentTransform) {
@@ -263,7 +261,8 @@ namespace our {
         material->transparent = material->tint.a < 0.999f;
 
         if (material->transparent) {
-            material->pipelineState.depthTesting.enabled = GL_FALSE;  // disable depth writing for transparent materials
+            material->pipelineState.depthTesting.enabled = GL_TRUE;  // disable depth writing for transparent materials
+            material->pipelineState.depthMask = false;
             material->pipelineState.blending.enabled = true;
             material->pipelineState.blending.sourceFactor = GL_SRC_ALPHA;
             int blendFunc = 0;
@@ -364,6 +363,36 @@ namespace our {
         }
     }
 
+    void Model::generateCombinedMesh() {
+        std::vector<Vertex> combinedVertices;
+        std::vector<unsigned int> combinedIndices;
+
+        for (const auto& submesh : submeshes) {
+            unsigned int indexOffset = static_cast<unsigned int>(combinedVertices.size());
+
+            // Transform each vertex into model space using the submesh's local transform
+            for (const Vertex& v : submesh->mesh->getVertices()) {
+                Vertex transformed = v;
+
+                // Apply the submesh transform to position
+                glm::vec4 worldPos = submesh->transform * glm::vec4(v.position, 1.0f);
+                transformed.position = glm::vec3(worldPos);
+
+                // Transform normal using the normal matrix (inverse transpose)
+                glm::mat3 normalMatrix = glm::mat3(glm::transpose(glm::inverse(submesh->transform)));
+                transformed.normal = glm::normalize(normalMatrix * v.normal);
+
+                combinedVertices.push_back(transformed);
+            }
+
+            // Re-base indices so they point into the combined vertex buffer
+            for (unsigned int idx : submesh->mesh->getIndices()) {
+                combinedIndices.push_back(idx + indexOffset);
+            }
+        }
+        combinedMesh = new Mesh(combinedVertices, combinedIndices);
+    }
+
     Model::~Model() {
         for (auto& submesh : submeshes) {
             delete submesh->mesh;

src/common/model/model.hpp

@@ -12,28 +12,33 @@
 
 #include "components/mesh-renderer.hpp"
 #include "material/material.hpp"
+#include "systems/render-command.hpp"
 
 namespace our {
-
     class Model {
         static int ID_COUNTER;  // this is used to give each model a unique ID for caching purposes
         int id;                 // the unique ID of this model
         std::string modelDirectory;
-        std::vector<MeshRendererComponent*> submeshes;
+        std::vector<MeshRendererComponent*> submeshes;  // submeshes with opaque materials (rendered in the first pass)
 
         void processNode(aiNode* node, const aiScene* scene, glm::mat4& parentTransform);
         MeshRendererComponent* processMesh(aiMesh* mesh, const aiScene* scene);
         void processVertexBoneData(aiMesh* mesh, std::vector<Vertex>& vertices);
         void loadMaterialsFromScene(const aiScene* scene);
         LitMaterial* loadMaterial(const aiScene* scene, const aiMaterial* mat);
         Texture2D* loadTextureFromMaterial(const aiScene* scene, const aiMaterial* mat, aiTextureType type);
-
+        void generateCombinedMesh();  // will be used for collision detection and other non-rendering purposes
+        Mesh* combinedMesh;           // a single mesh that combines all the submeshes of this model (used for collision
+                                      // detection and other non-rendering purposes)
     public:
         Model() {
             id = ID_COUNTER++;
         };
-        void draw(const glm::mat4& VP, const glm::mat4& modelMatrix, const std::vector<our::LightRenderData>& lights,
-                  const glm::vec3& cameraPosition) const;
+        void generateDrawCommands(std::vector<RenderCommand>& modelCommands,
+                                  std::vector<RenderCommand>& transparentCommands, const glm::mat4& modelMatrix) const;
+        Mesh* getCombinedMesh() const {
+            return combinedMesh;
+        }
         ~Model();
         void loadFromFile(const std::string& path);
     };

src/common/systems/forward-renderer.cpp

@@ -1,5 +1,6 @@
 #include "forward-renderer.hpp"
 
+#include "../components/model-renderer.hpp"
 #include "../mesh/mesh-utils.hpp"
 #include "../texture/texture-utils.hpp"
 
@@ -131,7 +132,6 @@ namespace our {
         opaqueCommands.clear();
         transparentCommands.clear();
         sceneLights.clear();
-        modelCommands.clear();
         for (auto entity : world->getEntities()) {
             // If we hadn't found a camera yet, we look for a camera in this entity
             if (!camera) camera = entity->getComponent<CameraComponent>();
@@ -169,11 +169,8 @@ namespace our {
             }
 
             if (auto modelRenderer = entity->getComponent<ModelRendererComponent>(); modelRenderer) {
-                RenderCommand command;
-                command.localToWorld = modelRenderer->getOwner()->getLocalToWorldMatrix();
-                command.center = glm::vec3(command.localToWorld * glm::vec4(0, 0, 0, 1));
-                command.model = modelRenderer->model;
-                modelCommands.push_back(command);
+                glm::mat4 localToWorld = modelRenderer->getOwner()->getLocalToWorldMatrix();
+                modelRenderer->model->generateDrawCommands(opaqueCommands, transparentCommands, localToWorld);
             }
         }
 
@@ -241,10 +238,6 @@ namespace our {
             skySphere->draw();
         }
 
-        for (const RenderCommand& command : modelCommands) {
-            command.model->draw(VP, command.localToWorld, sceneLights, cameraPosition);
-        }
-
         // draw all the transparent commands
         for (const RenderCommand& command : transparentCommands) {
             command.material->setup();

src/common/systems/forward-renderer.hpp

@@ -8,22 +8,10 @@
 #include "../asset-loader.hpp"
 #include "../components/camera.hpp"
 #include "../components/mesh-renderer.hpp"
-#include "../components/model-renderer.hpp"
 #include "../ecs/world.hpp"
+#include "render-command.hpp"
 
 namespace our {
-
-    // The render command stores command that tells the renderer that it should draw
-    // the given mesh at the given localToWorld matrix using the given material
-    // The renderer will fill this struct using the mesh renderer components
-    struct RenderCommand {
-        glm::mat4 localToWorld;
-        glm::vec3 center;
-        Mesh* mesh;
-        Material* material;
-        Model* model;
-    };
-
     // A forward renderer is a renderer that draw the object final color directly to the framebuffer
     // In other words, the fragment shader in the material should output the color that we should see on the screen
     // This is different from more complex renderers that could draw intermediate data to a framebuffer before computing
@@ -36,7 +24,6 @@ namespace our {
         // reallocating them every frame
         std::vector<RenderCommand> opaqueCommands;
         std::vector<RenderCommand> transparentCommands;
-        std::vector<RenderCommand> modelCommands;
         // Objects used for rendering a skybox
         Mesh* skySphere;
         TexturedMaterial* skyMaterial;

src/common/systems/render-command.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "material/material.hpp"
+#include "mesh/mesh.hpp"
+
+namespace our {
+    // The render command stores command that tells the renderer that it should draw
+    // the given mesh at the given localToWorld matrix using the given material
+    // The renderer will fill this struct using the mesh renderer components
+    struct RenderCommand {
+        glm::mat4 localToWorld;
+        glm::vec3 center;
+        Mesh* mesh;
+        Material* material;
+    };
+};  // namespace our