Refactor du code

- Conversion de méthodes en `const`, simplification du destructeur, et utilisation de `constexpr` pour les dimensions de l'image.
- Les types de certaines variables ont été modifiés pour améliorer la précision, et la fonction `FastFloor` a été mise à jour pour utiliser `static_cast`.

Author: Dan Liebault

R3DVoxel/utils/perlin.cpp

@@ -9,45 +9,42 @@ PerlinNoise::PerlinNoise(unsigned int seed) : m_seed(seed)
     perm.insert(perm.end(), perm.begin(), perm.end());
 }
 
-PerlinNoise::~PerlinNoise()
-{
-}
-
-float PerlinNoise::perlin(float x, float y)
+float PerlinNoise::perlin(float x, float y) const
 {
     x *= 0.00999999978f;
     y *= 0.00999999978f;
 
     int x0 = FastFloor(x);
     int y0 = FastFloor(y);
 
-    float f_x0 = x - static_cast<float>(x0);
-    float f_y0 = y - static_cast<float>(y0);
-    float f_x1 = f_x0 - 1.0f;
-    float f_y1 = f_y0 - 1.0f;
+    const float f_x0 = x - static_cast<float>(x0);
+    const float f_y0 = y - static_cast<float>(y0);
+    const float f_x1 = f_x0 - 1.0f;
+    const float f_y1 = f_y0 - 1.0f;
 
-    float xs = fade(f_x0);
-    float ys = fade(f_y0);
+    const float xs = static_cast<float>(fade(f_x0));
+    const float ys = static_cast<float>(fade(f_y0));
 
     x0 *= 501125321;
     y0 *= 1136930381;
-    int x1 = x0 + 501125321;
-    int y1 = y0 + 1136930381;
+    const int x1 = x0 + 501125321;
+    const int y1 = y0 + 1136930381;
 
-    float n0 = lerp(xs, dotgridgradient(x0, y0, f_x0, f_y0), dotgridgradient(x1, y0, f_x1, f_y0));
-    float n1 = lerp(xs, dotgridgradient(x0, y1, f_x0, f_y1), dotgridgradient(x1, y1, f_x1, f_y1));
+    const double n0 = lerp(xs, dotgridgradient(x0, y0, f_x0, f_y0), dotgridgradient(x1, y0, f_x1, f_y0));
+	const double n1 = lerp(xs, dotgridgradient(x0, y1, f_x0, f_y1), dotgridgradient(x1, y1, f_x1, f_y1));
 
-    return lerp(ys, n0, n1) * 1.4247691104677813f;
+    const auto r = lerp(ys, static_cast<float>(n0), static_cast<float>(n1));
+    return static_cast<float>(r) * 1.4247691104677813f;
 }
 
-void PerlinNoise::exportppm()
+void PerlinNoise::exportppm() const
 {
     std::ofstream file;
     file.open("image.ppm");
 
     // Image
-    const int image_width = 500;
-    const int image_height = 500;
+    constexpr int image_width = 500;
+	constexpr int image_height = 500;
 
     // Render
     file << "P3\n" << image_width << ' ' << image_height << "\n255\n";
@@ -74,33 +71,33 @@ void PerlinNoise::exportppm()
     file.close();
 }
 
-float PerlinNoise::dotgridgradient(int ix, int iy, float x, float y)
+float PerlinNoise::dotgridgradient(int ix, int iy, float x, float y) const
 {
     int hash = m_seed ^ ix ^ iy;
     hash *= 0x27d4eb2d;
     hash ^= hash >> 15;
     hash &= 127 << 1;
 
-    float xg = Lookup<float>::Gradients2D[hash];
-    float yg = Lookup<float>::Gradients2D[hash | 1];
+    const float xg = Lookup<float>::Gradients2D[hash];
+    const float yg = Lookup<float>::Gradients2D[hash | 1];
 
     return x * xg + y * yg;
 }
 
-double PerlinNoise::gradiant(int hash, double x, double y)
+double PerlinNoise::gradiant(int hash, double x, double y) const
 {
     int h = hash & 7;
     double u = h < 4 ? x : y;
     double v = h < 4 ? y : x;
     return ((h & 1) ? -u : u) + ((h & 2) ? -2.0 * v : 2.0 * v);
 }
 
-double PerlinNoise::lerp(float t, float a, float b)
+double PerlinNoise::lerp(float t, float a, float b) const
 {
     return a + t * (b - a);
 }
 
-double PerlinNoise::fade(double t)
+double PerlinNoise::fade(double t) const
 {
     return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 }

R3DVoxel/utils/perlin.h

@@ -54,22 +54,22 @@ const T Lookup<T>::Gradients2D[] =
     -0.38268343236509f, -0.923879532511287f, -0.923879532511287f, -0.38268343236509f, -0.923879532511287f, 0.38268343236509f, -0.38268343236509f, 0.923879532511287f,
 };
 
-static int FastFloor(float f) { return f >= 0 ? (int)f : (int)f - 1; }
+static int FastFloor(float f) { return f >= 0 ? static_cast<int>(f) : static_cast<int>(f) - 1; }
 
 class PerlinNoise
 {
 public:
     PerlinNoise(unsigned int seed);
-    ~PerlinNoise();
+    ~PerlinNoise() = default;
 
-    float perlin(float x, float y);
-    void exportppm();
+    float perlin(float x, float y) const;
+    void exportppm() const;
 
 private:
-    float dotgridgradient(int ix, int iy, float x, float y);
-    double gradiant(int hash, double x, double y);
-    double lerp(float t, float a, float b);
-    double fade(double t);
+    float dotgridgradient(int ix, int iy, float x, float y) const;
+    double gradiant(int hash, double x, double y) const;
+    double lerp(float t, float a, float b) const;
+    double fade(double t) const;
 
     std::vector<int> perm;
     int m_seed;