Merge branch 'main' of https://github.com/ailrst/blackpink into richal-scene-stuff

camera.c

@@ -41,8 +41,16 @@ struct solid manifold = (struct solid) {
         .dist = manidist,
 };
 
+struct colour 
+solid_col(struct object *s, struct ray *r) {
+        subtract_vec_ip(r->pos, &(s->sol.pos));
+        struct colour out = s->col(r, s);
+        add_vec_ip(r->pos, &(s->sol.pos));
+        return out;
+}
+
 double solid_dist(struct solid *s, struct vec *v) {
-        subtract_vec_ip(v, &s->pos);
+        subtract_vec_ip(v, &(s->pos));
         double out = s->dist(v);
         add_vec_ip(v, &s->pos);
         return out;
@@ -102,32 +110,36 @@ int vectorisnan(struct vec *v)
         return 0;
 }
 
-void 
-manifoldturn(struct ray *r, struct vec *v, double distance)
+void
+manifoldstepaxees(struct vec *pos, struct vec *dir, struct vec **lads, int numlads, double distance) 
 {
+        if (numlads == 0) {
+                *((int *) 0) = 0;
+        }
 
-        struct vec *yaxisold = estimateNormal(r->pos, &manifold);
+        struct vec *yaxisold = estimateNormal(pos, &manifold);
 
          /* move the vector foward in euclid */
-        add_scaled_vec_ip(r->pos, r->dir, distance);
+        add_scaled_vec_ip(pos, dir, distance);
 
-        struct vec *yaxisnew = estimateNormal(r->pos, &manifold);
+        struct vec *yaxisnew = estimateNormal(pos, &manifold);
 
         /* stick it to the manifold */
-        add_scaled_vec_ip(r->pos, yaxisnew, manifold.dist(r->pos));
+        add_scaled_vec_ip(pos, yaxisnew, manifold.dist(pos));
 
         double protamtloc = acos(dot_product_vec(yaxisold,yaxisnew));
 
         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 < numlads; i++) {
+                struct vec *temp = copy_vec(lads[i]);
+                rotateaxis(temp, protaxisloc, protamtloc); /* change the direction */
+                if (!vectorisnan(temp)) {
+                        free(lads[i]->elements);
+                        lads[i]->elements = temp->elements;
+                        free(temp);
+                } else {
+                        free_vec(temp);
+                }
         }
 
         free_vec(yaxisnew);
@@ -136,12 +148,9 @@ manifoldturn(struct ray *r, struct vec *v, double distance)
 }
 
 void 
-manifoldstep(struct ray *r, double distance)
+manifoldturn(struct ray *r, struct vec *v, double distance)
 {
 
-        manifoldturn(r, r->dir, distance);
-        return;
-
         struct vec *yaxisold = estimateNormal(r->pos, &manifold);
 
          /* move the vector foward in euclid */
@@ -155,13 +164,28 @@ manifoldstep(struct ray *r, double distance)
         double protamtloc = acos(dot_product_vec(yaxisold,yaxisnew));
 
         struct vec *protaxisloc = normalise_vec_ip(reyeet(yaxisold, yaxisnew));
-        rotateaxis(r->dir, protaxisloc, protamtloc); /* change the direction */
+
+        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);
+        }
 
         free_vec(yaxisnew);
         free_vec(yaxisold);
         free_vec(protaxisloc);
 }
 
