stuff

Makefile

@@ -1,10 +1,14 @@
 
 LINKS = -lSDL2 -lm -Wall -g
 
-all: colours.o
-	gcc main.c $(LINKS) colours.o -o blackpink
+all: colours.o vect.o
+	gcc main.c colours.o vect.o $(LINKS) -o blackpink
 
 colours.o: colours.c colours.h
 	gcc $(LINKS) -c colours.c -o colours.o
 
+vect.o: vect.c vect.h
+	gcc $(LINKS) -c vect.c -o vect.o
+
+
 clean:

camera.c

@@ -1,4 +1,6 @@
-#include "main.h"
+#include "types.h"
+#include "math.h"
+#include "vect.h"
 
 #define DRAW_DIST 1000.0
 #define MAX_ITERATIONS 255
@@ -6,6 +8,10 @@
 
 struct solid manifold;
 
+double solid_dist(struct solid *s, struct vec *v) {
+        return s->dist(v);
+}
+
 /* return a malloced vector, normal to sol at r */ 
 struct vec * 
 estimateNormal(struct vec *r, struct solid *sol) 
@@ -17,11 +23,11 @@ estimateNormal(struct vec *r, struct solid *sol)
                 double s1 = solid_dist(sol, tmp);
                 tmp->elements[i] = -EPSILON;
                 double s2 = solid_dist(sol, tmp);
-
+                
                 out->elements[i] = s1 - s2;
                 tmp->elements[i] = 0;
         }
-        free_vec(tmp->elements);
+        free(tmp->elements);
         return normalise_vec_ip(out);
 }
 
@@ -32,25 +38,36 @@ rotateaxis(struct vec *v, struct vec *k, double a)
 
         struct vec *comp1 = scalar_multiply_vec_ip(copy_vec(v), cosa);
         struct vec *comp2 = scalar_multiply_vec_ip(perpendicular_vec(k, v), sin(a));
-        struct vec *comp3 = scalar_multiply_vec_ip(copy_vec(k), dot(k, v)*(1 - cosa));
+        struct vec *comp3 = scalar_multiply_vec_ip(copy_vec(k), dot_product_vec(k, v)*(1 - cosa));
         add_vec_ip(comp1, add_vec_ip(comp2, comp3));
-        free(v->)
+
+        free(v->elements);
+        free_vec(comp3);
+        free_vec(comp2);
+        v->elements = comp1->elements;
 }
 
 void 
 manifoldstep(struct ray *r, double distance)
 {
-        struct vec *yaxisold = estimateNormal(r->pos, &manifold);
-        add_vec_ip(&r->pos, scale_vec(r->dir, distance)); /* move the vector foward in euclid */
-        struct vec *yaxisnew = estimateNormal(r->pos, &manifold);
 
-        struct vec *temp = scale_vec(yaxisnew, manifold.dist(r->pos));
-        add_vec_ip(&r->pos, temp); /* stick it to the manifold */
-        free_vec(temp);
+        struct vec *yaxisold = estimateNormal(&r->pos, &manifold);
+
+         /* move the vector foward in euclid */
+        add_scaled_vec_ip(&r->pos, &r->dir, distance);
 
-        double protamtloc = acos(dot(yaxisold,yaxisnew));
-        struct vec *protaxisloc = normalise_vec_ip(cross(yaxisold, yaxisnew));
+        struct vec *yaxisnew = estimateNormal(&r->pos, &manifold);
+
+        /* stick it to the manifold */
+        add_scaled_vec_ip(&r->pos, yaxisnew, manifold.dist(&r->pos));
+
+        double protamtloc = acos(dot_product_vec(yaxisold,yaxisnew));
+        struct vec *protaxisloc = normalise_vec_ip(perpendicular_vec(yaxisold, yaxisnew));
         rotateaxis(&r->dir, protaxisloc, protamtloc); /* change the direction */
+
+        free_vec(yaxisnew);
+        free_vec(yaxisold);
+        free_vec(protaxisloc);
 }
 
 struct pixel_info 
@@ -61,7 +78,7 @@ march(struct ray *r, struct object *scene)
         int i;
         color out = 0;
         for (i = 0; (i < MAX_ITERATIONS) && (travel_dist < DRAW_DIST); i++) {
-                scene_dist = scene->sol->dist(&r->pos);
+                scene_dist = scene->sol.dist(&r->pos);
 
                 if (scene_dist < EPSILON) { /* we've hit an object */
                          out = scene->col(*r);
@@ -77,4 +94,4 @@ march(struct ray *r, struct object *scene)
                 .travel_dist = travel_dist, 
                 .scene_dist = scene_dist
                 }; 
-}
+}

types.h

@@ -8,6 +8,7 @@
 #define B_INTERNAL_HEIGHT 800
 #define B_INTERNAL_WIDTH 600
 
+#include "vect.h"
 #include "main.h"
 
 enum solid_op {
@@ -49,5 +50,4 @@ struct object
     color (*col)(struct ray);
 };
 
-
 #endif

vect.c

@@ -27,6 +27,16 @@ struct vec* do_on_vec_ip(struct vec * v, double (*func)(double)) {
 }
 
 
+struct vec*
+new_vec_of(int num_dimensions, double value) {
+    struct vec* new_vector = new_vec(num_dimensions);
+    for (int i = 0; i < num_dimensions; i++) {
+        new_vector->elements[i] = value;
+    }
+
+    return new_vector;
+}
+
 /**
  * Frees all memory related to the given vec.
  */
@@ -132,6 +142,32 @@ add_vec_ip(struct vec* a, struct vec* b)
     return a;
 }
 
