ecker/GLdc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://gitlab.com/simulant/GLdc into pvr_direct

Browse Source
This commit is contained in:
Falco Girgis 2024-08-11 01:21:06 -05:00
commit 0f3be24cec
5 changed files with 86 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
GL/draw.c
View File

@ -946,35 +946,6 @@ static void light(SubmissionTarget* target) {
_glPerformLighting(vertex, ES, target->count); _glPerformLighting(vertex, ES, target->count);
} }
GL_FORCE_INLINE void divide(SubmissionTarget* target) {
TRACE();
/* Perform perspective divide on each vertex */
Vertex* vertex = _glSubmissionTargetStart(target);
const float h = GetVideoMode()->height;
ITERATE(target->count) {
const float f = MATH_Fast_Invert(vertex->w);
/* Convert to NDC and apply viewport */
vertex->xyz[0] = MATH_fmac(
VIEWPORT.hwidth, vertex->xyz[0] * f, VIEWPORT.x_plus_hwidth
);
vertex->xyz[1] = h - MATH_fmac(
VIEWPORT.hheight, vertex->xyz[1] * f, VIEWPORT.y_plus_hheight
);
/* Apply depth range */
vertex->xyz[2] = MAX(
1.0f - MATH_fmac(vertex->xyz[2] * f, 0.5f, 0.5f),
PVR_MIN_Z
);
++vertex;
}
}
GL_FORCE_INLINE int _calc_pvr_face_culling() { GL_FORCE_INLINE int _calc_pvr_face_culling() {
if(!_glIsCullingEnabled()) { if(!_glIsCullingEnabled()) {
return GPU_CULLING_SMALL; return GPU_CULLING_SMALL;

91
GL/matrix.c
View File

@ -15,13 +15,12 @@ GLfloat DEPTH_RANGE_MULTIPLIER_H = (0 + 1) / 2;
static Stack __attribute__((aligned(32))) MATRIX_STACKS[4]; // modelview, projection, texture static Stack __attribute__((aligned(32))) MATRIX_STACKS[4]; // modelview, projection, texture
static Matrix4x4 __attribute__((aligned(32))) NORMAL_MATRIX; static Matrix4x4 __attribute__((aligned(32))) NORMAL_MATRIX;
static Matrix4x4 __attribute__((aligned(32))) VIEWPORT_MATRIX;
Viewport VIEWPORT = { static Matrix4x4 __attribute__((aligned(32))) PROJECTION_MATRIX;
0, 0, 640, 480, 320.0f, 240.0f, 320.0f, 240.0f
};
static GLenum MATRIX_MODE = GL_MODELVIEW; static GLenum MATRIX_MODE = GL_MODELVIEW;
static GLubyte MATRIX_IDX = 0; static GLubyte MATRIX_IDX = 0;
static GLboolean NORMAL_DIRTY, PROJECTION_DIRTY;
static const Matrix4x4 __attribute__((aligned(32))) IDENTITY = { static const Matrix4x4 __attribute__((aligned(32))) IDENTITY = {
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
@ -94,12 +93,28 @@ static void transpose(GLfloat* m) {
swap(m[11], m[14]); swap(m[11], m[14]);
} }
static void recalculateNormalMatrix() { /* When projection matrix changes, need to pre-multiply with viewport transform matrix */
static void UpdateProjectionMatrix() {
PROJECTION_DIRTY = false;
UploadMatrix4x4(&VIEWPORT_MATRIX);
MultiplyMatrix4x4(stack_top(MATRIX_STACKS + (GL_PROJECTION & 0xF)));
DownloadMatrix4x4(&PROJECTION_MATRIX);
}
/* When modelview matrix changes, need to re-compute normal matrix */
static void UpdateNormalMatrix() {
NORMAL_DIRTY = false;
MEMCPY4(NORMAL_MATRIX, stack_top(MATRIX_STACKS + (GL_MODELVIEW & 0xF)), sizeof(Matrix4x4)); MEMCPY4(NORMAL_MATRIX, stack_top(MATRIX_STACKS + (GL_MODELVIEW & 0xF)), sizeof(Matrix4x4));
inverse((GLfloat*) NORMAL_MATRIX); inverse((GLfloat*) NORMAL_MATRIX);
transpose((GLfloat*) NORMAL_MATRIX); transpose((GLfloat*) NORMAL_MATRIX);
} }
static void OnMatrixChanged() {
if(MATRIX_MODE == GL_MODELVIEW) NORMAL_DIRTY = true;
if(MATRIX_MODE == GL_PROJECTION) PROJECTION_DIRTY = true;
}
void APIENTRY glMatrixMode(GLenum mode) { void APIENTRY glMatrixMode(GLenum mode) {
MATRIX_MODE = mode; MATRIX_MODE = mode;
MATRIX_IDX = mode & 0xF; MATRIX_IDX = mode & 0xF;
@ -111,17 +126,17 @@ void APIENTRY glPushMatrix() {
void* ret = stack_push(MATRIX_STACKS + MATRIX_IDX, top); void* ret = stack_push(MATRIX_STACKS + MATRIX_IDX, top);
(void) ret; (void) ret;
assert(ret); assert(ret);
OnMatrixChanged();
} }
void APIENTRY glPopMatrix() { void APIENTRY glPopMatrix() {
stack_pop(MATRIX_STACKS + MATRIX_IDX); stack_pop(MATRIX_STACKS + MATRIX_IDX);
if(MATRIX_MODE == GL_MODELVIEW) { OnMatrixChanged();
recalculateNormalMatrix();
}
} }
void APIENTRY glLoadIdentity() { void APIENTRY glLoadIdentity() {
stack_replace(MATRIX_STACKS + MATRIX_IDX, IDENTITY); stack_replace(MATRIX_STACKS + MATRIX_IDX, IDENTITY);
OnMatrixChanged();
} }
void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) { void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
@ -141,10 +156,7 @@ void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
assert(top); assert(top);
DownloadMatrix4x4(top); DownloadMatrix4x4(top);
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
@ -159,10 +171,7 @@ void APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z) {
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4(&scale); MultiplyMatrix4x4(&scale);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
@ -207,10 +216,7 @@ void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4((const Matrix4x4*) &rotate); MultiplyMatrix4x4((const Matrix4x4*) &rotate);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
/* Load an arbitrary matrix */ /* Load an arbitrary matrix */
@ -219,10 +225,7 @@ void APIENTRY glLoadMatrixf(const GLfloat *m) {
memcpy(TEMP, m, sizeof(float) * 16); memcpy(TEMP, m, sizeof(float) * 16);
stack_replace(MATRIX_STACKS + MATRIX_IDX, TEMP); stack_replace(MATRIX_STACKS + MATRIX_IDX, TEMP);
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
/* Ortho */ /* Ortho */
@ -248,6 +251,7 @@ void APIENTRY glOrtho(GLfloat left, GLfloat right,
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4((const Matrix4x4*) &OrthoMatrix); MultiplyMatrix4x4((const Matrix4x4*) &OrthoMatrix);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
} }
@ -279,6 +283,7 @@ void APIENTRY glFrustum(GLfloat left, GLfloat right,
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4((const Matrix4x4*) &FrustumMatrix); MultiplyMatrix4x4((const Matrix4x4*) &FrustumMatrix);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
} }
@ -290,10 +295,7 @@ void glMultMatrixf(const GLfloat *m) {
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4(&TEMP); MultiplyMatrix4x4(&TEMP);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
/* Load an arbitrary transposed matrix */ /* Load an arbitrary transposed matrix */
@ -324,10 +326,7 @@ void glLoadTransposeMatrixf(const GLfloat *m) {
TEMP[M15] = m[15]; TEMP[M15] = m[15];
stack_replace(MATRIX_STACKS + MATRIX_IDX, TEMP); stack_replace(MATRIX_STACKS + MATRIX_IDX, TEMP);
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
/* Multiply the current matrix by an arbitrary transposed matrix */ /* Multiply the current matrix by an arbitrary transposed matrix */
@ -357,22 +356,19 @@ void glMultTransposeMatrixf(const GLfloat *m) {
UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); UploadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
MultiplyMatrix4x4((const Matrix4x4*) &TEMP); MultiplyMatrix4x4((const Matrix4x4*) &TEMP);
DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX)); DownloadMatrix4x4(stack_top(MATRIX_STACKS + MATRIX_IDX));
OnMatrixChanged();
if(MATRIX_MODE == GL_MODELVIEW) {
recalculateNormalMatrix();
}
} }
/* Set the GL viewport */ /* Set the GL viewport */
void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
VIEWPORT.x = x; VIEWPORT_MATRIX[M0] = width * 0.5f;
VIEWPORT.y = y; VIEWPORT_MATRIX[M5] = height * -0.5f;
VIEWPORT.width = width; VIEWPORT_MATRIX[M10] = 1.0f;
VIEWPORT.height = height; VIEWPORT_MATRIX[M15] = 1.0f;
VIEWPORT.hwidth = ((GLfloat) VIEWPORT.width) * 0.5f;
VIEWPORT.hheight = ((GLfloat) VIEWPORT.height) * 0.5f; VIEWPORT_MATRIX[M12] = x + width * 0.5f;
VIEWPORT.x_plus_hwidth = VIEWPORT.x + VIEWPORT.hwidth; VIEWPORT_MATRIX[M13] = GetVideoMode()->height - (y + height * 0.5f);
VIEWPORT.y_plus_hheight = VIEWPORT.y + VIEWPORT.hheight; PROJECTION_DIRTY = true;
} }
/* Set the depth range */ /* Set the depth range */
@ -464,14 +460,17 @@ void _glMatrixLoadModelView() {
} }
void _glMatrixLoadProjection() { void _glMatrixLoadProjection() {
UploadMatrix4x4((const Matrix4x4*) stack_top(MATRIX_STACKS + (GL_PROJECTION & 0xF))); if (PROJECTION_DIRTY) UpdateProjectionMatrix();
UploadMatrix4x4(&PROJECTION_MATRIX);
} }
void _glMatrixLoadModelViewProjection() { void _glMatrixLoadModelViewProjection() {
UploadMatrix4x4((const Matrix4x4*) stack_top(MATRIX_STACKS + (GL_PROJECTION & 0xF))); if (PROJECTION_DIRTY) UpdateProjectionMatrix();
UploadMatrix4x4(&PROJECTION_MATRIX);
MultiplyMatrix4x4((const Matrix4x4*) stack_top(MATRIX_STACKS + (GL_MODELVIEW & 0xF))); MultiplyMatrix4x4((const Matrix4x4*) stack_top(MATRIX_STACKS + (GL_MODELVIEW & 0xF)));
} }
void _glMatrixLoadNormal() { void _glMatrixLoadNormal() {
if (NORMAL_DIRTY) UpdateNormalMatrix();
UploadMatrix4x4((const Matrix4x4*) &NORMAL_MATRIX); UploadMatrix4x4((const Matrix4x4*) &NORMAL_MATRIX);
} }

