ps1bsp/draw.h

#ifndef __DRAW_H__
#define __DRAW_H__

#include "common.h"
#include "display.h"
#include <inline_c.h>

// Macros for quickly blitting RGB and UV values with a single copy
// This is faster than copying each value individually
#define setColorFast(pr, r)         *((u_int*)(pr)) = *((u_int*)(r))
#define setUVFast(pu, u)            *((u_short*)(pu)) = *((u_short*)(u))

static u_int color_white = ((255 << 16) | (255 << 8) | 255);

static INLINE void draw_triangle_lit(SVECTOR *verts, u_long *ot)
{
    // Draw a single triangle
    const SVECTOR *v0 = &verts[0];
    const SVECTOR *v1 = &verts[1];
    const SVECTOR *v2 = &verts[2];

    // Naively draw the triangle with GTE, nothing special or optimized about this
    gte_ldv3(v0, v1, v2);
    gte_rtpt();     // Rotation, translation, perspective projection

    // Draw a flat-shaded untextured colored triangle
    POLY_G3 *poly = (POLY_G3*)mem_prim(sizeof(POLY_G3));
    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(ot, poly);
    ++polyCount;
}

static INLINE void draw_trianglestrip_lit(SVECTOR *verts, u_char numVerts, u_long *ot)
{
    // Draw the face as a triangle strip
    const SVECTOR *v0, *v1, *v2;
    const SVECTOR *head = verts;
    const SVECTOR *tail = verts + numVerts;
    u_char reverse = 0;

    v2 = head++;    // Initialize first vertex to index 0 and set head to index 1

    u_char numTris = numVerts - 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

        // Draw a flat-shaded untextured colored triangle
        POLY_G3 *poly = (POLY_G3*)mem_prim(sizeof(POLY_G3));
        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(ot, poly);
        ++polyCount;
    }
}

static INLINE void draw_quadstrip_lit(const ps1bsp_vertex_t *vertices, const ps1bsp_polyvertex_t *polyVerts, u_char numVerts, u_long *ot)
{
    const ps1bsp_polyvertex_t *v0, *v1, *v2, *v3;
    u_char i0, i1, i2, i3;
    u_char head = 0;
    u_char tail = numVerts;

    // Initialize the first two vertices
    i2 = --tail;
    i3 = 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 = (numVerts - 1) >> 1;
    for (u_char quadIdx = 0; quadIdx < numQuads; ++quadIdx)
    {
        i0 = i2;
        i1 = i3;
        i2 = --tail;
        i3 = head++;

        v0 = &polyVerts[i0];
        v1 = &polyVerts[i1];
        v2 = &polyVerts[i2];
        v3 = &polyVerts[i3];

        // Transform the first three vertices
        gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
        gte_rtpt();     // Rotation, translation, perspective projection

        // Draw a flat-shaded untextured colored quad
        POLY_G4 *poly = (POLY_G4*)mem_prim(sizeof(POLY_G4));
        setPolyG4(poly);
        gte_stsxy3_g3(poly);

        // Transform the fourth vertex to complete the quad
        gte_ldv0(&vertices[v3->index]);
        gte_rtps();
        gte_stsxy(&poly->x3);

        poly->r0 = poly->g0 = poly->b0 = (uint8_t)v0->r;
        poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->r;
        poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->r;
        poly->r3 = poly->g3 = poly->b3 = (uint8_t)v3->r;

        addPrim(ot, poly);
        ++polyCount;
    }
}

static INLINE void draw_quadstrip_colored(const ps1bsp_vertex_t *vertices, const ps1bsp_facevertex_t *faceVerts, u_char numVerts, u_long *ot)
{
    const ps1bsp_facevertex_t *v0, *v1, *v2, *v3;
    u_char i0, i1, i2, i3;
    u_char head = 0;
    u_char tail = numVerts;

    // Initialize the first two vertices
    i2 = --tail;
    i3 = 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 = (numVerts - 1) >> 1;
    for (u_char quadIdx = 0; quadIdx < numQuads; ++quadIdx)
    {
        i0 = i2;
        i1 = i3;
        i2 = --tail;
        i3 = head++;

        v0 = &faceVerts[i0];
        v1 = &faceVerts[i1];
        v2 = &faceVerts[i2];
        v3 = &faceVerts[i3];

        // Transform the first three vertices
        gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
        gte_rtpt();     // Rotation, translation, perspective projection

        // Draw a flat-shaded untextured colored quad
        POLY_G4 *poly = (POLY_G4*)mem_prim(sizeof(POLY_G4));
        setPolyG4(poly);
        gte_stsxy3_g3(poly);

        // Transform the fourth vertex to complete the quad
        gte_ldv0(&vertices[v3->index]);
        gte_rtps();
        gte_stsxy(&poly->x3);

        poly->r0 = v0->r << 3; poly->g0 = v0->g << 3; poly->b0 = v0->b << 3;
        poly->r1 = v1->r << 3; poly->g1 = v1->g << 3; poly->b1 = v1->b << 3;
        poly->r2 = v2->r << 3; poly->g2 = v2->g << 3; poly->b2 = v2->b << 3;
        poly->r3 = v3->r << 3; poly->g3 = v3->g << 3; poly->b3 = v3->b << 3;

        addPrim(ot, poly);
        ++polyCount;
    }
}

