ndepoel
/
ps1bsp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Moved polygon drawing routines into a separate header file

unrollquadloop
Nico de Poel 3 years ago
parent
8b34fb1950
commit
73903474e4
2 changed files with 227 additions and 220 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 226
      draw.h
  2. 221
      world.c

226
draw.h
View File

@ -0,0 +1,226 @@
#ifndef __DRAW_H__
#define __DRAW_H__
#include "common.h"
#include "display.h"
#include <inline_c.h>
static INLINE void draw_triangle_fan(SVECTOR *verts, u_char numVerts)
{
int p;
if (!mem_checkprim(sizeof(POLY_G3), numVerts - 2))
return;
// Draw the face as a triangle fan
u_char maxVert = numVerts - 1;
for (int vertIdx = 1; vertIdx < maxVert; ++vertIdx)
{
const SVECTOR *v0 = &verts[0];
const SVECTOR *v1 = &verts[vertIdx];
const SVECTOR *v2 = &verts[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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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 draw_triangle_strip(SVECTOR *verts, u_char numVerts)
{
int p;
u_char numTris = numVerts - 2;
if (!mem_checkprim(sizeof(POLY_G3), numTris))
return;
// 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
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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 draw_quad_strip(SVECTOR *verts, u_char numVerts)
{
int p;
u_char numQuads = (numVerts - 1) / 2;
if (!mem_checkprim(sizeof(POLY_G4), numQuads))
return;
// Draw the face as a quad strip
const SVECTOR *v0, *v1, *v2, *v3;
const SVECTOR *head = verts;
const SVECTOR *tail = verts + numVerts;
// 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
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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;
}
}
static INLINE void draw_quad_strip_tex(STVECTOR *verts, u_char numVerts, u_short tpage)
{
int p;
// 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) / 2;
if (!mem_checkprim(sizeof(POLY_GT4), numQuads))
return;
// Draw the face as a quad strip
const STVECTOR *v0, *v1, *v2, *v3;
const STVECTOR *head = verts;
const STVECTOR *tail = verts + numVerts;
// Initialize the first two vertices
v2 = --tail;
v3 = head++;
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
short depth = p >> 2;
if (depth <= 0 || depth >= OTLEN)
continue;
// Draw a flat-shaded untextured colored quad
POLY_GT4 *poly = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));
setPolyGT4(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);
// 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->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;
}
}
#endif // __DRAW_H__

221
world.c
View File

@ -2,8 +2,7 @@
#include "world.h" #include "world.h"
#include "display.h" #include "display.h"
#include "time.h" #include "time.h"
#include <inline_c.h>
#include "draw.h"
static CVECTOR colors[] = static CVECTOR colors[] =
{ {
@ -52,224 +51,6 @@ void world_load(const u_long *data, world_t *world)
LOAD_CHUNK(u_char, world->visData, world->numVisData, bytes, header->visData); LOAD_CHUNK(u_char, world->visData, world->numVisData, bytes, header->visData);
} }
static INLINE void draw_triangle_fan(SVECTOR *verts, u_char numVerts)
{
int p;
if (!mem_checkprim(sizeof(POLY_G3), numVerts - 2))
return;
// Draw the face as a triangle fan
u_char maxVert = numVerts - 1;
for (int vertIdx = 1; vertIdx < maxVert; ++vertIdx)
{
const SVECTOR *v0 = &verts[0];
const SVECTOR *v1 = &verts[vertIdx];
const SVECTOR *v2 = &verts[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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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 draw_triangle_strip(SVECTOR *verts, u_char numVerts)
{
int p;
u_char numTris = numVerts - 2;
if (!mem_checkprim(sizeof(POLY_G3), numTris))
return;
// 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
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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 draw_quad_strip(SVECTOR *verts, u_char numVerts)
{
int p;
u_char numQuads = (numVerts - 1) / 2;
if (!mem_checkprim(sizeof(POLY_G4), numQuads))
return;
// Draw the face as a quad strip
const SVECTOR *v0, *v1, *v2, *v3;
const SVECTOR *head = verts;
const SVECTOR *tail = verts + numVerts;
// 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
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
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));
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;
}
}
static INLINE void draw_quad_strip_tex(STVECTOR *verts, u_char numVerts, u_short tpage)
{
int p;
// 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) / 2;
if (!mem_checkprim(sizeof(POLY_GT4), numQuads))
return;
// Draw the face as a quad strip
const STVECTOR *v0, *v1, *v2, *v3;
const STVECTOR *head = verts;
const STVECTOR *tail = verts + numVerts;
// Initialize the first two vertices
v2 = --tail;
v3 = head++;
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
// Average Z for depth sorting and culling
gte_avsz3();
gte_stotz(&p);
short depth = p >> 2;
if (depth <= 0 || depth >= OTLEN)
continue;
// Draw a flat-shaded untextured colored quad
POLY_GT4 *poly = (POLY_GT4*)mem_prim(sizeof(POLY_GT4));
setPolyGT4(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);
// 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->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;
}
}
static INLINE short world_pointPlaneDist(const VECTOR *point, const ps1bsp_plane_t *plane) static INLINE short world_pointPlaneDist(const VECTOR *point, const ps1bsp_plane_t *plane)
{ {
// Make use of axis-aligned planes to skip the need for a dot product // Make use of axis-aligned planes to skip the need for a dot product

Write Preview
Loading…
Cancel
Save