reorganize model class

Author: ZzzhHe

include/Triangle.hpp

@@ -2,28 +2,53 @@
 
 #include <glm/glm.hpp>
 
-struct Vertex {
-    glm::vec4 Position;     // Position of the vertex in homogenous coordinates
-    glm::vec3 Normal;       // Normal vector for the vertex
-    glm::vec2 TexCoords;    // Texture coordinates
-    glm::vec3 Color;        // Color of the vertex
+#include "color.h"
+
+namespace simple_renderer {
+
+class Vertex {
+public:
+
+    // Default constructor
+    Vertex() = default;
+    // Copy constructor
+    Vertex(const Vertex& vertex) = default;
+    Vertex& operator=(const Vertex& vertex) = default;
+    // Move constructor
+    Vertex(Vertex&& vertex) = default;
+    Vertex& operator=(Vertex&& vertex) = default;
+    // Destructor
+    ~Vertex() = default;
 
     // Constructor with parameters
-    Vertex(const glm::vec4& pos, const glm::vec3& norm, const glm::vec2& tex, const glm::vec3& color = glm::vec3(1.0f, 1.0f, 1.0f))
-        : Position(pos), Normal(norm), TexCoords(tex), Color(color) {}
+    explicit Vertex(const glm::vec4& pos, const glm::vec3& norm, const glm::vec2& tex, const Color& color_)
+        : position_(pos), normal_(norm), texCoords_(tex), color_(color_) {}
 
     // Transform the vertex with a matrix
-    Vertex transform(const glm::mat4& matrix) const {
-        return Vertex(matrix * Position, Normal, TexCoords, Color);
+    void transform(const glm::mat4& matrix) {
+        position_ = matrix * position_;
     }
 
     // Perspective divide to convert from clip space to normalized device coordinates
     void perspectiveDivide() {
-        if (Position.w != 0) {
-            Position.x /= Position.w;
-            Position.y /= Position.w;
-            Position.z /= Position.w;
-            Position.w = 1.0f; // Homogenize
+        if (position_.w != 0) {
+            position_.x /= position_.w;
+            position_.y /= position_.w;
+            position_.z /= position_.w;
+            position_.w = 1.0f; // Homogenize
         }
     }
-};
+
+    glm::vec4 position() const { return position_; }
+    glm::vec3 normal() const { return normal_; }
+    glm::vec2 texCoords() const { return texCoords_; }
+    Color color() const { return color_; }
+    
+private:
+    glm::vec4 position_;     // Position of the vertex in homogenous coordinates
+    glm::vec3 normal_;       // Normal vector for the vertex
+    glm::vec2 texCoords_;    // Texture coordinates
+    Color color_;        // Color of the vertex
+};
+
+}

include/Vertex.hpp

@@ -21,7 +21,7 @@
 #include <string>
 
 #include "color.h"
-#include "vector.hpp"
+#include "log_math.hpp"
 
 namespace simple_renderer {
 

include/light.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <glm/glm.hpp>
+
+class Material {
+public:
+    // Default constructor
+    Material() = default;
+    // Copy constructor
+    Material(const Material& material) = default;
+    Material& operator=(const Material& material) = default;
+    // Move constructor
+    Material(Material&& material) = default;
+    Material& operator=(Material&& material) = default;
+    // Destructor
+    ~Material() = default;
+
+    float shininess = 0.0f;
+    glm::vec3 ambient;
+    glm::vec3 diffuse;
+    glm::vec3 specular;
+};

include/material.hpp

@@ -25,90 +25,43 @@
 #include "color.h"
 #include "config.h"
 #include "log_system.h"
-#include "matrix.hpp"
-#include "vector.hpp"
+#include "log_math.hpp"
 
-namespace simple_renderer {
-
-class Material {
-public:
-    Material() = default;
-    Material(const Material& material) = default;
-    Material(Material&& material) = default;
-    auto operator=(const Material& material) -> Material& = default;
-    auto operator=(Material&& material) -> Material& = default;
-    ~Material() = default;
-
-    float shininess = 0.0f;
-    glm::vec3 ambient;
-    glm::vec3 diffuse;
-    glm::vec3 specular;
-};
-
-class Vertex {
-public:
-    explicit Vertex(glm::vec3 coord, glm::vec3 normal, glm::vec2 texture_coord, const Color& color);
-    Vertex() = default;
-    Vertex(const Vertex& vertex) = default;
-    Vertex(Vertex&& vertex) = default;
-    auto operator=(const Vertex& vertex) -> Vertex& = default;
-    auto operator=(Vertex&& vertex) -> Vertex& = default;
-    ~Vertex() = default;
-
-    [[nodiscard]] Vertex operator*(const glm::mat4 &tran) const;
-
-    glm::vec3 coord_;
-    glm::vec3 normal_;
-    glm::vec2 texture_coord_;
-    Color color_;
-};
+#include "vertex.hpp"
+#include "face.hpp"
 
-class Face {
-public:
-    explicit Face(const Vertex& v0, const Vertex& v1, const Vertex& v2, Material material);
-    Face() = default;
-    Face(const Face& face) = default;
-    Face(Face&& face) = default;
-    auto operator=(const Face& face) -> Face& = default;
-    auto operator=(Face&& face) -> Face& = default;
-    ~Face() = default;
-
-    [[nodiscard]] Face operator*(const glm::mat4 &tran) const;
-
-    Vertex v0_;
-    Vertex v1_;
-    Vertex v2_;
-    glm::vec3 normal_;
-    Material material_;
-};
+namespace simple_renderer {
 
 class Model {
 public:
-    Model(const std::string &model_path);
+    
+    // Default constructor
     Model() = default;
+    // Default copy constructor
     Model(const Model& model) = default;
+    Model& operator=(const Model& model) = default;
+    // Default move constructor
     Model(Model&& model) = default;
-    auto operator=(const Model& model) -> Model& = default;
-    auto operator=(Model&& model) -> Model& = default;
+    Model& operator=(Model&& model) = default;
     ~Model() = default;
 
-    [[nodiscard]] Model operator*(const glm::mat4 &tran) const;
+    Model(const std::string &model_path);
+
+    void transform(const glm::mat4 &tran);
 
-    const std::vector<Face>& GetFaces() const;
-    const std::string ModelPath() const;
+    const std::vector<Face>& faces() const { return faces_; };
+    const std::string& modelPath() const { return directory_; };
 
 private:
     static constexpr const uint8_t kTriangleFaceVertexCount = 3;
+    std::string directory_;
 
     std::vector<Face> faces_;
-    std::string model_path_ = "";
 
-    std::pair<glm::vec3, glm::vec3> GetMaxMinXYZ() const;
-    
-    void NormalizeModel();
-    void LoadModel(const std::string& path);
-    void ProcessNode(aiNode* node, const aiScene* scene);
-    Face ProcessMesh(aiMesh* mesh, const aiScene* scene);
+    void loadModel(const std::string& path);
+    void processNode(aiNode* node, const aiScene* scene);
+    void processMesh(aiMesh* mesh, const aiScene* scene);
+    Material processMaterial(aiMaterial* material);
 };
 }  // namespace simple_renderer
 

include/matrix.hpp

@@ -17,9 +17,8 @@
 #ifndef SIMPLERENDER_SRC_INCLUDE_SHADER_BASE_H_
 #define SIMPLERENDER_SRC_INCLUDE_SHADER_BASE_H_
 
-#include "matrix.hpp"
 #include "model.hpp"
-#include "vector.hpp"
+#include "log_math.hpp"
 
 namespace simple_renderer {
 

include/model.hpp

@@ -23,10 +23,9 @@
 
 #include "light.h"
 #include "log_system.h"
-#include "matrix.hpp"
 #include "model.hpp"
 #include "shader_base.h"
-#include "vector.hpp"
+#include "log_math.hpp"
 
 namespace simple_renderer {
 

include/shader_base.h

@@ -47,8 +47,10 @@ auto DefaultShader::Vertex(const ShaderVertexIn &shader_vertex_in) const
     -> ShaderVertexOut {
   auto face(shader_vertex_in.face_);
 
-  face = face * shader_data_.model_matrix_ * shader_data_.view_matrix_ *
-         shader_data_.project_matrix_;
+    face.transform(
+        shader_data_.project_matrix_ 
+        * shader_data_.view_matrix_ 
+        * shader_data_.model_matrix_);
 
   /// @todo 变换贴图
   return ShaderVertexOut(face);