update according to the reviews

Signed-off-by: ZhuohaoHe <zhuohao.he@outlook.com>

Author: ZzzhHe

$EXECUTABLE_OUTPUT_PATH/logs/SimpleRendererLog.log

@@ -0,0 +1,8 @@
+[2024-08-09 15:04:13.936] [simple_renderer.cpp:57 SimpleRenderer] [info] SimpleRenderer init with 1920, 1080
+[2024-08-09 15:04:13.949] [model.cpp:115 Model] [info] 加载模型: obj/utah-teapot/utah-teapot.obj, 顶点数: 2082, 法线数: 2082, 颜色数: 2082, UV数: 1036, 子模型数: 1, 材质数: 1
+[2024-08-09 15:04:13.960] [simple_renderer.cpp:61 render] [info] render model: obj/utah-teapot/utah-teapot.obj
+[2024-08-09 15:04:13.961] [simple_renderer.cpp:197 DrawModel] [info] draw obj/utah-teapot/utah-teapot.obj
+[2024-08-09 15:37:12.808] [simple_renderer.cpp:57 SimpleRenderer] [info] SimpleRenderer init with 1920, 1080
+[2024-08-09 15:37:12.821] [model.cpp:118 Model] [info] 加载模型: obj/utah-teapot/utah-teapot.obj, 顶点数: 2082, 法线数: 2082, 颜色数: 2082, UV数: 1036, 子模型数: 1, 材质数: 1
+[2024-08-09 15:37:12.833] [simple_renderer.cpp:61 render] [info] render model: obj/utah-teapot/utah-teapot.obj
+[2024-08-09 15:37:12.835] [simple_renderer.cpp:197 DrawModel] [info] draw obj/utah-teapot/utah-teapot.obj

.gitignore

@@ -14,4 +14,4 @@ tools/opensbi/build
 .idea
 3rd
 Doxyfile
-include/config.h
+src/include/config.h

CMakeLists.txt

@@ -7,8 +7,6 @@
 # 设置最小 cmake 版本
 cmake_minimum_required(VERSION 3.27 FATAL_ERROR)
 
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 # 设置项目名与版本
 project(SimpleRenderer
@@ -42,15 +40,15 @@ set(FONT_FILE_PATH "${wqy_font_SOURCE_DIR}/wqy-zenhei.ttc")
 include(ProcessorCount)
 ProcessorCount(NPROC)
 # 日志文件路径
-set(LOG_FILE_PATH "${PROJECT_SOURCE_DIR}/build/logs/SimpleRendererLog.log")
+set(LOG_FILE_PATH "$EXECUTABLE_OUTPUT_PATH/logs/SimpleRendererLog.log")
 # 日志文件大小
 set(LOG_FILE_MAX_SIZE 1024*1024*4)
 # 日志文件数量
 set(LOG_FILE_MAX_COUNT 8)
 # 生成配置头文件
 configure_file(
         "${PROJECT_SOURCE_DIR}/cmake/config.h.in"
-        "${PROJECT_SOURCE_DIR}/include/config.h"
+        "${PROJECT_SOURCE_DIR}/src/include/config.h"
 )
 
 # 添加要编译的目录

CMakePresets.json

@@ -2,20 +2,10 @@
   "version": 6,
   "cmakeMinimumRequired": {
     "major": 3,
-    "minor": 27,
+    "minor": 23,
     "patch": 0
   },
   "configurePresets": [
-    {
-      "name": "host",
-      "description": "Linux Only",
-      "hidden": true,
-      "condition": {
-        "type": "equals",
-        "lhs": "${hostSystemName}",
-        "rhs": "Linux"
-      }
-    },
     {
       "name": "std",
       "description": "This preset makes sure the project actually builds with at least the specified standard",
@@ -30,13 +20,10 @@
       }
     },
     {
-      "name": "configurePresets_base",
+      "name": "config-base",
       "hidden": true,
-      "inherits": [
-        "host",
-        "std"
-      ],
-      "displayName": "configurePresets_base",
+      "inherits": [ "std" ],
+      "displayName": "config-base",
       "description": "base configurePresets",
       "binaryDir": "${sourceDir}/build",
       "cacheVariables": {
@@ -58,14 +45,47 @@
         }
       }
     },
+    {
+      "name": "config-mac",
+      "hidden": true,
+      "inherits": [ "config-base" ],
+      "displayName": "config-base",
+      "description": "macOS configurePresets",
+      "condition": {
+          "type": "equals",
+          "lhs": "${hostSystemName}",
+          "rhs": "Darwin"
+        },
+        "cacheVariables": {
+          "CMAKE_MACOSX_RPATH": "1",
+          "CMAKE_INSTALL_RPATH": "/Library/Frameworks",
+          "CMAKE_BUILD_WITH_INSTALL_RPATH": "TRUE"
+        }
+    },
     {
       "name": "build",
       "hidden": false,
       "inherits": [
-        "configurePresets_base"
+        "config-base"
+      ],
+      "displayName": "build-base",
+      "description": "build base configurePresets"
+    }, 
+    {
+      "name": "build-mac",
+      "hidden": false,
+      "inherits": [
+        "config-mac"
       ],
-      "displayName": "build",
-      "description": "build"
+      "displayName": "build-mac",
+      "description": "macOS build configurePresets"
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "build",
+      "displayName": "Build",
+      "configurePreset": "config-base"
     }
   ]
 }