static INLINE void draw_triangle_textured(STVECTOR *verts, u_short tpage, u_long *ot)
{
    // Draw a single textured triangle
    const STVECTOR *v0 = &verts[0];
    const STVECTOR *v1 = &verts[1];
    const STVECTOR *v2 = &verts[2];

    // Naively draw the triangle with GTE, nothing special or optimized about this
    gte_ldv3(v0, v1, v2);
    gte_rtpt();     // Rotation, translation, perspective projection

    // Draw a gouraud shaded textured triangle
    POLY_GT3 *poly = (POLY_GT3*)mem_prim(sizeof(POLY_GT3));
    setPolyGT3(poly);
    gte_stsxy3_gt3(poly);

    // Texture UVs
    setUV3(poly, v0->u, v0->v, v1->u, v1->v, v2->u, v2->v);
    poly->clut = quake_clut;
    poly->tpage = tpage;

    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(ot, poly);
    ++polyCount;
}

static INLINE void draw_quadstrip_textured(const ps1bsp_vertex_t *vertices, const ps1bsp_polyvertex_t *polyVerts, u_char numVerts, u_short tpage, u_long *ot)
{
    POLY_GT4 *p0, *p1, *p2;
    const ps1bsp_polyvertex_t *v0, *v1, *v2;
    u_char head = 0;
    u_char tail = numVerts;

    // Initialize the first vertices
    v0 = &polyVerts[head++];
    v1 = &polyVerts[--tail];
    v2 = &polyVerts[head++];

    // Transform the first three vertices
    gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
    gte_rtpt();

    // 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
    // NOTE: testing has shown that the PS1 is faster just rendering quads and accepting the odd collapsed quad, rather than being clever with pointer comparisons and drawing a single triangle at the end.
    u_char numQuads = (numVerts - 1) >> 1;
    u_char quadIdx = 0;
    for (;;)
    {
        if (quadIdx++ == numQuads)
            return;

        // Draw a gouraud shaded textured quad
        p0 = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));

        // Fill out the quad's data fields in struct order, to optimize data access
        // First vertex and texture CLUT
        setColorFast(&p0->r0, &v0->r);
        setUVFast(&p0->u0, &v0->u);
        gte_stsxy0(&p0->x0);
        p0->clut = quake_clut;

        // Second vertex and texture page
        setColorFast(&p0->r1, &v1->r);
        gte_stsxy1(&p0->x1);
        setUVFast(&p0->u1, &v1->u);
        p0->tpage = tpage;

        // Third vertex
        setColorFast(&p0->r2, &v2->r);
        gte_stsxy2(&p0->x2);
        setUVFast(&p0->u2, &v2->u);

        if (quadIdx++ == numQuads)
        {
            v0 = &polyVerts[--tail];

            // Transform the fourth vertex to complete the quad
            gte_ldv0(&vertices[v0->index]);
            gte_rtps();

            // Fourth vertex
            setColorFast(&p0->r3, &v0->r);
            setUVFast(&p0->u3, &v0->u);
            gte_stsxy(&p0->x3);

            // Finalize the quad
            setPolyGT4(p0);
            addPrim(ot, p0);
            ++polyCount;
            return;
        }

        // Start the second quad, sharing two vertices with the first quad
        p1 = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));
        setColorFast(&p1->r0, &v2->r);
        gte_stsxy2(&p1->x0);
        setUVFast(&p1->u0, &v2->u);
        p1->clut = quake_clut;

        // Transform the next three vertices
        v0 = &polyVerts[--tail];
        v1 = &polyVerts[head++];
        v2 = &polyVerts[--tail];

        gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
        gte_rtpt();

        // Fourth vertex of the first quad
        setColorFast(&p0->r3, &v0->r);
        setUVFast(&p0->u3, &v0->u);
        gte_stsxy0(&p0->x3);

        // Finalize the first quad
        setPolyGT4(p0);
        addPrim(ot, p0);
        ++polyCount;

        // Second vertex of the second quad
        setColorFast(&p1->r1, &v0->r);
        setUVFast(&p1->u1, &v0->u);
        gte_stsxy0(&p1->x1);
        p1->tpage = tpage;

        // Third vertex
        setColorFast(&p1->r2, &v1->r);
        gte_stsxy1(&p1->x2);
        setUVFast(&p1->u2, &v1->u);

        // Fourth vertex
        setColorFast(&p1->r3, &v2->r);
        gte_stsxy2(&p1->x3);
        setUVFast(&p1->u3, &v2->u);

        // Finalize the second quad
        setPolyGT4(p1);
        addPrim(ot, p1);
        ++polyCount;

        if (quadIdx++ == numQuads)
            return;

        // Start the third quad, sharing two vertices with the second quad and two with the next quad
        p2 = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));
        setColorFast(&p2->r0, &v1->r);
        gte_stsxy1(&p2->x0);
        setUVFast(&p2->u0, &v1->u);
        p2->clut = quake_clut;

        // Second vertex and texture page
        setColorFast(&p2->r1, &v2->r);
        setUVFast(&p2->u1, &v2->u);
        gte_stsxy2(&p2->x1);
        p2->tpage = tpage;

        // Transform the next three vertices
        v0 = &polyVerts[head++];
        v1 = &polyVerts[--tail];
        v2 = &polyVerts[head++];

        gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
        gte_rtpt();

        // Third vertex
        setColorFast(&p2->r2, &v0->r);
        gte_stsxy0(&p2->x2);
        setUVFast(&p2->u2, &v0->u);

        // Fourth vertex
        setColorFast(&p2->r3, &v1->r);
        gte_stsxy1(&p2->x3);
        setUVFast(&p2->u3, &v1->u);

        // Finalize the second quad
        setPolyGT4(p2);
        addPrim(ot, p2);
        ++polyCount;
    }
}