7
GL/platforms/sh4.c
View File

@ -79,9 +79,10 @@ GL_FORCE_INLINE void _glPerspectiveDivideVertex(Vertex* vertex, const float h, i
for(int v = 0; v < count; ++v) { for(int v = 0; v < count; ++v) {
const float f = _glFastInvert(vertex[v].w); const float f = _glFastInvert(vertex[v].w);
/* Convert to NDC and apply viewport */ /* Convert to screenspace */
vertex[v].xyz[0] = (vertex[v].xyz[0] * f * 320) + 320; /* (note that vertices have already been viewport transformed) */
vertex[v].xyz[1] = (vertex[v].xyz[1] * f * -240) + 240; vertex->xyz[0] *= f;
vertex->xyz[1] *= f;
/* Orthographic projections need to use invZ otherwise we lose /* Orthographic projections need to use invZ otherwise we lose
the depth information. As w == 1, and clip-space range is -w to +w the depth information. As w == 1, and clip-space range is -w to +w

80
GL/platforms/software.c
View File

@ -75,17 +75,13 @@ void SceneListBegin(GPUList list) {
vertex_counter = 0; vertex_counter = 0;
} }
GL_FORCE_INLINE void _glPerspectiveDivideVertex(Vertex* vertex, const float h) { GL_FORCE_INLINE void _glPerspectiveDivideVertex(Vertex* vertex) {
const float f = 1.0f / (vertex->w); const float f = 1.0f / (vertex->w);
/* Convert to NDC and apply viewport */ /* Convert to screenspace */
vertex->xyz[0] = __builtin_fmaf( /* (note that vertices have already been viewport transformed) */
VIEWPORT.hwidth, vertex->xyz[0] * f, VIEWPORT.x_plus_hwidth vertex->xyz[0] = vertex->xyz[0] * f;
); vertex->xyz[1] = vertex->xyz[1] * f;
vertex->xyz[1] = h - __builtin_fmaf(
VIEWPORT.hheight, vertex->xyz[1] * f, VIEWPORT.y_plus_hheight
);
if(vertex->w == 1.0f) { if(vertex->w == 1.0f) {
vertex->xyz[2] = 1.0f / (1.0001f + vertex->xyz[2]); vertex->xyz[2] = 1.0f / (1.0001f + vertex->xyz[2]);
@ -143,8 +139,6 @@ void SceneListSubmit(Vertex* v2, int n) {
return; return;
} }
const float h = GetVideoMode()->height;
uint8_t visible_mask = 0; uint8_t visible_mask = 0;
uint8_t counter = 0; uint8_t counter = 0;
@ -182,19 +176,19 @@ void SceneListSubmit(Vertex* v2, int n) {
switch(visible_mask) { switch(visible_mask) {
case 15: /* All visible, but final vertex in strip */ case 15: /* All visible, but final vertex in strip */
{ {
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glPerspectiveDivideVertex(v1, h); _glPerspectiveDivideVertex(v1);
_glPushHeaderOrVertex(v1); _glPushHeaderOrVertex(v1);
_glPerspectiveDivideVertex(v2, h); _glPerspectiveDivideVertex(v2);
_glPushHeaderOrVertex(v2); _glPushHeaderOrVertex(v2);
} }
break; break;
case 7: case 7:
/* All visible, push the first vertex and move on */ /* All visible, push the first vertex and move on */
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
break; break;
case 9: case 9:
@ -210,13 +204,13 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v2, v0, b); _glClipEdge(v2, v0, b);
b->flags = GPU_CMD_VERTEX_EOL; b->flags = GPU_CMD_VERTEX_EOL;
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
} }
break; break;
@ -233,13 +227,13 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v2, v0, b); _glClipEdge(v2, v0, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
} }
@ -262,13 +256,13 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v1, v2, b); _glClipEdge(v1, v2, b);
b->flags = v2->flags; b->flags = v2->flags;
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
} }
break; break;
@ -285,19 +279,19 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v2, v0, b); _glClipEdge(v2, v0, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glClipEdge(v1, v2, a); _glClipEdge(v1, v2, a);
a->flags = v2->flags; a->flags = v2->flags;
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
} }
@ -319,17 +313,17 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v1, v2, b); _glClipEdge(v1, v2, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
if(counter % 2 == 1) { if(counter % 2 == 1) {
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
} }
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
} }
break; break;
@ -349,15 +343,15 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v1, v2, b); _glClipEdge(v1, v2, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
c->flags = GPU_CMD_VERTEX_EOL; c->flags = GPU_CMD_VERTEX_EOL;
@ -380,15 +374,15 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v1, v2, b); _glClipEdge(v1, v2, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(v0, h); _glPerspectiveDivideVertex(v0);
_glPushHeaderOrVertex(v0); _glPushHeaderOrVertex(v0);
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
} }
@ -411,17 +405,17 @@ void SceneListSubmit(Vertex* v2, int n) {
_glClipEdge(v2, v0, b); _glClipEdge(v2, v0, b);
b->flags = GPU_CMD_VERTEX; b->flags = GPU_CMD_VERTEX;
_glPerspectiveDivideVertex(a, h); _glPerspectiveDivideVertex(a);
_glPushHeaderOrVertex(a); _glPushHeaderOrVertex(a);
_glPerspectiveDivideVertex(c, h); _glPerspectiveDivideVertex(c);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(b, h); _glPerspectiveDivideVertex(b);
_glPushHeaderOrVertex(b); _glPushHeaderOrVertex(b);
_glPushHeaderOrVertex(c); _glPushHeaderOrVertex(c);
_glPerspectiveDivideVertex(d, h); _glPerspectiveDivideVertex(d);
_glPushHeaderOrVertex(d); _glPushHeaderOrVertex(d);
} }
break; break;

14
GL/private.h
View File

@ -104,20 +104,6 @@ typedef struct {
AlignedVector vector; AlignedVector vector;
} PolyList; } PolyList;
typedef struct {
GLint x;
GLint y;
GLint width;
GLint height;
float x_plus_hwidth;
float y_plus_hheight;
float hwidth; /* width * 0.5f */
float hheight; /* height * 0.5f */
} Viewport;
extern Viewport VIEWPORT;
typedef struct { typedef struct {
/* Palette data is always stored in RAM as RGBA8888 and packed as ARGB8888 /* Palette data is always stored in RAM as RGBA8888 and packed as ARGB8888
* when uploaded to the PVR */ * when uploaded to the PVR */