Enhanced shader class with LUT caching for specular reflection to optimize computation and eliminate redundancy. Added copy/move constructors for thread safety

Signed-off-by: ZhouFANG <indevn@outlook.com>

Author: indevn

src/include/shader.hpp

@@ -1,6 +1,10 @@
 #ifndef SIMPLERENDER_SRC_INCLUDE_SHADER_HPP_
 #define SIMPLERENDER_SRC_INCLUDE_SHADER_HPP_
 
+#include <array>
+#include <bit>
+#include <shared_mutex>
+#include <unordered_map>
 #include <variant>
 
 #include "light.h"
@@ -12,6 +16,8 @@ namespace simple_renderer {
 using UniformValue = std::variant<int, float, Vector2f, Vector3f, Vector4f,
                                   Matrix3f, Matrix4f, Material, Light>;
 
+inline constexpr size_t kSpecularLutResolution = 256;
+
 class UniformBuffer {
  public:
   template <typename T>
@@ -85,17 +91,21 @@ struct FragmentUniformCache {
   bool derived_valid = false;
 };
 
+struct SpecularLUT {
+  std::array<float, kSpecularLutResolution> values{};
+};
+
 /**
  * @brief Shader Class 着色器类
  *
  */
 class Shader {
  public:
   Shader() = default;
-  Shader(const Shader &shader) = default;
-  Shader(Shader &&shader) = default;
-  auto operator=(const Shader &shader) -> Shader & = default;
-  auto operator=(Shader &&shader) -> Shader & = default;
+  Shader(const Shader &shader);
+  Shader(Shader &&shader) noexcept;
+  auto operator=(const Shader &shader) -> Shader &;
+  auto operator=(Shader &&shader) noexcept -> Shader &;
   virtual ~Shader() = default;
 
   // Input Data -> Vertex Shader -> Screen Space Coordiante
@@ -127,6 +137,8 @@ class Shader {
   SharedDataInShader sharedDataInShader_;
   VertexUniformCache vertex_uniform_cache_;
   FragmentUniformCache fragment_uniform_cache_;
+  mutable std::unordered_map<uint32_t, SpecularLUT> specular_lut_cache_;
+  mutable std::shared_mutex specular_cache_mutex_;
 
   void UpdateMatrixCache(const std::string &name, const Matrix4f &value);
   void UpdateFragmentCache(const std::string &name, const Light &value);
@@ -136,6 +148,11 @@ class Shader {
   void PrepareVertexUniformCache();
   void PrepareFragmentUniformCache();
 
+  // LUT相关
+  [[nodiscard]] auto BuildSpecularLUT(float shininess) const -> SpecularLUT;
+  [[nodiscard]] auto GetSpecularLUT(float shininess) const -> const SpecularLUT &;
+  [[nodiscard]] auto EvaluateSpecular(float cos_theta, float shininess) const -> float;
+
   Color SampleTexture(const Texture &texture, const Vector2f &uv) const;
   Color ClampColor(const Color color) const;
 };

src/shader.cpp

@@ -1,7 +1,56 @@
 #include "shader.hpp"
 
+#include <algorithm>
+#include <cmath>
+#include <mutex>
+#include <shared_mutex>
+
 namespace simple_renderer {
 
+Shader::Shader(const Shader& shader) {
+  std::shared_lock lock(shader.specular_cache_mutex_);
+  uniformbuffer_ = shader.uniformbuffer_;
+  sharedDataInShader_ = shader.sharedDataInShader_;
+  vertex_uniform_cache_ = shader.vertex_uniform_cache_;
+  fragment_uniform_cache_ = shader.fragment_uniform_cache_;
+  specular_lut_cache_ = shader.specular_lut_cache_;
+}
+
+Shader::Shader(Shader&& shader) noexcept {
+  std::unique_lock lock(shader.specular_cache_mutex_);
+  uniformbuffer_ = std::move(shader.uniformbuffer_);
+  sharedDataInShader_ = shader.sharedDataInShader_;
+  vertex_uniform_cache_ = shader.vertex_uniform_cache_;
+  fragment_uniform_cache_ = shader.fragment_uniform_cache_;
+  specular_lut_cache_ = std::move(shader.specular_lut_cache_);
+}
+
+auto Shader::operator=(const Shader& shader) -> Shader& {
+  if (this == &shader) {
+    return *this;
+  }
+  std::shared_lock lock(shader.specular_cache_mutex_);
+  uniformbuffer_ = shader.uniformbuffer_;
+  sharedDataInShader_ = shader.sharedDataInShader_;
+  vertex_uniform_cache_ = shader.vertex_uniform_cache_;
+  fragment_uniform_cache_ = shader.fragment_uniform_cache_;
+  specular_lut_cache_ = shader.specular_lut_cache_;
+  return *this;
+}
+
+auto Shader::operator=(Shader&& shader) noexcept -> Shader& {
+  if (this == &shader) {
+    return *this;
+  }
+  std::unique_lock lock(shader.specular_cache_mutex_);
+  uniformbuffer_ = std::move(shader.uniformbuffer_);
+  sharedDataInShader_ = shader.sharedDataInShader_;
+  vertex_uniform_cache_ = shader.vertex_uniform_cache_;
+  fragment_uniform_cache_ = shader.fragment_uniform_cache_;
+  specular_lut_cache_ = std::move(shader.specular_lut_cache_);
+  return *this;
+}
+
 Vertex Shader::VertexShader(const Vertex& vertex) {
   const bool cache_ready = vertex_uniform_cache_.derived_valid;
 
@@ -159,6 +208,56 @@ void Shader::PrepareFragmentUniformCache() {
   }
 }
 
+auto Shader::BuildSpecularLUT(float shininess) const -> SpecularLUT {
+  SpecularLUT lut;
+  if (shininess <= 0.0f) {
+    lut.values.fill(1.0f);
+    return lut;
+  }
+
+  for (size_t i = 0; i < kSpecularLutResolution; ++i) {
+    float cos_theta = static_cast<float>(i) /
+                      static_cast<float>(kSpecularLutResolution - 1);
+    lut.values[i] = cos_theta <= 0.0f ? 0.0f : std::pow(cos_theta, shininess);
+  }
+  return lut;
+}
+
+auto Shader::GetSpecularLUT(float shininess) const -> const SpecularLUT& {
+  uint32_t key = std::bit_cast<uint32_t>(shininess);
+  {
+    std::shared_lock lock(specular_cache_mutex_);
+    auto it = specular_lut_cache_.find(key);
+    if (it != specular_lut_cache_.end()) {
+      return it->second;
+    }
+  }
+
+  SpecularLUT lut = BuildSpecularLUT(shininess);
+  std::unique_lock lock(specular_cache_mutex_);
+  auto [it, inserted] = specular_lut_cache_.emplace(key, std::move(lut));
+  return it->second;
+}
+
+auto Shader::EvaluateSpecular(float cos_theta, float shininess) const -> float {
+  cos_theta = std::clamp(cos_theta, 0.0f, 1.0f);
+  if (shininess <= 0.0f) {
+    return 1.0f;
+  }
+  if (cos_theta <= 0.0f) {
+    return 0.0f;
+  }
+
+  const auto& lut = GetSpecularLUT(shininess);
+  float scaled = cos_theta * static_cast<float>(kSpecularLutResolution - 1);
+  size_t index = static_cast<size_t>(scaled);
+  float frac = scaled - static_cast<float>(index);
+
+  const float v0 = lut.values[index];
+  const float v1 = lut.values[std::min(index + 1, kSpecularLutResolution - 1)];
+  return v0 + (v1 - v0) * frac;
+}
+
 Color Shader::FragmentShader(const Fragment& fragment) const {
   // interpolate Normal, Color and UV
   Color interpolateColor = fragment.color;
@@ -202,8 +301,8 @@ Color Shader::FragmentShader(const Fragment& fragment) const {
   }
 
   Vector3f halfVector = glm::normalize(light_dir + view_dir);
-  float spec = std::pow(std::max(glm::dot(normal, halfVector), 0.0f),
-                        material.shininess);
+  float cos_theta = std::max(glm::dot(normal, halfVector), 0.0f);
+  float spec = EvaluateSpecular(cos_theta, material.shininess);
   if (material.has_specular_texture) {
     Color texture_color = SampleTexture(material.specular_texture, uv);
     specular_color = texture_color * spec;