scream

Makefile

@@ -1,23 +1,23 @@
 
-LINKS = -lSDL2 -lm -Wall -g
+LINKS = -std=c++20 -lSDL2 -lm -Wall -g -fsanitize=address -O0
 
 all: colours.o vect.o distfuncs.o camera.o scene.o
-	gcc main.c colours.o vect.o distfuncs.o camera.o scene.o $(LINKS) -o blackpink
+	g++ main.c colours.o vect.o distfuncs.o camera.o scene.o $(LINKS) -o blackpink
 
 colours.o: colours.c colours.h
-	gcc $(LINKS) -c colours.c -o colours.o
+	g++ $(LINKS) -c colours.c -o colours.o
 
 vect.o: vect.c vect.h
-	gcc $(LINKS) -c vect.c -o vect.o
+	g++ $(LINKS) -c vect.c -o vect.o
 
 distfuncs.o: distfuncs.c distfuncs.h
-	gcc $(LINKS) -c distfuncs.c -o distfuncs.o
+	g++ $(LINKS) -c distfuncs.c -o distfuncs.o
 
 camera.o: camera.c 
-	gcc $(LINKS) -c camera.c -o camera.o
+	g++ $(LINKS) -c camera.c -o camera.o
 
 scene.o: scene.c
-	gcc $(LINKS) -c scene.c -o scene.o
+	g++ $(LINKS) -c scene.c -o scene.o
 
 pres: presentation.md
 	pandoc -t beamer presentation.md -o pres.pdf    

camera.c

@@ -95,18 +95,20 @@ rotateaxis(struct vec *v, struct vec *k, double a)
                 add_scaled_vec_ip(scalar_multiply_vec_ip(reyeet(v, k), sin(a)), v, cosa),
                 k, dot_product_vec(k, v)*(1 - cosa));
 
-        free(v->elements);
-        v->elements = p->elements;
-        free(p);
+        for (int i = 0; i < v->dimension; i++) {
+            v->elements[i] = p->elements[i];
+        }
+
+        free_vec(p);
 }
 
-int vectorisnan(struct vec *v) 
+bool vectorisnan(struct vec *v) 
 {
         for (int i = 0; i < v->dimension; i++) {
-                if (v->elements[i] != v->elements[i]) 
-                        return 1;
+            if (isnan(v->elements[i]))
+                return true;
         }
-        return 0;
+        return false;
 }
 
 void
