Working on groups

source/shapes/group.cpp

@@ -0,0 +1,73 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Group implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <tuple.h>
+#include <ray.h>
+#include <group.h>
+#include <cone.h>
+#include <math_helper.h>
+
+#define MIN_ALLOC (2)
+
+Group::Group() : Shape(SHAPE_GROUP)
+{
+    this->allocatedObjectCount = MIN_ALLOC;
+    this->objectList = (Shape **)calloc(sizeof(Shape *), MIN_ALLOC);
+    this->objectCount = 0;
+}
+
+Intersect Group::intersect(Ray r)
+{
+    Intersect ret;
+    int i, j;
+    if (this->objectCount > 0)
+    {
+        for(i = 0; i < this->objectCount; i++)
+        {
+            Intersect xs = this->objectList[i]->intersect(r);
+            if (xs.count() > 0)
+            {
+                for(j = 0; j < xs.count(); j++)
+                {
+                    ret.add(xs[j]);
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+Intersect Group::localIntersect(Ray r)
+{
+    return Intersect();
+}
+
+Tuple Group::localNormalAt(Tuple point)
+{
+    return Vector(1, 0, 0);
+}
+
+void Group::addObject(Shape *s)
+{
+    if ((this->objectCount + 1) > this->allocatedObjectCount)
+    {
+        this->allocatedObjectCount *= 2;
+        this->objectList = (Shape **)realloc(this->objectList, sizeof(Shape **) * this->allocatedObjectCount);
+    }
+
+    s->parent = this;
+    s->updateTransform();
+
+    this->objectList[this->objectCount++] = s;
+}
+
+bool Group::isEmpty()
+{
+    return (this->objectCount == 0);
+}

source/shapes/shape.cpp

@@ -15,10 +15,11 @@
 
 Shape::Shape(ShapeType type)
 {
+    this->parent = nullptr;
     this->dropShadow = true;
     this->type = type;
-    this->transformMatrix = Matrix4().identity();
-    this->inverseTransform = this->transformMatrix.inverse();
+    this->localTransformMatrix = Matrix4().identity();
+    this->updateTransform();
 }
 
 Intersect Shape::intersect(Ray r)
@@ -32,7 +33,7 @@ Tuple Shape::normalAt(Tuple point)
 
     Tuple local_normal = this->localNormalAt(local_point);
 
-    Tuple world_normal = this->inverseTransform.transpose() * local_normal;
+     Tuple world_normal = this->transposedInverseTransform * local_normal;
 
     /* W may get wrong, so hack it. This is perfectly normal as we are using a 4x4 matrix instead of a 3x3 */
     world_normal.w = 0;
@@ -40,8 +41,20 @@ Tuple Shape::normalAt(Tuple point)
     return world_normal.normalise();
 }
 
+void Shape::updateTransform()
+{
+    this->transformMatrix = this->localTransformMatrix;
+    if (this->parent != nullptr)
+    {
+        this->transformMatrix = this->parent->transformMatrix * this->transformMatrix;
+    }
+
+    this->inverseTransform = this->transformMatrix.inverse();
+    this->transposedInverseTransform = this->inverseTransform.transpose();
+}
+
 void Shape::setTransform(Matrix transform)
 {
-    this->transformMatrix = transform;
-    this->inverseTransform = transform.inverse();
+    this->localTransformMatrix = transform;
+    this->updateTransform();
 }