feat: improved construction times

fastmath.hpp

@@ -6,7 +6,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <vector>
-#include <iostream>
 #define SHIFT_AMOUNT 16
 #define HALF_SHIFT (SHIFT_AMOUNT / 2)
 
@@ -21,13 +20,13 @@
 struct decimal {
 
     int32_t i;
+    constexpr decimal() = default;
+    // constexpr decimal() : i(0) {}
+    constexpr decimal(float i) : i(TO_INT(i)) {}
+    constexpr decimal(double i) : i(TO_INT(i)) {}
+    constexpr decimal(int32_t i) : i(i) {}
 
-    decimal() : i(0) {}
+    friend std::ostream &operator<<(std::ostream &os, const decimal &d) {
-    decimal(float i) : i(TO_INT(i)) {}
-    decimal(double i) : i(TO_INT(i)) {}
-    decimal(int32_t i) : i(i) {}
-
-    friend std::ostream& operator<<(std::ostream& os, const decimal &d) {
         return (os << TO_FLOAT(d.i));
     }
 
@@ -87,19 +86,14 @@ struct decimal {
 
 template <int n, class Dev> struct vec {
 
-    vec(decimal newV[n]) {
+    decimal v[n];
-        for (int i = 0; i < n; i++) {
-            v[i] = newV[i];
-        }
-    }
 
-    vec(std::vector<decimal> newV) {
+    constexpr vec() noexcept = default;
-        for (int i = 0; i < n; i++) {
-            v[i] = newV[i];
-        }
-    }
 
-    vec() : v{} {}
+    template <class... Args>
+    constexpr vec(Args... args) noexcept : v{static_cast<decimal>(args)...} {
+        static_assert(sizeof...(Args) == n, "Wrong number of elements for vec");
+    }
 
     friend Dev operator+(const vec<n, Dev> &v1, const vec<n, Dev> &v2) {
         Dev newV = {};
@@ -172,7 +166,7 @@ template <int n, class Dev> struct vec {
     }
 
     decimal operator*(const vec<n, Dev> &vec) {
-        decimal res;
+        decimal res = {0};
         for (int i = 0; i < n; i++) {
             res += vec.v[i] * v[i];
         }
@@ -203,21 +197,16 @@ template <int n, class Dev> struct vec {
         decimal f = decimal(1.0) / this->len();
         return (*this * f);
     }
-
-  protected:
-    decimal v[n];
 };
 struct vec2 : public vec<2, vec2> {
 
-    vec2() : vec<2, vec2>() {}
+    vec2(float x, float y) : vec<2, vec2>(decimal(x), decimal(y)) {}
 
-    vec2(float x, float y) : vec<2, vec2>({decimal(x), decimal(y)}) {}
+    vec2(double x, double y) : vec<2, vec2>(decimal(x), decimal(y)) {}
 
-    vec2(double x, double y) : vec<2, vec2>({decimal(x), decimal(y)}) {}
+    vec2(int32_t x, int32_t y) : vec<2, vec2>(decimal(x), decimal(y)) {}
 
-    vec2(int32_t x, int32_t y) : vec<2, vec2>({decimal(x), decimal(y)}) {}
+    vec2(decimal x, decimal y) : vec<2, vec2>(x, y) {}
-
-    vec2(decimal x, decimal y) : vec<2, vec2>({x, y}) {}
 
     decimal &x() { return v[0]; }
     decimal &y() { return v[1]; }
@@ -227,15 +216,15 @@ struct vec3 : public vec<3, vec3> {
     vec3() : vec<3, vec3>() {}
 
     vec3(float x, float y, float z)
-        : vec<3, vec3>({decimal(x), decimal(y), decimal(z)}) {}
+        : vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
 
     vec3(double x, double y, double z)
-        : vec<3, vec3>({decimal(x), decimal(y), decimal(z)}) {}
+        : vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
 
     vec3(int32_t x, int32_t y, int32_t z)
-        : vec<3, vec3>({decimal(x), decimal(y), decimal(z)}) {}
+        : vec<3, vec3>(decimal(x), decimal(y), decimal(z)) {}
 
-    vec3(decimal x, decimal y, decimal z) : vec<3, vec3>({x, y, z}) {}
+    vec3(decimal x, decimal y, decimal z) : vec<3, vec3>(x, y, z) {}
 
     decimal &x() { return v[0]; }
     decimal &y() { return v[1]; }
@@ -249,18 +238,16 @@ struct vec3 : public vec<3, vec3> {
 };
 struct vec4 : public vec<4, vec4> {
 
-    vec4() : vec<4, vec4>() {}
-
     vec4(float x, float y, float z, float w)
-        : vec<4, vec4>({decimal(x), decimal(y), decimal(z), decimal(w)}) {}
+        : vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
 
     vec4(double x, double y, double z, double w)
-        : vec<4, vec4>({decimal(x), decimal(y), decimal(z), decimal(w)}) {}
+        : vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
 
     vec4(int32_t x, int32_t y, int32_t z, int32_t w)
-        : vec<4, vec4>({decimal(x), decimal(y), decimal(z), decimal(w)}) {}
+        : vec<4, vec4>(decimal(x), decimal(y), decimal(z), decimal(w)) {}
 
-    vec4(decimal x, decimal y, decimal z) : vec<4, vec4>({x, y, z}) {}
+    vec4(decimal x, decimal y, decimal z) : vec<4, vec4>(x, y, z, 0) {}
 
     decimal &x() { return v[0]; }
     decimal &y() { return v[1]; }

renderer.hpp

@@ -72,13 +72,13 @@ class Renderer {
 
             int startX = std::max<int>(
                 (testP.bounding[0] * invWidthScale).i >> SHIFT_AMOUNT, 0);
-            int endX =
+            int endX = std::min<int>((testP.bounding[1] * invWidthScale).i >>
-                std::min<int>((testP.bounding[1] * invWidthScale).i >> SHIFT_AMOUNT,(uint32_t)
+                                         SHIFT_AMOUNT,
-                         target->width - 1);
+                                     (uint32_t)target->width - 1);
             int startY = std::max<int>(
                 (testP.bounding[2] * invHeightScale).i >> SHIFT_AMOUNT, 0);
-            int endY =
+            int endY = std::min<int>((testP.bounding[3] * invHeightScale).i >>
-                std::min<int>((testP.bounding[3] * invHeightScale).i >> SHIFT_AMOUNT,
+                                         SHIFT_AMOUNT,
                                      target->height - 1);
 
             vec3 pos = vec3(testP.bounding[0], testP.bounding[2], 0.0);
@@ -96,13 +96,15 @@ class Renderer {
                             decimal lightFac =
                                 std::max(normal * (-sunDir), decimal(0.0)) +
                                 decimal(0.5);
-                            // decimal reflection = target->setDepth(x, y,
+                            ;
-                            // depth);
+                            target->setDepth(x, y, depth);
                             target->set(x, y,
                                         (color * decimal(120.0)) * lightFac);
 
                             // target->set(x, y,
-                            //             (normals + vec3(1.0, 1.0, 1.0)) *
+                            // vec3(lightFac * decimal(200.0), 0, 0));
+                            // target->set(x, y,
+                            //             (normal + vec3(1.0, 1.0, 1.0)) *
                             //                 decimal(120.0));
                             // target->set(x, y, factors * decimal(200.0));
                             // if (!factors.isSmall())