ps1bsp/world.c

#include "common.h"
#include "world.h"
#include "display.h"

#include <inline_c.h>

static CVECTOR colors[] = 
{
    { 255, 0, 0 },
    { 0, 255, 0 },
    { 0, 0, 255 },
    { 255, 255, 0 },
    { 255, 0, 255 },
    { 0, 255, 255 },
    { 128, 255, 0 },
    { 255, 128, 0 },
    { 128, 0, 255 },
    { 255, 0, 128 },
    { 0, 128, 255 },
    { 0, 255, 128 },
};
static const int numColors = sizeof(colors) / sizeof(CVECTOR);

void world_load(const u_long *data, world_t *world)
{
    const char *bytes = (const char*)data;

    ps1bsp_header_t* header = (ps1bsp_header_t*)bytes;

    world->vertices = (ps1bsp_vertex_t*)(bytes + header->vertices.offset);
    world->numVertices = header->vertices.size / sizeof(ps1bsp_vertex_t);

    world->faces = (ps1bsp_face_t*)(bytes + header->faces.offset);
    world->numFaces = header->faces.size / sizeof(ps1bsp_face_t);

    world->faceVertices = (ps1bsp_facevertex_t*)(bytes + header->faceVertices.offset);
    world->numFaceVertices = header->faceVertices.size / sizeof(ps1bsp_facevertex_t);
}

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 quad
        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;

    // 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);

        // Copy this face's vertices into scratch RAM for fast reuse
        ps1bsp_facevertex_t *faceVertex = &world->faceVertices[face->firstFaceVertex];
        for (int vertIdx = 0; vertIdx < face->numFaceVertices; ++vertIdx, ++faceVertex)
        {
            const ps1bsp_vertex_t *vert = &world->vertices[faceVertex->index];
            vecs[vertIdx] = *((SVECTOR*)vert);
            vecs[vertIdx].pad = vert->baseLight;
        }

        if (face->numFaceVertices == 3)
            drawface_triangle_strip(face, vecs);
        else
            drawface_quad_strip(face, vecs);
    }
}