static INLINE void draw_quadstrip_water(const ps1bsp_vertex_t *vertices, const ps1bsp_polyvertex_t *polyVerts, u_char numVerts, u_short tpage, u_char semiTrans, u_long *ot)
{
    // Draw the face as a quad strip
    const ps1bsp_polyvertex_t *v0, *v1, *v2, *v3;
    u_char i0, i1, i2, i3;
    u_char head = 0;
    u_char tail = numVerts;

    // Initialize the first two vertices
    i2 = --tail;
    i3 = 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 = (numVerts - 1) >> 1;
    for (u_char quadIdx = 0; quadIdx < numQuads; ++quadIdx)
    {
        i0 = i2;
        i1 = i3;
        i2 = --tail;
        i3 = head++;

        v0 = &polyVerts[i0];
        v1 = &polyVerts[i1];
        v2 = &polyVerts[i2];
        v3 = &polyVerts[i3];

        // Transform the first three vertices
        gte_ldv3(&vertices[v0->index], &vertices[v1->index], &vertices[v2->index]);
        gte_rtpt();     // Rotation, translation, perspective projection

        // Draw a flat-shaded textured quad
        POLY_FT4 *poly = (POLY_FT4*)mem_prim(sizeof(POLY_FT4));
        
        // Fill out the quad's data fields in struct order, to optimize data access
        // First vertex and texture CLUT
        setColorFast(&poly->r0, &color_white);
        setUVFast(&poly->u0, &v0->u);
        gte_stsxy0(&poly->x0);
        poly->clut = water_clut;

        // Second vertex and texture page
        setUVFast(&poly->u1, &v1->u);
        poly->tpage = tpage;
        gte_stsxy1(&poly->x1);

        // Third vertex
        setUVFast(&poly->u2, &v2->u);
        gte_stsxy2(&poly->x2);

        // Transform the fourth vertex to complete the quad
        gte_ldv0(&vertices[v3->index]);
        gte_rtps();

        // Fourth vertex
        setUVFast(&poly->u3, &v3->u);
        gte_stsxy(&poly->x3);

        setPolyFT4(poly);
        poly->code |= 2 * !!semiTrans;
        addPrim(ot, poly);
        ++polyCount;
    }
}

#endif  // __DRAW_H__