Split face drawing off into a separate function, and made triangle fan and triangle strip available again as alternative options, for comparison.

Also using triangle fan as a special case for faces with three vertices, i.e. a simple single triangle.

world.c

@@ -38,6 +38,178 @@ void world_load(const u_long *data, world_t *world)
     bytes += sizeof(ps1bsp_face_t) * world->header->numFaces;
 }
 
+static inline void drawface_triangle_fan(const ps1bsp_face_t *face, SVECTOR *vecs)
+{
+    int p;
+
+    // Draw the face as a triangle fan
+    u_char maxVert = face->numFaceVertices - 1;
+    for (int vertIdx = 1; vertIdx < maxVert; ++vertIdx)
+    {
+        const SVECTOR *v0 = &vecs[0];
+        const SVECTOR *v1 = &vecs[vertIdx];
+        const SVECTOR *v2 = &vecs[vertIdx + 1];
+
+        // Naively draw the triangle with GTE, nothing special or optimized about this
+        gte_ldv3(v0, v1, v2);
+        gte_rtpt();     // Rotation, translation, perspective projection
+
+        // Normal clipping for backface culling
+        gte_nclip();
+        gte_stopz(&p);
+        if (p < 0)
+            continue;
+
+        // Average Z for depth sorting and culling
+        gte_avsz3();
+        gte_stotz(&p);
+        unsigned short depth = p >> 2;
+        if (depth <= 0 || depth >= OTLEN)
+            continue;
+
+        // Draw a flat-shaded untextured colored triangle
+        POLY_G3 *poly = (POLY_G3*)mem_prim(sizeof(POLY_G3));
+        if (poly == NULL)
+            break;
+
+        setPolyG3(poly);
+        gte_stsxy3_g3(poly);
+
+        poly->r0 = poly->g0 = poly->b0 = (uint8_t)v0->pad;
+        poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->pad;
+        poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->pad;
+
+        addPrim(curOT + depth, poly);
+        ++polyCount;
+    }
+}
+
+static inline void drawface_triangle_strip(const ps1bsp_face_t *face, SVECTOR *vecs)
+{
+    int p;
+
+    // Draw the face as a triangle strip
+    const SVECTOR *v0, *v1, *v2;
+    const SVECTOR *head = vecs;
+    const SVECTOR *tail = vecs + face->numFaceVertices;
+    u_char reverse = 0;
+
+    v2 = head++;    // Initialize first vertex to index 0 and set head to index 1
+
+    u_char numTris = face->numFaceVertices - 2;
+    for (u_char triIdx = 0; triIdx < numTris; ++triIdx)
+    {
+        if (reverse ^= 1)
+        {
+            v0 = v2;
+            v1 = head;
+            v2 = --tail;
+        }
+        else
+        {
+            v0 = v1;
+            v1 = ++head;
+            v2 = tail;
+        }
+
+        // Naively draw the triangle with GTE, nothing special or optimized about this
+        gte_ldv3(v0, v1, v2);
+        gte_rtpt();     // Rotation, translation, perspective projection
+
+        // Normal clipping for backface culling
+        gte_nclip();
+        gte_stopz(&p);
+        if (p < 0)
+            continue;
+
+        // Average Z for depth sorting and culling
+        gte_avsz3();
+        gte_stotz(&p);
+        unsigned short depth = p >> 2;
+        if (depth <= 0 || depth >= OTLEN)
+            continue;
+
+        // Draw a flat-shaded untextured colored triangle
+        POLY_G3 *poly = (POLY_G3*)mem_prim(sizeof(POLY_G3));
+        if (poly == NULL)
+            break;
+
+        setPolyG3(poly);
+        gte_stsxy3_g3(poly);
+
+        poly->r0 = poly->g0 = poly->b0 = (uint8_t)v0->pad;
+        poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->pad;
+        poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->pad;
+
+        addPrim(curOT + depth, poly);
+        ++polyCount;
+    }
+}
+
+static inline void drawface_quad_strip(const ps1bsp_face_t *face, SVECTOR *vecs)
+{
+    int p;
+
+    // Draw the face as a quad strip
+    const SVECTOR *v0, *v1, *v2, *v3;
+    const SVECTOR *head = vecs;
+    const SVECTOR *tail = vecs + face->numFaceVertices;
+
+    // Initialize the first two vertices
+    v2 = --tail;
+    v3 = head++;
+
+    // Normally a quad strip would have (N-2)/2 quads, but we might end up with a sole triangle at the end which will be drawn as a collapsed quad
+    u_char numQuads = (face->numFaceVertices - 1) / 2;
+    for (u_char quadIdx = 0; quadIdx < numQuads; ++quadIdx)
+    {
+        v0 = v2;
+        v1 = v3;
+        v2 = --tail;
+        v3 = head++;
+
+        // Naively draw the quad with GTE, nothing special or optimized about this
+        gte_ldv3(v0, v1, v2);
+        gte_rtpt();     // Rotation, translation, perspective projection
+
+        // Normal clipping for backface culling (TODO: should be necessary only once per face, using plane normal & camera direction)
+        gte_nclip();
+        gte_stopz(&p);
+        if (p < 0)
+            continue;
+
+        // Average Z for depth sorting and culling
+        gte_avsz3();
+        gte_stotz(&p);
+        unsigned short depth = p >> 2;
+        if (depth <= 0 || depth >= OTLEN)
+            continue;
+
+        // Draw a flat-shaded untextured colored triangle
+        POLY_G4 *poly = (POLY_G4*)mem_prim(sizeof(POLY_G4));
+        if (poly == NULL)
+            break;
+
+        setPolyG4(poly);
+        gte_stsxy0(&poly->x0);
+        gte_stsxy1(&poly->x1);
+        gte_stsxy2(&poly->x2);
+
+        // Transform the fourth vertex to complete the quad
+        gte_ldv0(v3);
+        gte_rtps();
+        gte_stsxy(&poly->x3);
+
+        poly->r0 = poly->g0 = poly->b0 = (uint8_t)v0->pad;
+        poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->pad;
+        poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->pad;
+        poly->r3 = poly->g3 = poly->b3 = (uint8_t)v3->pad;
+
+        addPrim(curOT + depth, poly);
+        ++polyCount;
+    }
+}
+
 void world_draw(const world_t *world)
 {
     int p;
@@ -63,64 +235,9 @@ void world_draw(const world_t *world)
             vecs[vertIdx].pad = vert->baseLight;
         }
 
