Draw cube using vertices and triangles lists

include/rasteriser/rasteriser.h

@@ -2,12 +2,23 @@
 #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;
@@ -24,6 +35,9 @@ 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,6 +2,7 @@
 #define SCENE_H
 
 #include "aliases.h"
+#include "vector/vec.h"
 #include "window/window.h"
 
 typedef struct {

src/rasteriser/main.c

@@ -1,8 +1,10 @@
 #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>
@@ -24,6 +26,68 @@ 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};
 
@@ -32,59 +96,13 @@ 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 capacity = 10ull * 1024ull * 1024ull * 1024ull;
-  if (!wapp_mem_arena_init(&frame_arena, capacity, WAPP_MEM_ALLOC_RESERVE,
-                           false)) {
+  u64 frame_arena_capacity = 10ull * 1024ull * 1024ull * 1024ull;
+  if (!wapp_mem_arena_init(&frame_arena, frame_arena_capacity,
+                           WAPP_MEM_ALLOC_RESERVE, 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) {
@@ -96,20 +114,7 @@ int main(void) {
 
     clear_window(&window, bg);
 
-    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);
+    render_object(&window, arena, &camera, viewport, vertices, triangles);
 
     swap_buffers(&window);
 
@@ -117,6 +122,7 @@ 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,6 +15,37 @@ 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,6 +1,8 @@
 #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){