+void 
+manifoldstep(struct ray *r, double distance)
+{
+        manifoldturn(r, r->dir, distance);
+}
+
 void place(struct solid *v) {
         struct vec *dirs [v->pos.dimension];
         for (int d = 0; d < v->pos.dimension; d++) {
@@ -170,25 +194,16 @@ void place(struct solid *v) {
         }
         struct vec *tdir = new_vec(v->pos.dimension);
         struct vec *tpos = new_vec(v->pos.dimension);
-        struct ray ree = (struct ray) {
-                .dir = tdir,
-                .pos = tpos,
-        };
+
         for (int d = 0; d < v->pos.dimension; d++) {
                 for (double yee = v->pos.elements[d]; dabs(yee) > EPSILON; yee -= dsign(yee) * EPSILON) {
-                        for (int i = 0; i < v->pos.dimension; i++) {
-                                if (i == d) continue;
-                                for (int j = 0; j < v->pos.dimension; j++) {
-                                        ree.dir->elements[j] = dirs[d]->elements[j];
-                                        ree.pos->elements[j] = v->pos.elements[j];
-                                }
-                                manifoldturn(&ree, dirs[i], EPSILON);
-                        }
-                        manifoldstep(&ree, EPSILON);
+                        manifoldstepaxees(tpos, dirs[d], dirs, v->pos.dimension, EPSILON);
                 }
         }
-        free_vec(ree.dir);
-        free_vec(ree.pos);
+        free_vec(tdir);
+        free_vec(tpos);
+        for (int d = 0; d < v->pos.dimension; d++) free_vec(dirs[d]);
+        free(dirs);
 }
 
 struct pixel_info 
@@ -201,8 +216,9 @@ march(struct ray *r, struct object *scene)
         int fligs = 0;
         struct colour out = (struct colour) {.sp = CS_RGB};
         for (i = 0; (i < MAX_ITERATIONS) && (travel_dist < DRAW_DIST); i++) {
-                //scene_dist = scene->sol.dist(&(r->pos));
+                /* calculate the distance to the scene */
                 scene_dist = solid_dist(&(scene->sol), r->pos);
+
                 if (scene_dist < EPSILON) { /* we've hit an object */
                         out = scene->col(r, scene);
                         fligs |= 0x01;
@@ -212,6 +228,7 @@ march(struct ray *r, struct object *scene)
                 if (min_dist > scene_dist)
                         min_dist = scene_dist;
 
+                /* step foward the calculated distance */
                 manifoldstep(r, scene_dist);
                 travel_dist += scene_dist;
         }
@@ -255,7 +272,7 @@ process_pixel(int i, int j)
             .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);
+        struct pixel_info p = march(&r, scene_object);
 
         
         // p.col.r += p.travel_dist;

camera.h

@@ -11,12 +11,13 @@
 struct pixel_info march(struct ray *r, struct object *scene);
 Uint32 process_pixel(int, int);
 
+struct colour solid_col(struct object *s, struct ray *r);
 double solid_dist(struct solid *s, struct vec *v);
 void place(struct solid *v);
 struct vec * estimateNormal(struct vec *r, struct solid *sol);
 
 void manifoldstep(struct ray *r, double distance);
-
 void manifoldturn(struct ray *r, struct vec *v, double distance);
+void manifoldstepaxees(struct vec *pos, struct vec *dir, struct vec **lads, int numlads, double distance);
 
 #endif

distfuncs.c

@@ -7,6 +7,71 @@
 #define HARD_LIGHT 2
 #define WHITE_LIGHT 2
 
+double divid_fp(double a, double b) {
+    return a / b;
+}
+
+/*
+ *
+ * float sdEllipsoid( vec3 p, vec3 r )
+{
+  float k0 = length(p/r);
+  float k1 = length(p/(r*r));
+  return k0*(k0-1.0)/k1;
+}
+ *
+ */
+double sdf_4ellipsoid(struct vec *x) {
+    double r = 1;
+
+    struct vec *shape = new_vec4(1.5,3,1,4);
+    struct vec *v = copy_vec(x);
+
+    double dim = 0;
+    for (int i = 0 ; i < v->dimension; i ++) {
+        v->elements[i] = v->elements[i] / shape->elements[i];
+    }
+
+    double k0 = magnitude_vec(v);
+    free_vec(v);
+    v = copy_vec(x);
+    for (int i = 0 ; i < v->dimension; i ++) {
+        v->elements[i] = v->elements[i] / pow(shape->elements[i], 2);
+    }
+    double k1 = magnitude_vec(v);
+
+    double result = k0 * (k0 - 1.0) / k1;
+    free_vec(v);
+    return result;
+
+}
+
+
+double sdf_3ellipsoid(struct vec *x) {
+    double r = 1;
+
+    struct vec *shape = new_vec3(1.5,3,1);
+    struct vec *v = copy_vec(x);
+
+    double dim = 0;
+    for (int i = 0 ; i < 3; i ++) {
+        v->elements[i] = v->elements[i] / shape->elements[i];
+    }
+
+    double k0 = magnitude_vec(v);
+    free_vec(v);
+    v = copy_vec(x);
+    for (int i = 0 ; i < 3; i ++) {
+        v->elements[i] = v->elements[i] / pow(shape->elements[i], 2);
+    }
+    double k1 = magnitude_vec(v);
+
+    double result = k0 * (k0 - 1.0) / k1;
+    free_vec(v);
+    return result;
+}
+
+
 double sdf_sphere(struct vec *x) {
     static const double r = 1.4;
     struct vec *v = copy_vec(x);
@@ -215,7 +280,9 @@ new_object(struct vec* position, double rotation, double scale,
         double (*dist)(struct vec*), struct colour (*col)(struct ray *, struct object *)) 
 {
     struct object new_obj;
-    new_obj.base_col = get_random_color();
+    struct colour default_col = {.r = 255, .g=255, .b=255, .a=255, .sp=CS_RGB};
+    new_obj.base_col = default_col;
+
     new_obj.col = col;
     new_obj.sol.dist = dist;
     new_obj.sol.pos = *position;
@@ -231,6 +298,11 @@ struct object new_sphere(struct vec* position, double rotation, double scale) {
     return new_object(position, rotation, scale, sdf_sphere, yeet_pho);
 }
 
+struct object new_ellipse(struct vec* position, double rotation, double scale) {
+    return new_object(position, rotation, scale, sdf_3ellipsoid, yeet_pho);
+}
+
+
 struct object new_box(struct vec* position, double rotation, double scale) {
     return new_object(position, rotation, scale, sdf_box, yeet_pho);
 }
@@ -244,11 +316,6 @@ struct object new_vert_line(struct vec* position, double rotation, double scale)
     return new_object(position, rotation, scale, sdf_phat_vert_line, yeet_pho);
 }
 
-struct colour yeet_whit(struct ray *ray, struct object* obj) {
-    struct colour c = {.r = 200, .g = 200, .b = 200, .a = 255, .sp=CS_RGB};
-    return c;
-}
-
 /**
  * The absolute jankiest way to make a tree but I couldn't think of anything
  * better.
@@ -269,4 +336,4 @@ struct object* new_tree(struct vec* position, double rotation, double scale) {
     tree[1] = leaves;
 
     return tree;
-}
+}

distfuncs.h

@@ -17,4 +17,8 @@ double sdf_sphere(struct vec *);
 
 struct colour yeet_col(struct ray *);
 
+double sdf_3ellipsoid(struct vec *x); 
+double sdf_4ellipsoid(struct vec *x); 
+
 #endif
+

main.c

@@ -19,7 +19,7 @@ int exitnow = 0;
 SDL_Renderer * ren;  
 Uint32 pixels[B_INTERNAL_HEIGHT][B_INTERNAL_WIDTH];
 
-struct object scene_object;
+struct object *scene_object;
 struct camera *camera;
 
 struct SDL_Window* make_window(void) {
@@ -34,6 +34,8 @@ struct SDL_Window* make_window(void) {
                                        SDL_WINDOW_RESIZABLE); 
 }
 
+
+
 void handle_inputs(void) 
 {
     /* this is so broken it leaks memory everywhere and crashes and idek why 
@@ -48,71 +50,31 @@ void handle_inputs(void)
     r.pos = new_vec(4);
 
     const double dist = 0.1;
-    double done = 0;
-
-    if (keyboardstate[SDL_SCANCODE_UP]) {
-        struct ray cameraray = {.pos = copy_vec(camera->pos), .dir = camera->y};
-        manifoldturn(&cameraray, camera->x, dist);
-        free_vec(cameraray.pos);
 
-        cameraray.pos = copy_vec(camera->pos);
-        manifoldturn(&cameraray, camera->z, dist);
+    struct vec ** in = malloc(sizeof(struct vec *) * 3);
+    in[0] = camera->x;
+    in[1] = camera->y;
+    in[2] = camera->z;
 
-        cameraray.pos = camera->pos;
-        manifoldstep(&cameraray, dist);
-        done = dist;
+    if (keyboardstate[SDL_SCANCODE_UP]) {
+        manifoldstepaxees(camera->pos, camera->y, in, 3, dist);
     }
     if (keyboardstate[SDL_SCANCODE_DOWN]) {
-        struct ray cameraray = {.pos = copy_vec(camera->pos), .dir = camera->y};
-        manifoldturn(&cameraray, camera->x, dist);
-
-        free_vec(cameraray.pos);
-        cameraray.pos = copy_vec(camera->pos);
-        manifoldturn(&cameraray, camera->z, -dist);
-
-        free_vec(cameraray.pos);
-        cameraray.pos = camera->pos;
-        manifoldstep(&cameraray, -dist);
-        done = -dist;
+        manifoldstepaxees(camera->pos, camera->y, in, 3, -dist);
     }
     if (keyboardstate[SDL_SCANCODE_LEFT])  {
-        struct ray cameraray = {.pos = copy_vec(camera->pos), .dir = camera->x};
-        manifoldturn(&cameraray, camera->z, dist);
-
-        free_vec(cameraray.pos);
-        cameraray.pos = copy_vec(camera->pos);
-
-        manifoldturn(&cameraray, camera->y, dist);
-        free_vec(cameraray.pos);
-        cameraray.pos = camera->pos;
-        manifoldstep(&cameraray, -dist);
-        done = -dist;
+        manifoldstepaxees(camera->pos, camera->x, in, 3, dist);
     }                                      
     if (keyboardstate[SDL_SCANCODE_RIGHT]) {
-        struct ray cameraray = {.pos = copy_vec(camera->pos), .dir = camera->x};
-        manifoldturn(&cameraray, camera->z, dist);
-
-        free_vec(cameraray.pos);
-        cameraray.pos = copy_vec(camera->pos);
-
-        manifoldturn(&cameraray, camera->y, dist);
-        free_vec(cameraray.pos);
-        cameraray.pos = camera->pos;
-        manifoldstep(&cameraray, dist);
-        done = -dist;
+        manifoldstepaxees(camera->pos, camera->x, in, 3, -dist);
     }                                      
         r.dir->elements[0] = -1;
     if (keyboardstate[SDL_SCANCODE_ESCAPE]) {
         exitnow = 1;
     }
 
-    if (fabs(done) > 0.00001)
-        manifoldstep(&r, done);
-
-    free_vec(r.dir);
-    free_vec(r.pos);
-    return;
-};
+    free(in);
+}
 
 
 int input_loop(void *ptr) {
@@ -183,9 +145,8 @@ void setup_camera_scene()
     scene_objects[1] = tree[1];
     
     scene_object = new_scene(2, scene_objects);
-    scene_object.sol.pos.dimension = 3;
-    scene_object.sol.pos.elements = camera->pos->elements;
-
+    scene_object->sol.pos.dimension = 3;
+    scene_object->sol.pos.elements = camera->pos->elements;
 }
 
 int main(int argc, char **argv) {
@@ -193,7 +154,7 @@ int main(int argc, char **argv) {
 
     SDL_Window * win = make_window();
     ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
-    SDL_RenderSetLogicalSize(ren, B_INTERNAL_HEIGHT, B_INTERNAL_HEIGHT);
+   // SDL_RenderSetLogicalSize(ren, B_INTERNAL_HEIGHT, B_INTERNAL_HEIGHT);
 
     // use this to turn on antristroptic filtering
 //    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2");

main.h

@@ -31,7 +31,7 @@ void sdlb_set_colour(struct colour col);
 
 void sdlb_draw_col_pixel(struct colour col, int x, int y);
 
-extern struct object scene_object;
+extern struct object *scene_object;
 extern int keyboardstate[322];  // 322 is the number of SDLK_DOWN events
 extern struct camera *camera;
 #endif

scene.c

@@ -20,7 +20,7 @@ colour_function(struct ray* ray, struct object* obj)
         double distance = solid_dist(&(scene.objects[i].sol), ray->pos);
         if (distance < min) {
             min = distance;
-            scene_colour = scene.objects[i].col(ray, &scene.objects[i]);
+            scene_colour = solid_col(scene.objects + i, ray);
         }
     }
 
@@ -41,7 +41,7 @@ distance_function(struct vec* position)
     return min;
 }
 
-struct object 
+struct object *
 new_scene(int num_scene_objects, struct object* scene_objects) 
 {
     scene.num_objects = num_scene_objects;
@@ -51,13 +51,13 @@ new_scene(int num_scene_objects, struct object* scene_objects)
     //     place(&(scene.objects[i].sol));
     // }
 
-    struct object scene_rep;
-    scene_rep.sol.dist = distance_function;
-    scene_rep.sol.op = B_ADD;
-    scene_rep.sol.rotation = 0;
-    scene_rep.sol.scale = 1;
+    struct object *scene_rep = malloc(sizeof(struct object));
+    scene_rep->sol.dist = distance_function;
+    scene_rep->sol.op = B_ADD;
+    scene_rep->sol.rotation = 0;
+    scene_rep->sol.scale = 1;
 
-    scene_rep.col = colour_function;
+    scene_rep->col = colour_function;
 
     return scene_rep;
 }

scene.h

@@ -9,6 +9,6 @@
 
 extern struct scene_objects scene;
 
-struct object new_scene(int, struct object*);
+struct object * new_scene(int, struct object*);
 
 #endif

types.h

@@ -2,8 +2,8 @@
 #define TYPES_H
 
 #define B_NUM_RAYMARCH_THREADS 8
-#define B_WINDOW_WIDTH 800
-#define B_WINDOW_HEIGHT 600
+#define B_WINDOW_WIDTH 900
+#define B_WINDOW_HEIGHT 900
 #define B_INTERNAL_HEIGHT 100
 #define B_INTERNAL_WIDTH 100