Load plane, node and leaf data, and iterate through leaves to draw faces.

ps1bsp.h

@@ -33,7 +33,7 @@ typedef struct
 	ps1bsp_dentry_t faceVertices;
 	ps1bsp_dentry_t planes;
 	ps1bsp_dentry_t nodes;
-	ps1bsp_dentry_t leafs;
+	ps1bsp_dentry_t leaves;
 	ps1bsp_dentry_t leafFaces;
 } ps1bsp_header_t;
 
@@ -72,17 +72,19 @@ typedef struct
 {
 	unsigned short firstFaceVertex;
 	unsigned char numFaceVertices;
+
+	u_long drawFrame;	// Which frame was this face last drawn on? Used to check if this face should be drawn.
 } ps1bsp_face_t;
 
 typedef struct
 {
 	SVECTOR normal;
-	u_short dist;
+	short dist;
 } ps1bsp_plane_t;
 
 typedef struct
 {
-	u_int planeId;
+	int planeId;
 	u_short front;
 	u_short back;
 	// TODO: add bounding box for frustum culling

world.c

@@ -1,6 +1,7 @@
 #include "common.h"
 #include "world.h"
 #include "display.h"
+#include "time.h"
 
 #include <inline_c.h>
 
@@ -35,6 +36,18 @@ void world_load(const u_long *data, world_t *world)
 
     world->faceVertices = (ps1bsp_facevertex_t*)(bytes + header->faceVertices.offset);
     world->numFaceVertices = header->faceVertices.size / sizeof(ps1bsp_facevertex_t);
+
+    world->planes = (ps1bsp_plane_t*)(bytes + header->planes.offset);
+    world->numPlanes = header->planes.size / sizeof(ps1bsp_plane_t);
+
+    world->nodes = (ps1bsp_node_t*)(bytes + header->nodes.offset);
+    world->numNodes = header->nodes.size / sizeof(ps1bsp_node_t);
+
+    world->leaves = (ps1bsp_leaf_t*)(bytes + header->leaves.offset);
+    world->numLeaves = header->leaves.size / sizeof(ps1bsp_leaf_t);
+
+    world->leafFaces = (u_short*)(bytes + header->leafFaces.offset);
+    world->numLeafFaces = header->leafFaces.size / sizeof(u_short);
 }
 
 static INLINE void drawface_triangle_fan(const ps1bsp_face_t *face, SVECTOR *vecs)
@@ -209,21 +222,11 @@ static INLINE void drawface_quad_strip(const ps1bsp_face_t *face, SVECTOR *vecs)
     }
 }
 
-void world_draw(const world_t *world)
+static void world_drawface(const world_t *world, const ps1bsp_face_t *face, char *scratchptr)
 {
-    int p;
+    const CVECTOR *col = &colors[(u_long)face % numColors];
 
-    // The world doesn't move, so we just set the camera view-projection matrix
-    gte_SetRotMatrix(&vp_matrix);
-	gte_SetTransMatrix(&vp_matrix);
-
-    for (int faceIdx = 0; faceIdx < world->numFaces; ++faceIdx)
-    {
-        const ps1bsp_face_t *face = &world->faces[faceIdx];
-        const CVECTOR *col = &colors[faceIdx % numColors];
-
-        char *scratch = scratchpad;
-        SVECTOR *vecs = (SVECTOR*)mem_scratch(&scratch, sizeof(SVECTOR) * face->numFaceVertices);
+    SVECTOR *vecs = (SVECTOR*)mem_scratch(&scratchptr, sizeof(SVECTOR) * face->numFaceVertices);
 
     // Copy this face's vertices into scratch RAM for fast reuse
     ps1bsp_facevertex_t *faceVertex = &world->faceVertices[face->firstFaceVertex];
@@ -235,8 +238,35 @@ void world_draw(const world_t *world)
     }
 
     if (face->numFaceVertices == 3)
-            drawface_triangle_strip(face, vecs);
+        drawface_triangle_fan(face, vecs);
     else
         drawface_quad_strip(face, vecs);
+}
+
+void world_draw(const world_t *world)
+{
+    int p;
+
+    // The world doesn't move, so we just set the camera view-projection matrix
+    gte_SetRotMatrix(&vp_matrix);
+	gte_SetTransMatrix(&vp_matrix);
+
+    u_long frameNum = time_getFrameNumber();
+
+    const ps1bsp_leaf_t *leaf = &world->leaves[0];
+    for (u_short leafIdx = 0; leafIdx < world->numLeaves; ++leafIdx, ++leaf)
+    {
+        u_short *leafFace = &world->leafFaces[leaf->firstLeafFace];
+        for (u_short leafFaceIdx = 0; leafFaceIdx < leaf->numLeafFaces; ++leafFaceIdx, ++leafFace)
+        {
+            ps1bsp_face_t *face = &world->faces[*leafFace];
+
+            // Check if we've already drawn this face
+            if (face->drawFrame == frameNum)
+                continue;
+
+            world_drawface(world, face, scratchpad);
+            face->drawFrame = frameNum;
+        }
     }
 }

world.h

@@ -13,6 +13,18 @@ typedef struct
 
     u_short numFaceVertices;
     ps1bsp_facevertex_t *faceVertices;
+
+    u_short numPlanes;
+    ps1bsp_plane_t *planes;
+
+    u_short numNodes;
+    ps1bsp_node_t *nodes;
+
+    u_short numLeaves;
+    ps1bsp_leaf_t *leaves;
+
+    u_short numLeafFaces;
+    u_short *leafFaces;
 } world_t;
 
 void world_load(const u_long *data, world_t *world);