include/rasteriser/rasteriser.h

@@ -2,23 +2,12 @@
 #define RASTERISER_H
 
 #include "aliases.h"
-#include "camera/camera.h"
 #include "list/typed_list.h"
 #include "mem_arena.h"
 #include "vector/vec.h"
 #include "window/window.h"
 
-typedef struct {
-  u64 idx0;
-  u64 idx1;
-  u64 idx2;
-  colour_t colour;
-} scene_triangle_t;
-
 MAKE_LIST_TYPE(f32);
-MAKE_LIST_TYPE(vec2i_t);
-MAKE_LIST_TYPE(vec3f_t);
-MAKE_LIST_TYPE(scene_triangle_t);
 
 typedef struct {
   vec2i_t p0;
@@ -35,9 +24,6 @@ typedef struct {
   colour_t colour;
 } triangle_t;
 
-void render_object(window_t *wnd, Arena *arena, const camera_t *camera,
-                   vec3f_t viewport, const list_vec3f_t *vertices,
-                   const list_scene_triangle_t *triangles);
 void draw_wireframe_triangle(window_t *wnd, Arena *arena, triangle_t triangle);
 void draw_filled_triangle(window_t *wnd, Arena *arena, triangle_t triangle);
 void draw_shaded_triangle(window_t *wnd, Arena *arena, triangle_t triangle);

include/scene/scene.h

@@ -2,7 +2,6 @@
 #define SCENE_H
 
 #include "aliases.h"
-#include "vector/vec.h"
 #include "window/window.h"
 
 typedef struct {

src/rasteriser/main.c

@@ -1,10 +1,8 @@
 #include "camera/camera.h"
-#include "list/typed_list.h"
 #include "mem_arena.h"
 #include "mem_utils.h"
 #include "misc/misc_utils.h"
 #include "rasteriser/rasteriser.h"
-#include "scene/scene.h"
 #include "vector/vec.h"
 #include "window/window.h"
 #include <SDL2/SDL_events.h>
@@ -26,68 +24,6 @@ int main(void) {
     return EXIT_FAILURE;
   }
 
-  Arena *arena = NULL;
-  u64 main_arena_capacity = 20ull * 1024ull * 1024ull * 1024ull;
-  if (!wapp_mem_arena_init(&arena, main_arena_capacity, WAPP_MEM_ALLOC_RESERVE,
-                           false)) {
-    return EXIT_FAILURE;
-  }
-
-  vec3f_t translation = {-1.5f, 0.0f, 7.0f};
-
-  list_vec3f_t *vertices = list_create(vec3f_t, arena);
-  if (!vertices) {
-    return EXIT_FAILURE;
-  }
-  // Vertices
-  vec3f_t v0 = vec_add(vec3f_t, translation, ((vec3f_t){1, 1, 1}));
-  vec3f_t v1 = vec_add(vec3f_t, translation, ((vec3f_t){-1, 1, 1}));
-  vec3f_t v2 = vec_add(vec3f_t, translation, ((vec3f_t){-1, -1, 1}));
-  vec3f_t v3 = vec_add(vec3f_t, translation, ((vec3f_t){1, -1, 1}));
-  vec3f_t v4 = vec_add(vec3f_t, translation, ((vec3f_t){1, 1, -1}));
-  vec3f_t v5 = vec_add(vec3f_t, translation, ((vec3f_t){-1, 1, -1}));
-  vec3f_t v6 = vec_add(vec3f_t, translation, ((vec3f_t){-1, -1, -1}));
-  vec3f_t v7 = vec_add(vec3f_t, translation, ((vec3f_t){1, -1, -1}));
-
-  list_append(vec3f_t, arena, vertices, v0);
-  list_append(vec3f_t, arena, vertices, v1);
-  list_append(vec3f_t, arena, vertices, v2);
-  list_append(vec3f_t, arena, vertices, v3);
-  list_append(vec3f_t, arena, vertices, v4);
-  list_append(vec3f_t, arena, vertices, v5);
-  list_append(vec3f_t, arena, vertices, v6);
-  list_append(vec3f_t, arena, vertices, v7);
-
-  list_scene_triangle_t *triangles = list_create(scene_triangle_t, arena);
-  if (!triangles) {
-    return EXIT_FAILURE;
-  }
-  // Triangles
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){0, 1, 2, (colour_t){.colour = 0xff0000ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){0, 2, 3, (colour_t){.colour = 0xff0000ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){4, 0, 3, (colour_t){.colour = 0x00ff00ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){4, 3, 7, (colour_t){.colour = 0x00ff00ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){5, 4, 7, (colour_t){.colour = 0x0000ffff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){5, 7, 6, (colour_t){.colour = 0x0000ffff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){1, 5, 6, (colour_t){.colour = 0xffff00ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){1, 6, 2, (colour_t){.colour = 0xffff00ff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){4, 5, 1, (colour_t){.colour = 0xff00ffff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){4, 1, 0, (colour_t){.colour = 0xff00ffff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){2, 6, 7, (colour_t){.colour = 0x00ffffff}}));
-  list_append(scene_triangle_t, arena, triangles,
-              ((scene_triangle_t){2, 7, 3, (colour_t){.colour = 0x00ffffff}}));
-
   bool running = true;
   SDL_Event event = {0};
 
@@ -96,13 +32,59 @@ int main(void) {
   // i32 h_min = ((i32)window.half_height) * -1;
   // i32 h_max = (i32)window.half_height;
 
+  // The four "front" vertices
+  vec3f_t vAf = {-2, -0.5, 5};
+  vec3f_t vBf = {-2, 0.5, 5};
+  vec3f_t vCf = {-1, 0.5, 5};
+  vec3f_t vDf = {-1, -0.5, 5};
+
+  // The four "back" vertices
+  vec3f_t vAb = {-2, -0.5, 6};
+  vec3f_t vBb = {-2, 0.5, 6};
+  vec3f_t vCb = {-1, 0.5, 6};
+  vec3f_t vDb = {-1, -0.5, 6};
+
+  // The front face
+  line_t lABf = {project_point(vAf, &window, &camera, viewport),
+                 project_point(vBf, &window, &camera, viewport)};
+  line_t lBCf = {project_point(vBf, &window, &camera, viewport),
+                 project_point(vCf, &window, &camera, viewport)};
+  line_t lCDf = {project_point(vCf, &window, &camera, viewport),
+                 project_point(vDf, &window, &camera, viewport)};
+  line_t lDAf = {project_point(vDf, &window, &camera, viewport),
+                 project_point(vAf, &window, &camera, viewport)};
+
+  // The back face
+  line_t lABb = {project_point(vAb, &window, &camera, viewport),
+                 project_point(vBb, &window, &camera, viewport)};
+  line_t lBCb = {project_point(vBb, &window, &camera, viewport),
+                 project_point(vCb, &window, &camera, viewport)};
+  line_t lCDb = {project_point(vCb, &window, &camera, viewport),
+                 project_point(vDb, &window, &camera, viewport)};
+  line_t lDAb = {project_point(vDb, &window, &camera, viewport),
+                 project_point(vAb, &window, &camera, viewport)};
+
+  // The front-to-back edges
+  line_t lABfb = {project_point(vAf, &window, &camera, viewport),
+                  project_point(vAb, &window, &camera, viewport)};
+  line_t lBCfb = {project_point(vBf, &window, &camera, viewport),
+                  project_point(vBb, &window, &camera, viewport)};
+  line_t lCDfb = {project_point(vCf, &window, &camera, viewport),
+                  project_point(vCb, &window, &camera, viewport)};
+  line_t lDAfb = {project_point(vDf, &window, &camera, viewport),
+                  project_point(vDb, &window, &camera, viewport)};
+
   Arena *frame_arena = NULL;
-  u64 frame_arena_capacity = 10ull * 1024ull * 1024ull * 1024ull;
+  u64 capacity = 10ull * 1024ull * 1024ull * 1024ull;
-  if (!wapp_mem_arena_init(&frame_arena, frame_arena_capacity,
+  if (!wapp_mem_arena_init(&frame_arena, capacity, WAPP_MEM_ALLOC_RESERVE,
-                           WAPP_MEM_ALLOC_RESERVE, false)) {
+                           false)) {
     return EXIT_FAILURE;
   }
 
+  colour_t front = {.colour = 0x00ffaaff};
+  colour_t back = {.colour = 0xee0099ff};
+  colour_t fb = {.colour = 0xffaa00ff};
+
   while (running) {
     while (SDL_PollEvent(&event)) {
       switch (event.type) {
@@ -114,7 +96,20 @@ int main(void) {
 
     clear_window(&window, bg);
 
-    render_object(&window, arena, &camera, viewport, vertices, triangles);
+    draw_line(&window, frame_arena, lABf, front);
+    draw_line(&window, frame_arena, lBCf, front);
+    draw_line(&window, frame_arena, lCDf, front);
+    draw_line(&window, frame_arena, lDAf, front);
+
+    draw_line(&window, frame_arena, lABb, back);
+    draw_line(&window, frame_arena, lBCb, back);
+    draw_line(&window, frame_arena, lCDb, back);
+    draw_line(&window, frame_arena, lDAb, back);
+
+    draw_line(&window, frame_arena, lABfb, fb);
+    draw_line(&window, frame_arena, lBCfb, fb);
+    draw_line(&window, frame_arena, lCDfb, fb);
+    draw_line(&window, frame_arena, lDAfb, fb);
 
     swap_buffers(&window);
 
@@ -122,7 +117,6 @@ int main(void) {
   }
 
   wapp_mem_arena_destroy(&frame_arena);
-  wapp_mem_arena_destroy(&arena);
   close_window(&window);
 
   return EXIT_SUCCESS;

src/rasteriser/rasteriser.c

@@ -15,37 +15,6 @@ internal list_float *interpolate(Arena *arena, i32 i0, f32 d0, i32 i1, f32 d1);
 
 internal inline void order_triangle_points(triangle_t *triangle);
 
-void render_object(window_t *wnd, Arena *arena, const camera_t *camera,
-                   vec3f_t viewport, const list_vec3f_t *vertices,
-                   const list_scene_triangle_t *triangles) {
-  list_vec2i_t *projected = list_create_with_capacity(
-      vec2i_t, arena, vertices->count * sizeof(vec3f_t));
-  if (!projected) {
-    return;
-  }
-
-  vec3f_t vertex = {0};
-  for (u64 i = 0; i < vertices->count; ++i) {
-    vertex = list_get(vertices, i);
-    list_append(vec2i_t, arena, projected,
-                project_point(vertex, wnd, camera, viewport));
-  }
-
-  for (u64 i = 0; i < triangles->count; ++i) {
-    scene_triangle_t triangle = list_get(triangles, i);
-    triangle_t tri = {
-        .p0 = list_get(projected, triangle.idx0),
-        .p1 = list_get(projected, triangle.idx1),
-        .p2 = list_get(projected, triangle.idx2),
-        .h0 = 1.0f,
-        .h1 = 1.0f,
-        .h2 = 1.0f,
-        .colour = triangle.colour,
-    };
-    draw_wireframe_triangle(wnd, arena, tri);
-  }
-}
-
 void draw_wireframe_triangle(window_t *wnd, Arena *arena, triangle_t triangle) {
   order_triangle_points(&triangle);
 

src/scene/scene.c

@@ -1,8 +1,6 @@
 #include "scene/scene.h"
 #include "aliases.h"
 #include "misc/misc_utils.h"
-#include "vector/vec.h"
-#include "window/window.h"
 
 internal const sphere_t spheres[] = {
     (sphere_t){