ps1bsp/draw.h

#ifndef __DRAW_H__
#define __DRAW_H__

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

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->light;
        poly->r1 = poly->g1 = poly->b1 = (uint8_t)v1->light;
        poly->r2 = poly->g2 = poly->b2 = (uint8_t)v2->light;
        poly->r3 = poly->g3 = poly->b3 = (uint8_t)v3->light;

        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)
{
    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
    // 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;
    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 gouraud shaded textured quad
        POLY_GT4 *poly = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));
        setPolyGT4(poly);
        gte_stsxy3_gt3(poly);

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

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

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

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

static INLINE void draw_quadstrip_water(const ps1bsp_vertex_t *vertices, const ps1bsp_polyvertex_t *polyVerts, u_char numVerts, u_short tpage, 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));
        setPolyFT4(poly);
        setSemiTrans(poly, 1);
        gte_stsxy3_ft3(poly);

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

        // Texture UVs
        setUV4(poly, v0->u, v0->v, v1->u, v1->v, v2->u, v2->v, v3->u, v3->v);
        poly->clut = water_clut;
        poly->tpage = tpage;

        // Unlit
        poly->r0 = poly->g0 = poly->b0 = 255;

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

#endif  // __DRAW_H__