@@ -131,11 +133,13 @@ manifoldstepaxees(struct vec *pos, struct vec *dir, struct vec **lads, int numla
         struct vec *protaxisloc = normalise_vec_ip(reyeet(yaxisold, yaxisnew));
         for (int i = 0; i < numlads; i++) {
                 struct vec *temp = copy_vec(lads[i]);
-                rotateaxis(temp, protaxisloc, protamtloc); /* change the direction */
+                rotateaxis(temp, protaxisloc, protamtloc);
                 if (!vectorisnan(temp)) {
-                        free(lads[i]->elements);
-                        lads[i]->elements = temp->elements;
-                        free(temp);
+                        for (int j = 0; j < lads[i]->dimension; j++) {
+                            lads[i]->elements[j] = temp->elements[j];
+                        }
+
+                        free_vec(temp);
                 } else {
                         free_vec(temp);
                 }
@@ -165,15 +169,16 @@ manifoldturn(struct ray *r, struct vec *v, double distance)
         struct vec *protaxisloc = normalise_vec_ip(reyeet(yaxisold, yaxisnew));
 
         struct vec *temp = copy_vec(v);
+
         rotateaxis(temp, protaxisloc, protamtloc); /* change the direction */
+
         if (!vectorisnan(temp)) {
-                free(v->elements);
-                v->elements = temp->elements;
-                free(temp);
-        } else {
-                free_vec(temp);
-        }
+                for (int i = 0; i < v->dimension; i++) {
+                    v->elements[i] = temp->elements[i];
+                }
+        } 
 
+        free_vec(temp);
         free_vec(yaxisnew);
         free_vec(yaxisold);
         free_vec(protaxisloc);
@@ -187,7 +192,7 @@ manifoldstep(struct ray *r, double distance)
 
 void 
 place(struct solid *v) {
-        struct vec **dirs = malloc(sizeof(struct vec *) * v->pos.dimension);
+        struct vec **dirs = (struct vec **)malloc(sizeof(struct vec *) * v->pos.dimension);
         for (int d = 0; d < v->pos.dimension; d++) {
                 dirs[d] = new_vec(v->pos.dimension);
                 dirs[d]->elements[d] = 1;
@@ -206,8 +211,11 @@ place(struct solid *v) {
 
 
 
-        v->pos.elements = tpos->elements;
-        free(tpos);
+        for (int i = 0; i < v->pos.dimension; i++) {
+            v->pos.elements[i] = tpos->elements[i];
+        }
+
+        free_vec(tpos);
         free_vec(tdir);
         for (int d = 0; d < v->pos.dimension; d++) free_vec(dirs[d]);
         free(dirs);
@@ -243,8 +251,8 @@ march(struct ray *r, struct object *scene)
         /* no colour reached */
         return (struct pixel_info) {
                 .flags = fligs, 
-                .iterations = i, 
                 .col = out, 
+                .iterations = i, 
                 .travel_dist = travel_dist, 
                 .scene_dist = min_dist
                 }; 
@@ -276,8 +284,9 @@ process_pixel(int i, int j)
 {
         struct ray r = (struct ray) {
             .pos = new_vec(4),
-            .dir = normalise_vec_ip(new_vec4(i  - B_INTERNAL_WIDTH/2, j - B_INTERNAL_HEIGHT/2, 100, 0))
+            .dir = normalise_vec_ip(new_vec4(i  - B_INTERNAL_WIDTH/(2), j - B_INTERNAL_HEIGHT/(2), 100, 0))
         };
+        
 
         struct pixel_info p = march(&r, scene_object);
         

colours.c

@@ -182,7 +182,7 @@ struct colour *get_adjacent(struct colour base, int deg, int num) {
     struct colour col = get_hsl(base);
     num += 1;
 
-    struct colour* colours = alloca(sizeof(struct colour) * num); 
+    struct colour* colours = (struct colour *)alloca(sizeof(struct colour) * num); 
 
     for (int i = 0; i < num; i++) {
         int m = (i % 2 == 0) ? -i : i;
@@ -192,7 +192,7 @@ struct colour *get_adjacent(struct colour base, int deg, int num) {
         colours[i].h += fmod(colours[i].h, 360);
     }
 
-    struct colour *ret_colours = calloc(num, sizeof(struct colour) * num);
+    struct colour *ret_colours = (struct colour *)calloc(num, sizeof(struct colour) * num);
 
     for (int i = 0; i < num; i++) {
         ret_colours[i] = get_rgb(colours[i]);
@@ -205,7 +205,7 @@ struct colour *get_adjacent(struct colour base, int deg, int num) {
 }
 
 void print_colour(struct colour c) {
-    char *colour = calloc(20, sizeof(char));
+    char *colour = (char *)calloc(20, sizeof(char));
     sprintf(colour, "#%02x%02x%02x (%d)", c.r, c.g, c.b, c.a);
     
     printf("\x1b[38;2;%d;%d;%dm%s\x1b[0m\n", c.r, c.g, c.b, colour);

colours.h

@@ -14,7 +14,6 @@ enum colour_space {
 };
 
 struct colour {
-    enum colour_space sp;
     double h;
     double s;
     double v;
@@ -23,6 +22,7 @@ struct colour {
     short g;
     short b;
     short a; // alpha
+    enum colour_space sp;
 };
 
 SDL_Colour get_sdlcolour(struct colour col, int alpha); 

distfuncs.c

@@ -117,17 +117,17 @@ double sdf_cone(struct vec *x) {
 
     double cone2 = 
 
-    struct vec * temp = new_vec2(v->e->x, v->e->z);
+    struct vec * temp = new_vec2(v->e.x, v->e.z);
     double aaa = magnitude_vec(temp);
     free_vec(temp);
-    w = new_vec2(aaa, v->e->y);
+    w = new_vec2(aaa, v->e.y);
 
     double t2 = clamp((dot_product_vec(w, v) / dot_product_vec(cone, cone)), 0.0, 1.0);
     temp = scalar_multiply_vec(cone, t2);
     a = subtract_vec(w, temp);
     free_vec(temp);
 
-    temp = new_vec2(clamp(w->e->x / cone->e->x, 0.0, 1.0), 1.0);
+    temp = new_vec2(clamp(w->e.x / cone->e.x, 0.0, 1.0), 1.0);
     scalar_multiply_vec_ip(temp, )
 
 
@@ -153,7 +153,7 @@ double sdf_phat_vert_line(struct vec *x) {
 
     struct vec *v = copy_vec(x);
     
-    v->e->y -= clamp(v->e->y, 0.0, h);
+    v->e.y -= clamp(v->e.y, 0.0, h);
     double val = magnitude_vec(v) - r;
     free_vec(v);
     return val;
@@ -251,7 +251,7 @@ struct colour yeet_col_og(struct ray *ray, struct object *obj) {
     struct vec *n = subtract_vec_ip(l, ray->pos);
     struct vec *nl = normalise_vec(l);
 
-    struct colour c = {.r = nl->e->x * 555, .g = nl->e->y * 555, .b = nl->e->z * 555, .a = 255, .sp=CS_RGB};
+    struct colour c = {.r = nl->e.x * 555, .g = nl->e.y * 555, .b = nl->e.z * 555, .a = 255, .sp=CS_RGB};
 
     free_vec(n);
     return (c);
@@ -347,7 +347,7 @@ struct colour yeet_brown(struct ray *ray, struct object* obj) {
  * tree (trunk and leaves). Iterate over the array when adding to a scene.
  */
 struct object* new_tree(struct vec* position, double rotation, double scale) {
-    struct object* tree = malloc(2 * sizeof(struct object));
+    struct object* tree = (struct object *)malloc(2 * sizeof(struct object));
     struct object trunk = new_object(position, rotation, scale, sdf_phat_vert_line, yeet_pho);
     trunk.base_col = (struct colour){.r = 0x92, .g = 0x2D, .b = 0x50, .sp = CS_RGB};
     trunk.base_col.g += rand() % 20;

main.c

@@ -14,12 +14,15 @@
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_video.h>
 #include <stdlib.h>
+#include <sys/types.h>
 
 int keyboardstate[322] = {};  // 322 is the number of SDLK_DOWN events
-int exitnow = 0;
+static int exitnow = 0;
 SDL_Renderer * ren;  
 Uint32 pixels[B_INTERNAL_HEIGHT][B_INTERNAL_WIDTH];
 
+static bool shitty_semaphore[B_NUM_RAYMARCH_THREADS] = {};
+
 struct object *scene_object;
 struct camera *camera;
 
@@ -53,7 +56,7 @@ void handle_inputs(void)
 
     const double dist = 0.1;
 
-    struct vec ** in = malloc(sizeof(struct vec *) * 3);
+    struct vec ** in = (struct vec **)malloc(sizeof(struct vec *) * 3);
     in[0] = camera->x;
     in[1] = camera->y;
     in[2] = camera->z;
@@ -82,6 +85,11 @@ void handle_inputs(void)
         exitnow = 1;
     }
 
+    for (int i = 0; i < 3; i++) {
+        scene_object->sol.pos.elements[i] = camera->pos->elements[i];
+    }
+
+
     free(in);
 }
 
@@ -117,16 +125,25 @@ static int raymarch_threadfn(void *data) {
 
     /* draw stuff */
     /* march the rays */
-    for (int i = 0; i < B_INTERNAL_WIDTH; i++) {
-        for (int j = 0; j < B_INTERNAL_HEIGHT; j++) {
-            /* checkerboard rendering */
-            if ((i + j * B_INTERNAL_WIDTH) % B_NUM_RAYMARCH_THREADS != id) {
-                continue;
+    do {
+
+        while (shitty_semaphore[id]) {
+            ; // wait
+        }
+
+        for (int i = 0; i < B_INTERNAL_WIDTH; i++) {
+            for (int j = 0; j < B_INTERNAL_HEIGHT; j++) {
+                /* checkerboard rendering */
+                if ((i + j * B_INTERNAL_WIDTH) % B_NUM_RAYMARCH_THREADS != id) {
+                    continue;
+                }
+                //sdlb_draw_col_pixel(p.col, j, i);
+                pixels[j][i] = process_pixel(i, j);
             }
-            //sdlb_draw_col_pixel(p.col, j, i);
-            pixels[j][i] = process_pixel(i, j);
         }
-    }
+
+        shitty_semaphore[id] = true;
+    } while (!exitnow);
 
     free(data);
     return 0;
@@ -137,7 +154,7 @@ void setup_camera_scene()
 {
     //struct object white_sphere = new_object(new_vec3(0.75, 0, 8), 0, 1, sdf_box, yeet_whit);
 
-    camera = calloc(1, sizeof(struct camera));
+    camera = (struct camera *)calloc(1, sizeof(struct camera));
     camera->pos = new_vec(4);
     camera->x = new_vec(4);
     camera->y = new_vec(4);
@@ -158,7 +175,7 @@ void setup_camera_scene()
     const int num_trees = 4;
     int lastelem = 1;
 
-    struct object* scene_objects = malloc((lastelem + 2 * num_trees) * sizeof(struct object));
+    struct object* scene_objects = (struct object *)malloc((lastelem + 2 * num_trees) * sizeof(struct object));
 
     struct vec *plane_pos = new_vec4(0,2,-5,0);
     scene_objects[0] = new_plane(plane_pos, 1, 1);
@@ -174,7 +191,13 @@ void setup_camera_scene()
     
     scene_object = new_scene(2 * num_trees + lastelem, scene_objects);
     scene_object->sol.pos.dimension = 3;
-    scene_object->sol.pos.elements = camera->pos->elements;
+    // oh no does this actually have to point to the same thing ;-;
+//      scene_object->sol.pos.elements = camera->pos->elements;
+
+    for (int i = 0; i < 3; i++) {
+        scene_object->sol.pos.elements[i] = camera->pos->elements[i];
+    }
+
 }
 
 int main(int argc, char **argv) {
@@ -195,23 +218,23 @@ int main(int argc, char **argv) {
     SDL_Texture *texture = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, 
             SDL_TEXTUREACCESS_STATIC, B_INTERNAL_WIDTH, B_INTERNAL_HEIGHT);
 
-    SDL_Thread ** threads = calloc(B_NUM_RAYMARCH_THREADS, sizeof(SDL_Thread *));
+    SDL_Thread ** threads = (SDL_Thread **)calloc(B_NUM_RAYMARCH_THREADS, sizeof(SDL_Thread *));
 
     SDL_Thread *input_thread = SDL_CreateThread(input_loop, "input", (void *)NULL);
     setup_camera_scene();
+    for (int i = 0; i < B_NUM_RAYMARCH_THREADS; i++) {
+        int *tid = (int *)malloc(sizeof(int));
+        *tid = i;
+        threads[i] = SDL_CreateThread(raymarch_threadfn, "raymarch", tid);
+        // tid is freed in raymarch_threadfn
+    }
 
     while (!exitnow) {
         /* clear the view */
         start = SDL_GetPerformanceCounter();
-        SDL_LockMutex(frame_mutex);
         SDL_RenderClear(ren);
-        
-        for (int i = 0; i < B_NUM_RAYMARCH_THREADS; i++) {
-            int *tid = malloc(sizeof(int));
-            *tid = i;
-            threads[i] = SDL_CreateThread(raymarch_threadfn, "raymarch", tid);
-            // tid is freed in raymarch_threadfn
-        }
+        /*
+        SDL_LockMutex(frame_mutex);
 
         for (int i = 0; i < B_NUM_RAYMARCH_THREADS; i++) {
             int status;
@@ -219,12 +242,33 @@ int main(int argc, char **argv) {
         }
 
         SDL_UnlockMutex(frame_mutex);
+        */
+
+        bool done = false;
+        while (!done) {
+            done = true;
+            for (int i = 0; i < B_NUM_RAYMARCH_THREADS; i++) {
+                if (!shitty_semaphore[i]) {
+                    done = false;
+                    break;
+                }
+            }
+        }
+
         SDL_UpdateTexture(texture, NULL, pixels, B_INTERNAL_WIDTH * sizeof(Uint32));
 
         SDL_RenderCopy(ren, texture, NULL, NULL);
 
         SDL_RenderPresent(ren);
 
+
+        for (int i = 0; i < B_NUM_RAYMARCH_THREADS; i++) {
+            shitty_semaphore[i] = false;
+        }
+
+
+
+
         end = SDL_GetPerformanceCounter();
         double el = (1000 * (end - start) / SDL_GetPerformanceFrequency());
         if (el > 0) {

scene.c

@@ -53,7 +53,7 @@ new_scene(int num_scene_objects, struct object* scene_objects)
     }
      */
 
-    struct object *scene_rep = malloc(sizeof(struct object));
+    struct object *scene_rep = (struct object *)malloc(sizeof(struct object));
     scene_rep->sol.dist = distance_function;
     scene_rep->sol.op = B_ADD;
     scene_rep->sol.rotation = 0;

vect.c

@@ -1,7 +1,27 @@
 #include "vect.h"
 #include <math.h>
 #include <float.h>
+#include <execinfo.h>
 
+#define MAX_VECTORS 30240
+
+static int exitnow = 0;
+static int num_vectors[5] = {};
+
+struct vec vecnlist[5][MAX_VECTORS];
+
+/*
+struct vec* vecnlist[5] = {(struct vec *)&vec2list, 
+    (struct vec *)&vec3list, 
+    (struct vec *)&vec4list, 
+    (struct vec *)&vec5list
+};
+
+*/
+
+static int num_freevectors[5] = {};
+
+struct vec *freeveclist[5][MAX_VECTORS];
 
 
 /**
@@ -11,10 +31,28 @@
 struct vec* 
 new_vec(int num_dimensions)
 {
-    struct vec* new_vector = calloc(1,sizeof(struct vec));
+    //struct vec* new_vector = calloc(1,sizeof(struct vec));
+    // deque a free vector
+    char * did;
+    struct vec* new_vector;
+    if (num_freevectors[num_dimensions - 2] == 0 && num_vectors[num_dimensions - 2] < MAX_VECTORS) {
+       new_vector = (struct vec *)&(vecnlist[num_dimensions - 2][num_vectors[num_dimensions - 2]]);
+       num_vectors[num_dimensions - 2]++;
+       did = "new vec";
+    } else if (num_freevectors[num_dimensions - 2] > 0){
+       new_vector = freeveclist[num_dimensions - 2][(num_freevectors[num_dimensions - 2]) - 1];
+       did = "from free store";
+    } else {
+        fprintf(stderr, "OUT OF VECTORS %d %d %d\n", num_dimensions, num_vectors[num_dimensions - 2], num_freevectors[num_dimensions - 2]);
+        exitnow = true;
+    }
+    
     new_vector->dimension = num_dimensions;
+    new_vector->active = true;
 
-    new_vector->elements = calloc(num_dimensions, sizeof(double));
+    for (int i = 0; i < num_dimensions; i++) {
+        new_vector->elements[i] = 0;
+    }
 
     return new_vector;
 }
@@ -48,6 +86,8 @@ new_vec_of(int num_dimensions, double value) {
         new_vector->elements[i] = value;
     }
 
+    new_vector->active = true;
+
     return new_vector;
 }
 
@@ -57,8 +97,22 @@ new_vec_of(int num_dimensions, double value) {
 void 
 free_vec(struct vec* a) 
 {
-    free(a->elements);
-    free(a);
+    char *reason;
+
+
+    if (a < (struct vec *)vecnlist || a > (struct vec *)(vecnlist + MAX_VECTORS - 1)) {
+        fprintf(stderr, "WTF BAD VEC %e\n", a);
+        *(int *)109= 1;
+    }
+
+    if (!a->active) {
+        *(int *)102= 1;
+        return;
+    }
+
+    a->active = false;
+    int ind = a->dimension - 2;
+    freeveclist[ind][num_freevectors[ind]++] = a;
 }
 
 /**
@@ -68,6 +122,7 @@ struct vec*
 copy_vec(struct vec* to_copy) 
 {
     struct vec* new_vector = new_vec(to_copy->dimension);
+
     for (int i = 0; i < to_copy->dimension; i++) {
         new_vector->elements[i] = to_copy->elements[i];
     }
@@ -180,7 +235,7 @@ add_scaled_vec_ip(struct vec* a, struct vec* b, double scaleFactor) {
 
 
     for (int i = 0; i < smallest_dimension; i++) {
-        a->elements[i] = a->elements[i] + b->elements[i] * scaleFactor;
+        a->elements[i] += b->elements[i] * scaleFactor;
     }
 
     // Assume the smaller array is all 0s if the dimensions aren't equal
@@ -381,12 +436,12 @@ vec_min(const struct vec *v)
 struct mat2*
 new_mat(int num_rows, int num_cols) 
 {
-    struct mat2* new_matrix = calloc(1, sizeof(struct mat2));
+    struct mat2* new_matrix = (struct mat2*)calloc(1, sizeof(struct mat2));
     new_matrix->num_rows = num_rows;
     new_matrix->num_cols = num_cols;
-    new_matrix->elements = calloc(num_rows, sizeof(double*));
+    new_matrix->elements = (double **)calloc(num_rows, sizeof(double*));
     for (int r = 0; r < num_rows; r++) {
-        new_matrix->elements[r] = calloc(num_cols, sizeof(double));
+        new_matrix->elements[r] = (double *)calloc(num_cols, sizeof(double));
     }
 
     return new_matrix;

vect.h

@@ -4,32 +4,79 @@
 #include <stdlib.h>
 #include <stdio.h>
 
+
+void free_vec(struct vec* a);
+
 struct yeetVec {
     double x;
     double y;
     double z;
     double w;
+    double q;
 };
 
 struct vec {
     int dimension;
     union {
-        double *elements;
-        struct yeetVec *e;
+        struct yeetVec e;
+        double elements[5];
+    };
+    bool active;
+    /*
+
+    ~vec() {
+        free_vec(this);
+    }
+    */
+};
+
+struct vec5 {
+    int dimension;
+    union {
+        double elements[5];
+        struct yeetVec e;
+    };
+};
+
+struct vec4 {
+    int dimension;
+    union {
+        double elements[4];
+        struct yeetVec e;
+    };
+};
+
+struct vec3 {
+    int dimension;
+    union {
+        double elements[3];
+        struct yeetVec e;
+    };
+};
+
+
+struct vec2 {
+    int dimension;
+    union {
+        double elements[2];
+        struct yeetVec e;
     };
 };
 
+
 struct mat2 {
     int num_rows;
     int num_cols;
     double **elements;
 };
 
+
+
+
 struct vec* new_vec(int num_dimensions);
 struct vec* new_random_vec(int num_dimensions, double min, double max);
 struct vec* new_vec_of(int num_dimensions, double value);
 
-void free_vec(struct vec*);
 
 struct vec* new_vec2(double x, double y);
 struct vec* new_vec3(double x, double y, double z);