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

    world->header = (ps1bsp_header_t*)bytes;
    bytes += sizeof(ps1bsp_header_t);

    world->vertices = (ps1bsp_vertex_t*)bytes;
    bytes += sizeof(ps1bsp_vertex_t) * world->header->numVertices;

    world->faceVertices = (ps1bsp_facevertex_t*)bytes;
    bytes += sizeof(ps1bsp_facevertex_t) * world->header->numFaceVertices;

    world->faces = (ps1bsp_face_t*)bytes;
    bytes += sizeof(ps1bsp_face_t) * world->header->numFaces;
}

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->header->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;
        }

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