Use simd for vec3 computations

4 files changed, 58 insertions, 49 deletions

diff --git a/include/aabb.hpp b/include/aabb.hpp
index cdbb79a..5f819db 100644
--- a/include/aabb.hpp
+++ b/include/aabb.hpp
@@ -16,41 +16,47 @@ class aabb {
             auto &v2 = tri.v2.position;

             auto &v3 = tri.v3.position;

 

-            minimum.x = fmin(fmin(v1.x, v2.x), v3.x);

-            minimum.y = fmin(fmin(v1.y, v2.y), v3.y);

-            minimum.z = fmin(fmin(v1.z, v2.z), v3.z);

+            // minimum.x = fmin(fmin(v1.x, v2.x), v3.x);

+            // minimum.y = fmin(fmin(v1.y, v2.y), v3.y);

+            // minimum.z = fmin(fmin(v1.z, v2.z), v3.z);

 

-            maximum.x = fmax(fmax(v1.x, v2.x), v3.x);

-            maximum.y = fmax(fmax(v1.y, v2.y), v3.y);

-            maximum.z = fmax(fmax(v1.z, v2.z), v3.z);

+            minimum.v[0] = fmin(fmin(v1.v[0], v2.v[0]), v3.v[0]);

+            minimum.v[1] = fmin(fmin(v1.v[1], v2.v[1]), v3.v[1]);

+            minimum.v[2] = fmin(fmin(v1.v[2], v2.v[2]), v3.v[2]);

+

+            // maximum.x = fmax(fmax(v1.x, v2.x), v3.x);

+            // maximum.y = fmax(fmax(v1.y, v2.y), v3.y);

+            // maximum.z = fmax(fmax(v1.z, v2.z), v3.z);

+

+            maximum.v[0] = fmax(fmax(v1.v[0], v2.v[0]), v3.v[0]);

+            maximum.v[1] = fmax(fmax(v1.v[1], v2.v[1]), v3.v[1]);

+            maximum.v[2] = fmax(fmax(v1.v[2], v2.v[2]), v3.v[2]);

         }

 

         void union_with(const aabb &box) {

-            minimum.x = minimum.x < box.minimum.x ? minimum.x : box.minimum.x;

-            minimum.y = minimum.y < box.minimum.y ? minimum.y : box.minimum.y;

-            minimum.z = minimum.z < box.minimum.z ? minimum.z : box.minimum.z;

-

-            maximum.x = maximum.x > box.maximum.x ? maximum.x : box.maximum.x;

-            maximum.y = maximum.y > box.maximum.y ? maximum.y : box.maximum.y;

-            maximum.z = maximum.z > box.maximum.z ? maximum.z : box.maximum.z;

+            minimum.min(box.minimum);

+            maximum.max(box.maximum);

         }

 

         void union_with(const point3 &point) {

-            minimum.x = minimum.x < point.x ? minimum.x : point.x;

-            minimum.y = minimum.y < point.y ? minimum.y : point.y;

-            minimum.z = minimum.z < point.z ? minimum.z : point.z;

-

-            maximum.x = maximum.x > point.x ? maximum.x : point.x;

-            maximum.y = maximum.y > point.y ? maximum.y : point.y;

-            maximum.z = maximum.z > point.z ? maximum.z : point.z;

+            minimum.min(point);

+            maximum.max(point);

         }

 

         int32_t maximum_axis() {

             vec3 diag = diagonal();

 

-            if (diag.x > diag.y && diag.x > diag.z) {

+            // if (diag.x > diag.y && diag.x > diag.z) {

+            //     return 0;

+            // } else if (diag.y > diag.z) {

+            //     return 1;

+            // } else {

+            //     return 2;

+            // }

+

+            if (diag.v[0] > diag.v[1] && diag.v[0] > diag.v[2]) {

                 return 0;

-            } else if (diag.y > diag.z) {

+            } else if (diag.v[1] > diag.v[2]) {

                 return 1;

             } else {

                 return 2;

@@ -67,7 +73,8 @@ class aabb {
 

         float surface_area() {

             auto diag = diagonal();

-            return 2.f * (diag.x * diag.y + diag.x * diag.z + diag.y * diag.z);

+            // return 2.f * (diag.x * diag.y + diag.x * diag.z + diag.y * diag.z);

+            return 2.f * (diag.v[0] * diag.v[1] + diag.v[0] * diag.v[2] + diag.v[1] * diag.v[2]);

         }

 

         vec3 minimum = vec3(std::numeric_limits<float>::max());

diff --git a/include/bvh-node.hpp b/include/bvh-node.hpp
index 09c9420..698977a 100644
--- a/include/bvh-node.hpp
+++ b/include/bvh-node.hpp
@@ -91,13 +91,13 @@ public:
 

             node.primitive_id = old_node.primitive_id;

 

-            node.min[0] = old_node.bounding_box.minimum.x;

-            node.min[1] = old_node.bounding_box.minimum.y;

-            node.min[2] = old_node.bounding_box.minimum.z;

+            node.min[0] = old_node.bounding_box.minimum.v[0];

+            node.min[1] = old_node.bounding_box.minimum.v[1];

+            node.min[2] = old_node.bounding_box.minimum.v[2];

 

-            node.max[0] = old_node.bounding_box.maximum.x;

-            node.max[1] = old_node.bounding_box.maximum.y;

-            node.max[2] = old_node.bounding_box.maximum.z;

+            node.max[0] = old_node.bounding_box.maximum.v[0];

+            node.max[1] = old_node.bounding_box.maximum.v[1];

+            node.max[2] = old_node.bounding_box.maximum.v[2];

 

             if (old_node.next_id != -1) {

                 node.next_id = temp_nodes[old_node.next_id].df_id;

diff --git a/include/utils.hpp b/include/utils.hpp
index e7178d8..8548a5f 100644
--- a/include/utils.hpp
+++ b/include/utils.hpp
@@ -9,6 +9,7 @@ std::vector<uint8_t> read_file(const char* path);
 std::vector<uint8_t> read_file(std::string& path);
 
 #define PI 3.14159265359
+#define EPSILON 0.000001
 
 inline float deg_to_rad(float deg) {
     return deg * PI / 180.0;
diff --git a/include/vec3.hpp b/include/vec3.hpp
index 6291e30..429d747 100644
--- a/include/vec3.hpp
+++ b/include/vec3.hpp
@@ -2,6 +2,7 @@
 #define __VEC3_HPP_
 
 #include <iostream>
+#include <xmmintrin.h>
 
 class vec3 {
     public:
@@ -9,10 +10,15 @@ class vec3 {
 
     vec3(float x);
     vec3(float x, float y, float z);
+    vec3(__m128& v);
+    vec3(__m128&& v);
+    vec3(const vec3& vec);
 
     vec3 operator-() const;
 
-    vec3& operator+=(vec3 vec);
+    vec3& operator=(const vec3& vec);
+
+    vec3& operator+=(const vec3& vec);
 
     vec3& operator*=(float scale);
 
@@ -28,7 +34,11 @@ class vec3 {
 
     vec3 cross(const vec3& vec) const;
 
-    vec3 unit() const;
+    vec3& min(const vec3& vec);
+
+    vec3& max(const vec3& vec);
+
+    vec3& normalize();
 
     bool near_zero() const;
 
@@ -36,38 +46,29 @@ class vec3 {
 
     static vec3 random(float min, float max);
 
-    float x, y, z;
-    float padding;
+    __m128 v;
 };
 
-vec3 lerp(vec3 u, vec3 v, float t);
+vec3 lerp(const vec3& u, const vec3& v, float t);
 
-vec3 operator+(vec3 u, vec3 v);
+vec3 operator+(const vec3& u, const vec3& v);
 
-vec3 operator-(vec3 u, vec3 v);
+vec3 operator-(const vec3& u, const vec3& v);
 
-vec3 operator*(vec3 u, vec3 v);
+vec3 operator*(const vec3& u, const vec3& v);
 
-vec3 operator*(vec3 u, float scale);
+vec3 operator*(const vec3& u, float scale);
 
-vec3 operator*(float scale, vec3 u);
+vec3 operator*(float scale, const vec3& u);
 
-vec3 operator/(vec3 u, float scale);
+vec3 operator/(const vec3& u, float scale);
 
-vec3 reflect(vec3 v, vec3 n);
+vec3 reflect(const vec3& v, const vec3& n);
 
 vec3 refract(const vec3& uv, const vec3& n, float etai_over_etat);
 
 std::ostream& operator<<(std::ostream& out, vec3 vec);
 
-vec3 random_in_unit_sphere();
-
-vec3 random_unit_vector();
-
-vec3 random_in_hemisphere(const vec3& normal);
-
-vec3 random_in_unit_disk();
-
 using point3 = vec3;
 using color = vec3;