+/**
+ * Add vec a to vec b * scaleFactor and store in vec a. Returns a pointer to vec a.
+ */
+struct vec*
+add_scaled_vec_ip(struct vec* a, struct vec* b, double scaleFactor) {
+    int smallest_dimension = a->dimension < b->dimension ? a->dimension : b->dimension;
+    int largest_dimension = a->dimension > b->dimension? a->dimension : b->dimension;
+
+
+    for (int i = 0; i < smallest_dimension; i++) {
+        a->elements[i] = a->elements[i] + b->elements[i] * scaleFactor;
+    }
+
+    // Assume the smaller array is all 0s if the dimensions aren't equal
+    for (int i = smallest_dimension; i < largest_dimension; i++) {
+        if (largest_dimension == a->dimension) {
+            a->elements[i] = a->elements[i];
+        } else if (largest_dimension == b->dimension) {
+            a->elements[i] = b->elements[i] * scaleFactor;
+        }
+    }
+
+    return a;
+}
+
+
 /**
  * Subtracts vec b from vec a and returns a reference to the difference vec.
  */
@@ -159,6 +195,33 @@ subtract_vec(struct vec* a, struct vec* b)
     return result;
 }
 
+/**
+ * Subtracts vec b from vec a and stores the result in vec a, returning a 
+ * pointer to it as well.
+ */
+struct vec* 
+subtract_vec_ip(struct vec* a, struct vec* b) 
+{
+    int smallest_dimension = a->dimension < b->dimension ? a->dimension : b->dimension;
+    int largest_dimension = a->dimension > b->dimension? a->dimension : b->dimension;
+
+    // Perform subtraction up to where the dimensions of both vectors are equal.
+    for (int i = 0; i < smallest_dimension; i++) {
+        a->elements[i] = a->elements[i] - b->elements[i];
+    }
+
+    // Assume the smaller array is all 0s if the dimensions aren't equal
+    for (int i = smallest_dimension; i < largest_dimension; i++) {
+        if (largest_dimension == a->dimension) {
+            break; // the elements of a don't need to be changed 
+        } else if (largest_dimension == b->dimension) {
+            a->elements[i] = - b->elements[i];
+        }
+    }
+
+    return a;
+}
+
 /**
  * Calculates the magnitude of vec a.
  */
@@ -203,15 +266,14 @@ normalise_vec_ip(struct vec* a)
 }
 
 /**
- * Calculate the dot product of vec a and vec b and return a reference to
- * the result.
+ * Calculate the dot product of vec a and vec b.
  */
-struct vec* 
+double
 dot_product_vec(struct vec* a, struct vec* b) 
 {
-    struct vec* result = new_vec(a->dimension);
+    double result = 0;
     for (int i = 0; i < a->dimension; i++) {
-        result->elements[i] = a->elements[i] * b->elements[i];
+        result += a->elements[i] * b->elements[i];
     }
 
     return result;
@@ -231,6 +293,19 @@ scalar_multiply_vec(struct vec* a, double scalarFactor)
     return result;
 }
 
+/**
+ * Multiply vec a by a scalarFactor and return vec a with the result.
+ */
+struct vec* 
+scalar_multiply_vec_ip(struct vec* a, double scalarFactor) 
+{
+    for (int i = 0; i < a->dimension; i++) {
+        a->elements[i] *= scalarFactor;
+    }
+
+    return a;
+}
+
 /**
  * Calculate the distance between vec a and vec b by summing the square of
  * the differences of each component.
@@ -246,7 +321,9 @@ distance_vec(struct vec* a, struct vec* b)
     return sqrt(sum_of_differences);
 }
 
-double vec_max(const struct vect *v) {
+double 
+vec_max(const struct vec *v) 
+{
     double max = -DBL_MAX;
 
     for (int i = 0; i < v->dimension; i++) {
@@ -257,7 +334,9 @@ double vec_max(const struct vect *v) {
     return max;
 }
 
-double vec_min(const struct vec *v) {
+double 
+vec_min(const struct vec *v) 
+{
     double min = DBL_MAX;
 
     for (int i = 0; i < v->dimension; i++) {

vect.h

@@ -10,6 +10,8 @@ struct vec {
 };
 
 struct vec* new_vec(int num_dimensions);
+struct vec* new_vec_of(int num_dimensions, double value);
+
 void free_vec(struct vec*);
 
 struct vec* new_vec2(double x, double y);
@@ -18,8 +20,10 @@ struct vec* new_vec4(double w, double x, double y, double z);
 
 struct vec* add_vec(struct vec* a, struct vec* b);
 struct vec* add_vec_ip(struct vec* a, struct vec* b);
+struct vec* add_scaled_vec_ip(struct vec* a, struct vec* b, double scaleFactor);
 
 struct vec* subtract_vec(struct vec* a, struct vec* b);
+struct vec* subtract_vec_ip(struct vec* a, struct vec* b);
 
 struct vec* normalise_vec(struct vec* a);
 struct vec* normalise_vec_ip(struct vec* a);
@@ -27,8 +31,14 @@ struct vec* normalise_vec_ip(struct vec* a);
 double magnitude_vec(struct vec* a);
 double distance_vec(struct vec* a, struct vec* b);
 
-struct vec* dot_product_vec(struct vec* a, struct vec* b);
+double dot_product_vec(struct vec* a, struct vec* b);
+
+struct vec* add_scaled_vec_ip(struct vec* a, struct vec* b, double multiplier);
+
 struct vec* scalar_multiply_vec(struct vec* a, double multiplier);
+struct vec* scalar_multiply_vec_ip(struct vec* a, double multiplier);
+
+struct vec* copy_vec(struct vec*);
 
 struct vec* perpendicular_vec(struct vec* a, struct vec* b);