-        // Draw the face as a quad strip
-        const SVECTOR *v0, *v1, *v2, *v3;
-        const SVECTOR *head = vecs;
-        const SVECTOR *tail = vecs + face->numFaceVertices;
-
-        // Initialize the first two vertices
-        v2 = --tail;
-        v3 = head++;
-
-        // Normally a quad strip would have (N-2)/2 quads, but we might end up with a sole triangle at the end which will be drawn as a collapsed quad
-        u_char numQuads = (face->numFaceVertices - 1) / 2;
-        for (u_char quadIdx = 0; quadIdx < numQuads; ++quadIdx)
-        {
-            v0 = v2;
-            v1 = v3;
-            v2 = --tail;
-            v3 = head++;
-
-            // Naively draw the quad with GTE, nothing special or optimized about this
-            gte_ldv3(v0, v1, v2);
-            gte_rtpt();     // Rotation, translation, perspective projection
-
-            // Normal clipping for backface culling (TODO: should be necessary only once per face, using plane normal & camera direction)
-            gte_nclip();
-            gte_stopz(&p);
-            if (p < 0)
-                continue;
-
-            // Average Z for depth sorting and culling
-            gte_avsz3();
-            gte_stotz(&p);
-            unsigned short depth = p >> 2;
-            if (depth <= 0 || depth >= OTLEN)
-                continue;
-
-            // Draw a flat-shaded untextured colored triangle
-            POLY_G4 *poly = (POLY_G4*)mem_prim(sizeof(POLY_G4));
-            if (poly == NULL)
-                break;
-
-            setPolyG4(poly);
-
-            gte_stsxy0(&poly->x0);
-            gte_stsxy1(&poly->x1);
-            gte_stsxy2(&poly->x2);
-
-            // Transform the fourth vertex to complete the quad
-            gte_ldv0(v3);
-            gte_rtps();
-            gte_stsxy(&poly->x3);
-
-            poly->r0 = poly->g0 = poly->b0 = (uint8_t)v0->pad;
-            poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->pad;
-            poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->pad;
-            poly->r3 = poly->g3 = poly->b3 = (uint8_t)v3->pad;
-
-            addPrim(curOT + depth, poly);
-            ++polyCount;
-        }
+        if (face->numFaceVertices == 3)
+            drawface_triangle_fan(face, vecs);
+        else
+            drawface_quad_strip(face, vecs);
     }
 }