cmake/3rd.cmake

@@ -57,8 +57,7 @@ CPMAddPackage(
         "gtest_force_shared_crt ON"
 )
 
-# SDL2
-
+# https://github.com/libsdl-org/SDL
 CPMAddPackage(
         NAME SDL2
         GITHUB_REPOSITORY libsdl-org/SDL
@@ -70,22 +69,17 @@ CPMAddPackage(
         "SDL_STATIC_PIC ON"
         "SDL_WERROR OFF"
 )
-find_package(SDL2 REQUIRED)
-
-# https://github.com/aminosbh/sdl2-cmake-modules.git
-CPMAddPackage(
-        NAME sdl2-cmake-modules
-        GIT_REPOSITORY https://github.com/aminosbh/sdl2-cmake-modules.git
-        GIT_TAG ad006a3daae65a612ed87415037e32188b81071e
-        DOWNLOAD_ONLY True
-)
-if (SDL2_ADDED)
-    add_library(SDL2::SDL2)
-endif()
 
-if (sdl2-cmake-modules_ADDED)
-    list(APPEND CMAKE_MODULE_PATH ${sdl2-cmake-modules_SOURCE_DIR})
-endif ()
+# # https://github.com/aminosbh/sdl2-cmake-modules.git
+# CPMAddPackage(
+#         NAME sdl2-cmake-modules
+#         GIT_REPOSITORY https://github.com/aminosbh/sdl2-cmake-modules.git
+#         GIT_TAG ad006a3daae65a612ed87415037e32188b81071e
+#         DOWNLOAD_ONLY True
+# )
+# if (sdl2-cmake-modules_ADDED)
+#     list(APPEND CMAKE_MODULE_PATH ${sdl2-cmake-modules_SOURCE_DIR})
+# endif ()
 
 # https://github.com/tinyobjloader/tinyobjloader.git
 CPMAddPackage(
@@ -103,11 +97,16 @@ if (tinyobjloader_ADDED)
     )
 endif ()
 
+# https://github.com/g-truc/glm
 CPMAddPackage(
     NAME glm
     GITHUB_REPOSITORY g-truc/glm
     GIT_TAG 1.0.1
 )
+if (glm_ADDED)
+    add_library(glm INTERFACE)
+    target_include_directories(glm INTERFACE ${glm_SOURCE_DIR})
+endif ()
 
 # https://github.com/nothings/stb.git
 CPMAddPackage(
@@ -236,12 +235,6 @@ if (NOT LCOV_EXE)
             "Following https://github.com/linux-test-project/lcov to install.")
 endif ()
 
-find_package(SDL2 REQUIRED)
-if (NOT SDL2_FOUND)
-    message(FATAL_ERROR "sdl2 not found.\n"
-            "Following https://github.com/libsdl-org/SDL to install.")
-endif ()
-
 find_package(OpenMP REQUIRED)
 if (NOT OpenMP_FOUND)
     message(FATAL_ERROR "OpenMP not found.\n"
@@ -252,10 +245,4 @@ find_package(spdlog REQUIRED)
 if (NOT spdlog_FOUND)
     message(FATAL_ERROR "spdlog not found.\n"
             "Following https://github.com/gabime/spdlog to install.")
-endif ()
-
-find_package(glm REQUIRED)
-if (NOT glm_FOUND)
-    message(FATAL_ERROR "glm not found.\n"
-            "Following https://github.com/g-truc/glm tp install")
 endif ()

include/config.h

@@ -12,7 +12,7 @@ file(GLOB_RECURSE SRC_FILES CONFIGURE_DEPENDS
 add_library(${PROJECT_NAME} STATIC ${SRC_FILES})
 
 target_include_directories(${PROJECT_NAME} PRIVATE
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/include>
     $<INSTALL_INTERFACE:include>
 )
 

include/vector.hpp

@@ -20,7 +20,7 @@ namespace simple_renderer {
 
 auto DefaultShader::InterpolateColor(
     const Color &color0, const Color &color1, const Color &color2,
-    const glm::vec3 &barycentric_coord) -> Color {
+    const Vector3f &barycentric_coord) -> Color {
   return Color(
       static_cast<uint8_t>(static_cast<float>(color0[Color::kColorIndexRed]) *
                                barycentric_coord.x +
@@ -56,7 +56,8 @@ auto DefaultShader::Vertex(const ShaderVertexIn &shader_vertex_in) const
 
 auto DefaultShader::Fragment(const ShaderFragmentIn &shader_fragment_in) const
     -> ShaderFragmentOut {
-  auto intensity = glm::dot(shader_fragment_in.normal_,shader_fragment_in.light_);
+  auto intensity =
+      glm::dot(shader_fragment_in.normal_, shader_fragment_in.light_);
   auto is_need_draw = true;
   // 光照方向为正，不绘制背面
   if (intensity <= 0) {

src/CMakeLists.txt

@@ -64,7 +64,7 @@ class DefaultShader : public ShaderBase {
    */
   static auto InterpolateColor(const Color &color0, const Color &color1,
                                const Color &color2,
-                               const glm::vec3 &barycentric_coord) -> Color;
+                               const Vector3f &barycentric_coord) -> Color;
 };
 
 }  // namespace simple_renderer

src/default_shader.cpp

@@ -33,9 +33,9 @@ class Light {
   /// 光照名称
   std::string name_ = "default light name";
   /// 位置
-  glm::vec3 pos = kDefaultPos;
+  Vector3f pos = kDefaultPos;
   /// 方向
-  glm::vec3 dir = kDefaultDir;
+  Vector3f dir = kDefaultDir;
   /// 颜色
   Color color = kDefaultColor;
 
@@ -57,9 +57,9 @@ class Light {
 
  private:
   /// 默认位置
-  static const glm::vec3 kDefaultPos;
+  static const Vector3f kDefaultPos;
   /// 默认方向，左手系，x 向右，y 向下，z 正方向为屏幕由内向外
-  static const glm::vec3 kDefaultDir;
+  static const Vector3f kDefaultDir;
   /// 默认颜色
   static const Color kDefaultColor;
 };

include/color.h renamed to src/include/color.h

@@ -23,20 +23,22 @@
 #include "log_system.h"
 
 namespace simple_renderer {
-
-
+using Matrix4f = glm::mat4;
 }  // namespace simple_renderer
 
 /**
  * spdlog 输出矩阵实现
  */
 template <>
-struct fmt::formatter<glm::mat4> : fmt::formatter<std::string> {
-  auto format(const glm::mat4 &matrix, fmt::format_context &ctx) const -> decltype(ctx.out()) {
-    // Convert the glm::mat4 to a string using glm::to_string
+struct fmt::formatter<simple_renderer::Matrix4f> : fmt::formatter<std::string> {
+  auto format(const simple_renderer::Matrix4f &matrix,
+              fmt::format_context &ctx) const -> decltype(ctx.out()) {
+    // Convert the Matrix4f to a string using glm::to_string
+    // 转化矩阵为字符串
     std::string matrix_str = glm::to_string(matrix);
-    
+
     // Format and output the string
+    // 输出格式化后的字符串
     return fmt::format_to(ctx.out(), "\n{}", matrix_str);
   }
 };

include/default_shader.h renamed to src/include/default_shader.h

@@ -36,9 +36,9 @@ namespace simple_renderer {
 class Model {
  public:
   /// 顶点坐标
-  using Coord = glm::vec3;
+  using Coord = Vector3f;
   /// 法向量
-  using Normal = glm::vec3;
+  using Normal = Vector3f;
   /// 贴图
   using TextureCoord = glm::vec2;
 
@@ -47,11 +47,11 @@ class Model {
     /// 反光度
     float shininess = 0;
     /// 环境光照
-    glm::vec3 ambient;
+    Vector3f ambient;
     /// 漫反射光照
-    glm::vec3 diffuse;
+    Vector3f diffuse;
     /// 镜面光照
-    glm::vec3 specular;
+    Vector3f specular;
 
     /// @name 默认构造/析构函数
     /// @{
@@ -108,7 +108,7 @@ class Model {
      * @param tran 要对顶点进行的变换矩阵
      * @return 结果
      */
-    [[nodiscard]] auto operator*(const glm::mat4 &tran) const -> Vertex;
+    [[nodiscard]] auto operator*(const Matrix4f &tran) const -> Vertex;
   };
 
   /// @todo 直接保存太浪费内存了
@@ -148,7 +148,7 @@ class Model {
      * @param tran 要对面进行的变换矩阵
      * @return 结果
      */
-    [[nodiscard]] auto operator*(const glm::mat4 &tran) const -> Face;
+    [[nodiscard]] auto operator*(const Matrix4f &tran) const -> Face;
   };
 
   /// obj 文件路径
@@ -179,7 +179,7 @@ class Model {
    * @param tran 要对模型进行的变换矩阵
    * @return 结果
    */
-  [[nodiscard]] auto operator*(const glm::mat4 &tran) const -> Model;
+  [[nodiscard]] auto operator*(const Matrix4f &tran) const -> Model;
 
   /**
    * 获取面

include/light.h renamed to src/include/light.h

@@ -83,11 +83,11 @@ class ShaderVertexOut {
 class ShaderFragmentIn {
  public:
   /// 重心坐标
-  glm::vec3 barycentric_coord_;
+  Vector3f barycentric_coord_;
   /// 法线方向
-  glm::vec3 normal_;
+  Vector3f normal_;
   /// 光照方向
-  glm::vec3 light_;
+  Vector3f light_;
 
   /// @name 三个顶点的颜色
   /// @{
@@ -105,8 +105,8 @@ class ShaderFragmentIn {
    * @param color1 顶点 1 颜色
    * @param color2 顶点 2 颜色
    */
-  explicit ShaderFragmentIn(const glm::vec3 &_barycentric_coord,
-                            const glm::vec3 &_normal, const glm::vec3 &_light,
+  explicit ShaderFragmentIn(const Vector3f &_barycentric_coord,
+                            const Vector3f &_normal, const Vector3f &_light,
                             const Color &_color0, const Color &_color1,
                             const Color &_color2);
 
@@ -160,20 +160,20 @@ class ShaderFragmentOut {
 class ShaderData {
  public:
   /// 模型变换矩阵
-  glm::mat4 model_matrix_ = glm::mat4(1.0f);
+  Matrix4f model_matrix_ = Matrix4f(1.0f);
   /// 视图变换矩阵
-  glm::mat4 view_matrix_ = glm::mat4(1.0f);
+  Matrix4f view_matrix_ = Matrix4f(1.0f);
   /// 正交变换矩阵
-  glm::mat4 project_matrix_ = glm::mat4(1.0f);
+  Matrix4f project_matrix_ = Matrix4f(1.0f);
 
   /**
    * 构造函数
    * @param model_matrix 模型变换矩阵
    * @param view_matrix 视图变换矩阵
    * @param project_matrix 正交变换矩阵
    */
-  explicit ShaderData(const glm::mat4 &model_matrix, const glm::mat4 &view_matrix,
-                      const glm::mat4 &project_matrix);
+  explicit ShaderData(const Matrix4f &model_matrix, const Matrix4f &view_matrix,
+                      const Matrix4f &project_matrix);
 
   /// @name 默认构造/析构函数
   /// @{

include/log_system.h renamed to src/include/log_system.h

@@ -128,9 +128,9 @@ class SimpleRenderer {
    *     weight_B = s
    *     weight_C = t
    */
-  static auto GetBarycentricCoord(const glm::vec3 &p0, const glm::vec3 &p1,
-                                  const glm::vec3 &p2, const glm::vec3 &pa)
-      -> std::pair<bool, glm::vec3>;
+  static auto GetBarycentricCoord(const Vector3f &p0, const Vector3f &p1,
+                                  const Vector3f &p2, const Vector3f &pa)
+      -> std::pair<bool, Vector3f>;
 
   /**
    * 深度插值，由重心坐标计算出对应点的深度值
@@ -141,7 +141,7 @@ class SimpleRenderer {
    * @return 深度值
    */
   static auto InterpolateDepth(float depth0, float depth1, float depth2,
-                               const glm::vec3 &barycentric_coord) -> float;
+                               const Vector3f &barycentric_coord) -> float;
 };
 
 }  // namespace simple_renderer

include/matrix.hpp renamed to src/include/matrix.hpp

@@ -0,0 +1,61 @@
+
+/**
+ * @file vector.hpp
+ * @brief 向量模版
+ * @author Zone.N (Zone.Niuzh@hotmail.com)
+ * @version 1.0
+ * @date 2022-06-07
+ * @copyright MIT LICENSE
+ * https://github.com/Simple-XX/SimpleRenderer
+ * @par change log:
+ * <table>
+ * <tr><th>Date<th>Author<th>Description
+ * <tr><td>2022-06-07<td>Zone.N<td>迁移到 doxygen
+ * </table>
+ */
+
+#ifndef SIMPLERENDER_SRC_INCLUDE_VECTOR_HPP_
+#define SIMPLERENDER_SRC_INCLUDE_VECTOR_HPP_
+
+#include <glm/glm.hpp>
+
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/string_cast.hpp>
+
+#include "log_system.h"
+
+namespace simple_renderer {
+using Vector2f = glm::vec2;
+using Vector3f = glm::vec3;
+using Vector4f = glm::vec4;
+}  // namespace simple_renderer
+
+/**
+ * spdlog 输出 Vector3f 实现
+ */
+template <>
+struct fmt::formatter<simple_renderer::Vector3f> : fmt::formatter<std::string> {
+  auto format(const simple_renderer::Vector3f &vector,
+              fmt::format_context &ctx) const -> decltype(ctx.out()) {
+    std::string vector_string = glm::to_string(vector);
+
+    // Format and output the string
+    return fmt::format_to(ctx.out(), "\n{}", vector_string);
+  }
+};
+
+/**
+ * spdlog 输出 Vector4f 实现
+ */
+template <>
+struct fmt::formatter<simple_renderer::Vector4f> : fmt::formatter<std::string> {
+  auto format(const simple_renderer::Vector4f &vector,
+              fmt::format_context &ctx) const -> decltype(ctx.out()) {
+    std::string vector_string = glm::to_string(vector);
+
+    // Format and output the string
+    return fmt::format_to(ctx.out(), "\n{}", vector_string);
+  }
+};
+
+#endif /* SIMPLERENDER_SRC_INCLUDE_VECTOR_HPP_ */

include/model.hpp renamed to src/include/model.hpp

@@ -22,8 +22,8 @@
 
 namespace simple_renderer {
 
-const glm::vec3 Light::kDefaultPos = glm::vec3(0, 0, 0);
-const glm::vec3 Light::kDefaultDir = glm::vec3(0, 0, -1);
+const Vector3f Light::kDefaultPos = Vector3f(0, 0, 0);
+const Vector3f Light::kDefaultDir = Vector3f(0, 0, -1);
 const Color Light::kDefaultColor = Color::kWhite;
 
 Light::Light(const std::string &name) : name_(name) {

include/shader_base.h renamed to src/include/shader_base.h

@@ -16,20 +16,20 @@
 
 #include "log_system.h"
 
-#include <iostream>
-
 #include <spdlog/async.h>
 #include <spdlog/sinks/basic_file_sink.h>
 #include <spdlog/sinks/rotating_file_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
+#include <iostream>
+
 namespace simple_renderer {
 
 LogSystem::LogSystem(const std::string &log_file_path, size_t lig_file_max_size,
                      size_t log_file_max_count) {
   spdlog::init_thread_pool(65536, 1);
-//   std::string log_file_paths = "./logs/simple_renderer.log";
+  //   std::string log_file_paths = "./logs/simple_renderer.log";
   auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
   auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
       log_file_path, lig_file_max_size, log_file_max_count);

include/simple_renderer.h renamed to src/include/simple_renderer.h

@@ -15,8 +15,8 @@
  */
 
 #include "model.hpp"
-#include <glm/gtc/matrix_transform.hpp>
 
+#include <glm/gtc/matrix_transform.hpp>
 #include <utility>
 
 #define TINYOBJLOADER_IMPLEMENTATION
@@ -33,30 +33,34 @@ Model::Vertex::Vertex(Coord coord, Normal normal, TextureCoord texture_coord,
       texture_coord_(std::move(texture_coord)),
       color_(color) {}
 
-auto Model::Vertex::operator*(const glm::mat4 &tran) const -> Model::Vertex {
-    Vertex vertex(*this);
+auto Model::Vertex::operator*(const Matrix4f &tran) const -> Model::Vertex {
+  Vertex vertex(*this);
 
-    // Convert the 3D coordinate to a 4D vector by adding a 1.0 w-component
-    glm::vec4 res4(coord_, 1.0f);
+  // Convert the 3D coordinate to a 4D vector by adding a 1.0 w-component
+  // 将 3D 坐标转换为 4D 向量，通过添加 1.0 w-分量
+  Vector4f res4(coord_, 1.0f);
 
-    // Apply the transformation matrix
-    glm::vec4 ret4 = tran * res4;
+  // Apply the transformation matrix
+  // 应用变换矩阵
+  Vector4f ret4 = tran * res4;
 
-    // Update the vertex coordinates with the transformed values
-    vertex.coord_ = glm::vec3(ret4);
+  // Update the vertex coordinates with the transformed values
+  // 使用变换后的值更新顶点坐标
+  vertex.coord_ = Vector3f(ret4);
 
-    /// @todo 变换法线
+  /// @todo 变换法线
 
-    return vertex;
+  return vertex;
 }
 
 Model::Face::Face(const Model::Vertex &v0, const Model::Vertex &v1,
                   const Model::Vertex &v2, Material material)
     : v0_(v0), v1_(v1), v2_(v2), material_(std::move(material)) {
   // 计算法向量
   // 如果 obj 内包含法向量，直接使用即可
-  if (glm::normalize(v0.normal_) != glm::vec3(0.0f) && glm::normalize(v1.normal_) != glm::vec3(0.0f) &&
-      glm::normalize(v2.normal_) != glm::vec3(0.0f)) {
+  if (glm::normalize(v0.normal_) != Vector3f(0.0f) &&
+      glm::normalize(v1.normal_) != Vector3f(0.0f) &&
+      glm::normalize(v2.normal_) != Vector3f(0.0f)) {
     normal_ = glm::normalize((v0.normal_ + v1.normal_ + v2.normal_));
   }
   // 手动计算
@@ -68,18 +72,18 @@ Model::Face::Face(const Model::Vertex &v0, const Model::Vertex &v1,
   }
 }
 
-auto Model::Face::operator*(const glm::mat4 &tran) const -> Model::Face {
-    auto face(*this);
-    face.v0_ = face.v0_ * tran;
-    face.v1_ = face.v1_ * tran;
-    face.v2_ = face.v2_ * tran;
+auto Model::Face::operator*(const Matrix4f &tran) const -> Model::Face {
+  auto face(*this);
+  face.v0_ = face.v0_ * tran;
+  face.v1_ = face.v1_ * tran;
+  face.v2_ = face.v2_ * tran;
 
-    // Calculate the transformed normal
-    glm::vec3 v2v0 = face.v2_.coord_ - face.v0_.coord_;
-    glm::vec3 v1v0 = face.v1_.coord_ - face.v0_.coord_;
-    face.normal_ = glm::normalize(glm::cross(v2v0, v1v0));
+  // Calculate the transformed normal
+  Vector3f v2v0 = face.v2_.coord_ - face.v0_.coord_;
+  Vector3f v1v0 = face.v1_.coord_ - face.v0_.coord_;
+  face.normal_ = glm::normalize(glm::cross(v2v0, v1v0));
 
-    return face;
+  return face;
 }
 
 Model::Model(const std::string &obj_path, const std::string &mtl_path)
@@ -146,7 +150,7 @@ Model::Model(const std::string &obj_path, const std::string &mtl_path)
 
         // 如果法线索引存在(即 idx.normal_index >= 0)，
         // 则构造并保存，否则设置为 0
-        Normal normal = glm::vec3(0.0f);
+        Normal normal = Vector3f(0.0f);
         if (idx.normal_index >= 0) {
           normal = Normal(attrib.normals[3 * size_t(idx.normal_index) + 0],
                           attrib.normals[3 * size_t(idx.normal_index) + 1],
@@ -155,7 +159,7 @@ Model::Model(const std::string &obj_path, const std::string &mtl_path)
 
         // 如果贴图索引存在(即 idx.texcoord_index >= 0)，
         // 则构造并保存，否则设置为 0
-        TextureCoord texture_coord = glm::vec3(0.0f);
+        TextureCoord texture_coord = Vector3f(0.0f);
         if (idx.texcoord_index >= 0) {
           texture_coord = TextureCoord(
               attrib.texcoords[2 * size_t(idx.texcoord_index) + 0],
@@ -175,13 +179,13 @@ Model::Model(const std::string &obj_path, const std::string &mtl_path)
       auto material = Material();
       if (!materials.empty()) {
         material.shininess = materials[shape_index].shininess;
-        material.ambient = glm::vec3(materials[shape_index].ambient[0],
+        material.ambient = Vector3f(materials[shape_index].ambient[0],
                                     materials[shape_index].ambient[1],
                                     materials[shape_index].ambient[2]);
-        material.diffuse = glm::vec3(materials[shape_index].diffuse[0],
+        material.diffuse = Vector3f(materials[shape_index].diffuse[0],
                                     materials[shape_index].diffuse[1],
                                     materials[shape_index].diffuse[2]);
-        material.specular = glm::vec3(materials[shape_index].specular[0],
+        material.specular = Vector3f(materials[shape_index].specular[0],
                                      materials[shape_index].specular[1],
                                      materials[shape_index].specular[2]);
       }
@@ -193,7 +197,7 @@ Model::Model(const std::string &obj_path, const std::string &mtl_path)
   Normalize();
 }
 
-auto Model::operator*(const glm::mat4 &tran) const -> Model {
+auto Model::operator*(const Matrix4f &tran) const -> Model {
   auto model = Model(*this);
 
   for (auto &i : model.faces_) {
@@ -216,23 +220,23 @@ std::pair<Model::Coord, Model::Coord> Model::GetMaxMinXYX() {
                    std::numeric_limits<float>::max());
 
   for (const auto &i : faces_) {
-    auto curr_max_x = std::max(i.v0_.coord_.x,
-                               std::max(i.v1_.coord_.x, i.v2_.coord_.x));
-    auto curr_max_y = std::max(i.v0_.coord_.y,
-                               std::max(i.v1_.coord_.y, i.v2_.coord_.y));
-    auto curr_max_z = std::max(i.v0_.coord_.z,
-                               std::max(i.v1_.coord_.z, i.v2_.coord_.z));
+    auto curr_max_x =
+        std::max(i.v0_.coord_.x, std::max(i.v1_.coord_.x, i.v2_.coord_.x));
+    auto curr_max_y =
+        std::max(i.v0_.coord_.y, std::max(i.v1_.coord_.y, i.v2_.coord_.y));
+    auto curr_max_z =
+        std::max(i.v0_.coord_.z, std::max(i.v1_.coord_.z, i.v2_.coord_.z));
 
     max.x = curr_max_x > max.x ? curr_max_x : max.x;
     max.y = curr_max_y > max.y ? curr_max_y : max.y;
     max.z = curr_max_z > max.z ? curr_max_z : max.z;
 
-    auto curr_min_x = std::min(i.v0_.coord_.x,
-                               std::min(i.v1_.coord_.x, i.v2_.coord_.x));
-    auto curr_min_y = std::min(i.v0_.coord_.y,
-                               std::min(i.v1_.coord_.y, i.v2_.coord_.y));
-    auto curr_min_z = std::min(i.v0_.coord_.z,
-                               std::min(i.v1_.coord_.z, i.v2_.coord_.z));
+    auto curr_min_x =
+        std::min(i.v0_.coord_.x, std::min(i.v1_.coord_.x, i.v2_.coord_.x));
+    auto curr_min_y =
+        std::min(i.v0_.coord_.y, std::min(i.v1_.coord_.y, i.v2_.coord_.y));
+    auto curr_min_z =
+        std::min(i.v0_.coord_.z, std::min(i.v1_.coord_.z, i.v2_.coord_.z));
 
     min.x = curr_min_x < min.x ? curr_min_x : min.x;
     min.y = curr_min_y < min.y ? curr_min_y : min.y;
@@ -244,31 +248,34 @@ std::pair<Model::Coord, Model::Coord> Model::GetMaxMinXYX() {
 void Model::Normalize() {
   auto [max, min] = GetMaxMinXYX();
 
-    // Compute the dimensions of the bounding box
-    auto x = std::abs(max.x) + std::abs(min.x);
-    auto y = std::abs(max.y) + std::abs(min.y);
-    auto z = std::abs(max.z) + std::abs(min.z);
+  // Compute the dimensions of the bounding box
+  auto x = std::abs(max.x) + std::abs(min.x);
+  auto y = std::abs(max.y) + std::abs(min.y);
+  auto z = std::abs(max.z) + std::abs(min.z);
 
-    // Calculate the scaling factor
-    auto scale = 1.0f / std::max(x, std::max(y, z));
+  // Calculate the scaling factor
+  auto scale = 1.0f / std::max(x, std::max(y, z));
 
-    // Create the scaling matrix
-    glm::mat4 scale_matrix = glm::scale(glm::mat4(1.0f), glm::vec3(scale, scale, scale));
+  // Create the scaling matrix
+  Matrix4f scale_matrix =
+      glm::scale(Matrix4f(1.0f), Vector3f(scale, scale, scale));
 
-    // Calculate the center of the bounding box
-    glm::vec3 center = glm::vec3((max.x + min.x) / 2.0f, (max.y + min.y) / 2.0f, (max.z + min.z) / 2.0f);
+  // Calculate the center of the bounding box
+  Vector3f center = Vector3f((max.x + min.x) / 2.0f, (max.y + min.y) / 2.0f,
+                             (max.z + min.z) / 2.0f);
 
-    // Create the translation matrix
-    glm::mat4 translation_matrix = glm::translate(glm::mat4(1.0f), -center);
+  // Create the translation matrix
+  Matrix4f translation_matrix = glm::translate(Matrix4f(1.0f), -center);
 
-    // Combine the scaling and translation matrices
-    glm::mat4 normalization_matrix = scale_matrix * translation_matrix;
+  // Combine the scaling and translation matrices
+  Matrix4f normalization_matrix = scale_matrix * translation_matrix;
 
-    // Debug output
-    SPDLOG_DEBUG("normalization_matrix: \n{}", glm::to_string(normalization_matrix));
+  // Debug output
+  SPDLOG_DEBUG("normalization_matrix: \n{}",
+               glm::to_string(normalization_matrix));
 
-    // Apply the normalization matrix to the model
-    *this = *this * normalization_matrix;
+  // Apply the normalization matrix to the model
+  *this = *this * normalization_matrix;
 }
 
 }  // namespace simple_renderer

src/include/vector.hpp

@@ -22,9 +22,9 @@ ShaderVertexIn::ShaderVertexIn(const Model::Face &face) : face_(face) {}
 
 ShaderVertexOut::ShaderVertexOut(const Model::Face &face) : face_(face) {}
 
-ShaderFragmentIn::ShaderFragmentIn(const glm::vec3 &barycentric_coord,
-                                   const glm::vec3 &normal,
-                                   const glm::vec3 &light, const Color &color0,
+ShaderFragmentIn::ShaderFragmentIn(const Vector3f &barycentric_coord,
+                                   const Vector3f &normal,
+                                   const Vector3f &light, const Color &color0,
                                    const Color &color1, const Color &color2)
     : barycentric_coord_(barycentric_coord),
       normal_(normal),
@@ -37,9 +37,9 @@ ShaderFragmentOut::ShaderFragmentOut(const bool &is_need_draw,
                                      const Color &color)
     : is_need_draw_(is_need_draw), color_(color) {}
 
-ShaderData::ShaderData(const glm::mat4 &model_matrix,
-                       const glm::mat4 &view_matrix,
-                       const glm::mat4 &project_matrix)
+ShaderData::ShaderData(const Matrix4f &model_matrix,
+                       const Matrix4f &view_matrix,
+                       const Matrix4f &project_matrix)
     : model_matrix_(model_matrix),
       view_matrix_(view_matrix),
       project_matrix_(project_matrix) {}

src/light.cpp

@@ -160,7 +160,7 @@ void SimpleRenderer::DrawTriangle(const ShaderBase &shader, const Light &light,
       }
       auto [is_inside, barycentric_coord] = GetBarycentricCoord(
           v0.coord_, v1.coord_, v2.coord_,
-          glm::vec3(static_cast<float>(x), static_cast<float>(y), 0));
+          Vector3f(static_cast<float>(x), static_cast<float>(y), 0));
       // 如果点在三角形内再进行下一步
       if (!is_inside) {
         continue;
@@ -222,37 +222,37 @@ void SimpleRenderer::DrawModel(const ShaderBase &shader, const Light &light,
 }
 
 /// @todo 巨大性能开销
-auto SimpleRenderer::GetBarycentricCoord(const glm::vec3 &p0, const glm::vec3 &p1,
-                                         const glm::vec3 &p2, const glm::vec3 &pa)
-    -> std::pair<bool, glm::vec3> {
+auto SimpleRenderer::GetBarycentricCoord(const Vector3f &p0, const Vector3f &p1,
+                                         const Vector3f &p2, const Vector3f &pa)
+    -> std::pair<bool, Vector3f> {
   auto p1p0 = p1 - p0;
   auto p2p0 = p2 - p0;
   auto pap0 = pa - p0;
 
   auto deno = (p1p0.x * p2p0.y - p1p0.y * p2p0.x);
   if (std::abs(deno) < std::numeric_limits<decltype(deno)>::epsilon()) {
-    return std::pair<bool, const glm::vec3>{false, glm::vec3()};
+    return std::pair<bool, const Vector3f>{false, Vector3f()};
   }
 
   auto s = (p2p0.y * pap0.x - p2p0.x * pap0.y) / deno;
   if ((s > 1) || (s < 0)) {
-    return std::pair<bool, const glm::vec3>{false, glm::vec3()};
+    return std::pair<bool, const Vector3f>{false, Vector3f()};
   }
 
   auto t = (p1p0.x * pap0.y - p1p0.y * pap0.x) / deno;
   if ((t > 1) || (t < 0)) {
-    return std::pair<bool, const glm::vec3>{false, glm::vec3()};
+    return std::pair<bool, const Vector3f>{false, Vector3f()};
   }
 
   if ((1 - s - t > 1) || (1 - s - t < 0)) {
-    return std::pair<bool, const glm::vec3>{false, glm::vec3()};
+    return std::pair<bool, const Vector3f>{false, Vector3f()};
   }
 
-  return std::pair<bool, const glm::vec3>{true, glm::vec3(1 - s - t, s, t)};
+  return std::pair<bool, const Vector3f>{true, Vector3f(1 - s - t, s, t)};
 }
 
 auto SimpleRenderer::InterpolateDepth(float depth0, float depth1, float depth2,
-                                      const glm::vec3 &_barycentric_coord)
+                                      const Vector3f &_barycentric_coord)
     -> float {
   auto depth = depth0 * _barycentric_coord.x;
   depth += depth1 * _barycentric_coord.y;

src/log_system.cpp

@@ -14,7 +14,7 @@ enable_testing()
 include(GoogleTest)
 
 include_directories(
-    ${SimpleRenderer_SOURCE_DIR}/include
+    ${SimpleRenderer_SOURCE_DIR}/src/include
 )
 
 list(APPEND DEFAULT_TEST_COMPILE_OPTIONS
@@ -38,26 +38,14 @@ link_libraries(
     SimpleRenderer
 )
 
-# Check if the platform is macOS
-if(APPLE)
-    # Enable RPATH support on macOS
-    set(CMAKE_MACOSX_RPATH 1)
 
-    # Set the RPATH to look for frameworks relative to the executable path
-    set(CMAKE_INSTALL_RPATH "/Library/Frameworks")
-
-    # Ensure that RPATH is used in the build
-    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-endif()
-
-
-# add_subdirectory(unit_test)
+add_subdirectory(unit_test)
 #add_subdirectory(integration_test)
 add_subdirectory(system_test)
 
-# add_coverage_target(
-#         DEPENDS unit_test
-#         SOURCE_DIR ${SimpleRenderer_SOURCE_DIR}
-#         BINARY_DIR ${SimpleRenderer_BINARY_DIR}
-#         EXCLUDE_DIR ${SimpleRenderer_SOURCE_DIR}/3rd/*
-# )
+add_coverage_target(
+        DEPENDS unit_test
+        SOURCE_DIR ${SimpleRenderer_SOURCE_DIR}
+        BINARY_DIR ${SimpleRenderer_BINARY_DIR}
+        EXCLUDE_DIR ${SimpleRenderer_SOURCE_DIR}/3rd/*
+)

src/model.cpp

@@ -33,9 +33,9 @@ class Camera {
   /// 光照名称
   std::string name_ = "default light name";
   /// 位置
-  glm::vec3 pos_;
+  Vector3f pos_;
   /// 方向
-  glm::vec3 dir_;
+  Vector3f dir_;
 
   /**
    * 构造函数

src/shader_base.cpp

@@ -59,16 +59,18 @@ int main(int argc, char **argv) {
   // objs.emplace_back(obj_path + "/african_head.obj");
   objs.emplace_back(obj_path + "/utah-teapot/utah-teapot.obj");
 
-
-  auto matrix =
-      glm::mat4(1.0f);
-  glm::mat4 scale_matrix = glm::scale(glm::mat4(1.0f), glm::vec3(500.0f, 500.0f, 500.0f));
-
-// Translation matrix
-    glm::mat4 translation_matrix = glm::translate(glm::mat4(1.0f), glm::vec3(kWidth / 2.0f, kHeight / 2.0f, 0.0f));
-
-    // Combined transformation matrix
-    matrix = translation_matrix * scale_matrix;
+  auto matrix = simple_renderer::Matrix4f(1.0f);
+  simple_renderer::Matrix4f scale_matrix =
+      glm::scale(simple_renderer::Matrix4f(1.0f),
+                 simple_renderer::Vector3f(500.0f, 500.0f, 500.0f));
+
+  // Translation matrix
+  simple_renderer::Matrix4f translation_matrix = glm::translate(
+      simple_renderer::Matrix4f(1.0f),
+      simple_renderer::Vector3f(kWidth / 2.0f, kHeight / 2.0f, 0.0f));
+
+  // Combined transformation matrix
+  matrix = translation_matrix * scale_matrix;
 
   // 矩阵运算的顺序
   // 归一化