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

merge upstream

Browse Source
This commit is contained in:
Hayden K 2019-03-13 12:17:43 -04:00
commit 61f9ff5122
9 changed files with 507 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

660
GL/draw.c
View File

@ -67,6 +67,234 @@ typedef void (*FloatParseFunc)(GLfloat* out, const GLubyte* in);
typedef void (*ByteParseFunc)(GLubyte* out, const GLubyte* in);
typedef void (*PolyBuildFunc)(ClipVertex* first, ClipVertex* previous, ClipVertex* vertex, ClipVertex* next, const GLsizei i);
static void _readVertexData3f3f(const float* input, GLuint count, GLubyte stride, float* output) {
const float* end = (float*) (((GLubyte*) input) + (count * stride));
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = input[2];
input = (float*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3us3f(const GLushort* input, GLuint count, GLubyte stride, float* output) {
const GLushort* end = (GLushort*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = input[2];
input = (GLushort*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3ui3f(const GLuint* input, GLuint count, GLubyte stride, float* output) {
const GLuint* end = (GLuint*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = input[2];
input = (GLuint*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3ub3f(const GLubyte* input, GLuint count, GLubyte stride, float* output) {
const float ONE_OVER_TWO_FIVE_FIVE = 1.0f / 255.0f;
const GLubyte* end = ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0] * ONE_OVER_TWO_FIVE_FIVE;
output[1] = input[1] * ONE_OVER_TWO_FIVE_FIVE;
output[2] = input[2] * ONE_OVER_TWO_FIVE_FIVE;
input += stride;
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2f2f(const float* input, GLuint count, GLubyte stride, float* output) {
const float* end = (float*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
input = (float*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2f3f(const float* input, GLuint count, GLubyte stride, float* output) {
const float* end = (float*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = 0.0f;
input = (float*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2ub3f(const GLubyte* input, GLuint count, GLubyte stride, float* output) {
const float ONE_OVER_TWO_FIVE_FIVE = 1.0f / 255.0f;
const GLubyte* end = ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0] * ONE_OVER_TWO_FIVE_FIVE;
output[1] = input[1] * ONE_OVER_TWO_FIVE_FIVE;
output[2] = 0.0f;
input += stride;
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2us3f(const GLushort* input, GLuint count, GLubyte stride, float* output) {
const GLushort* end = (GLushort*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = 0.0f;
input = (GLushort*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2us2f(const GLushort* input, GLuint count, GLubyte stride, float* output) {
const GLushort* end = (GLushort*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
input = (GLushort*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2ui2f(const GLuint* input, GLuint count, GLubyte stride, float* output) {
const GLuint* end = (GLuint*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
input = (GLuint*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2ub2f(const GLubyte* input, GLuint count, GLubyte stride, float* output) {
const float ONE_OVER_TWO_FIVE_FIVE = 1.0f / 255.0f;
const GLubyte* end = (GLubyte*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0] * ONE_OVER_TWO_FIVE_FIVE;
output[1] = input[1] * ONE_OVER_TWO_FIVE_FIVE;
input = (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData2ui3f(const GLuint* input, GLuint count, GLubyte stride, float* output) {
const GLuint* end = (GLuint*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[0] = input[0];
output[1] = input[1];
output[2] = 0.0f;
input = (GLuint*) (((GLubyte*) input) + stride);
output = (float*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData4ubARGB(const GLubyte* input, GLuint count, GLubyte stride, GLubyte* output) {
const GLubyte* end = ((GLubyte*) input) + (count * stride);
while(input < end) {
output[R8IDX] = input[0];
output[G8IDX] = input[1];
output[B8IDX] = input[2];
output[A8IDX] = input[3];
input = (GLubyte*) (((GLubyte*) input) + stride);
output = (GLubyte*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData4fARGB(const float* input, GLuint count, GLubyte stride, GLubyte* output) {
const float* end = (float*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[R8IDX] = (GLubyte) (input[0] * 255.0f);
output[G8IDX] = (GLubyte) (input[1] * 255.0f);
output[B8IDX] = (GLubyte) (input[2] * 255.0f);
output[A8IDX] = (GLubyte) (input[3] * 255.0f);
input = (float*) (((GLubyte*) input) + stride);
output = (GLubyte*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3fARGB(const float* input, GLuint count, GLubyte stride, GLubyte* output) {
const float* end = (float*) ((GLubyte*) input) + (count * stride);
while(input < end) {
output[R8IDX] = (GLubyte) (input[0] * 255.0f);
output[G8IDX] = (GLubyte) (input[1] * 255.0f);
output[B8IDX] = (GLubyte) (input[2] * 255.0f);
output[A8IDX] = 1.0f;
input = (float*) (((GLubyte*) input) + stride);
output = (GLubyte*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3ubARGB(const GLubyte* input, GLuint count, GLubyte stride, GLubyte* output) {
const GLubyte* end = ((GLubyte*) input) + (count * stride);
while(input < end) {
output[R8IDX] = input[0];
output[G8IDX] = input[1];
output[B8IDX] = input[2];
output[A8IDX] = 1.0f;
input = (((GLubyte*) input) + stride);
output = (GLubyte*) (((GLubyte*) output) + sizeof(ClipVertex));
}
}
static void _readVertexData3usARGB(const GLushort* input, GLuint count, GLubyte stride, GLubyte* output) {
assert(0 && "Not Implemented");
}
static void _readVertexData3uiARGB(const GLuint* input, GLuint count, GLubyte stride, GLubyte* output) {
assert(0 && "Not Implemented");
}
static void _readVertexData4usARGB(const GLushort* input, GLuint count, GLubyte stride, GLubyte* output) {
assert(0 && "Not Implemented");
}
static void _readVertexData4uiARGB(const GLuint* input, GLuint count, GLubyte stride, GLubyte* output) {
assert(0 && "Not Implemented");
}
GLuint _glGetEnabledAttributes() {
return ENABLED_VERTEX_ATTRIBUTES;
}
@ -273,13 +501,12 @@ static inline void transformNormalToEyeSpace(GLfloat* normal) {
mat_trans_normal3(normal[0], normal[1], normal[2]);
}
static inline void swapVertex(ClipVertex* v1, ClipVertex* v2) {
static ClipVertex tmp;
tmp = *v1;
*v1 = *v2;
*v2 = tmp;
}
#define swapVertex(a, b) \
do { \
ClipVertex temp = *a; \
*a = *b; \
*b = temp; \
} while(0)
static inline FloatParseFunc _calcVertexParseFunc() {
switch(VERTEX_POINTER.type) {
@ -466,7 +693,7 @@ static inline void nullFloatParseFunc(GLfloat* out, const GLubyte* in) {}
static inline void genElementsCommon(
ClipVertex* output,
const GLubyte* iptr, GLuint istride, GLenum type,
GLsizei count,
GLuint count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
@ -506,7 +733,7 @@ static inline void genElementsCommon(
static inline void genElementsTriangles(
ClipVertex* output,
GLsizei count,
GLuint count,
const GLubyte* iptr, GLuint istride, GLenum type,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
@ -530,7 +757,7 @@ static inline void genElementsTriangles(
static inline void genElementsQuads(
ClipVertex* output,
GLsizei count,
GLuint count,
const GLubyte* iptr, GLuint istride, GLenum type,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
@ -555,7 +782,7 @@ static inline void genElementsQuads(
static inline void genElementsTriangleFan(
ClipVertex* output,
GLsizei count,
GLuint count,
const GLubyte* iptr, GLuint istride, GLenum type,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
@ -595,7 +822,7 @@ static inline void genElementsTriangleFan(
static inline void genElementsTriangleStrip(
ClipVertex* output,
GLsizei count,
GLuint count,
const GLubyte* iptr, GLuint istride, GLenum type,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
@ -614,95 +841,7 @@ static inline void genElementsTriangleStrip(
output[count - 1].flags = PVR_CMD_VERTEX_EOL;
}
static inline void genArraysCommon(
ClipVertex* output,
GLsizei count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
const GLubyte* stptr, GLuint ststride,
const GLubyte* nptr, GLuint nstride,
GLboolean doTexture, GLboolean doMultitexture, GLboolean doLighting
) {
const FloatParseFunc vertexFunc = _calcVertexParseFunc();
const ByteParseFunc diffuseFunc = _calcDiffuseParseFunc();
const FloatParseFunc uvFunc = _calcUVParseFunc();
const FloatParseFunc stFunc = _calcSTParseFunc();
const FloatParseFunc normalFunc = _calcNormalParseFunc();
assert(vertexFunc);
assert(diffuseFunc);
assert(uvFunc);
assert(stFunc);
assert(normalFunc);
GLsizei i = count;
ClipVertex* vertex = output;
while(i--) {
vertex->flags = PVR_CMD_VERTEX;
vertexFunc(vertex->xyz, vptr);
vptr += vstride;
vertex++;
}
i = count;
vertex = output;
while(i--) {
diffuseFunc(vertex->bgra, cptr);
cptr += cstride;
vertex++;
}
if(doTexture) {
i = count;
vertex = output;
while(i--) {
uvFunc(vertex->uv, uvptr);
uvptr += uvstride;
vertex++;
}
}
if(doMultitexture) {
i = count;
vertex = output;
while(i--) {
stFunc(vertex->st, stptr);
stptr += ststride;
++vertex;
}
}
if(doLighting) {
i = count;
vertex = output;
while(i--) {
normalFunc(vertex->nxyz, nptr);
nptr += nstride;
++vertex;
}
}
}
static inline void genArraysTriangles(
ClipVertex* output,
GLsizei count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
const GLubyte* stptr, GLuint ststride,
const GLubyte* nptr, GLuint nstride,
GLboolean doTexture, GLboolean doMultitexture, GLboolean doLighting) {
genArraysCommon(
output, count,
vptr, vstride, cptr, cstride, uvptr, uvstride, stptr, ststride, nptr, nstride,
doTexture, doMultitexture, doLighting
);
static inline void genArraysTriangles(ClipVertex* output, GLuint count) {
GLsizei i = count;
ClipVertex* vertex = output;
for(i = 2; i < count; i += 3) {
@ -710,72 +849,30 @@ static inline void genArraysTriangles(
}
}
static void genArraysQuads(
ClipVertex* output,
GLsizei count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
const GLubyte* stptr, GLuint ststride,
const GLubyte* nptr, GLuint nstride,
GLboolean doTexture, GLboolean doMultitexture, GLboolean doLighting) {
static inline void genArraysQuads(ClipVertex* output, GLuint count) {
ClipVertex* previous;
ClipVertex* this = output + 3;
genArraysCommon(
output, count,
vptr, vstride, cptr, cstride, uvptr, uvstride, stptr, ststride, nptr, nstride,
doTexture, doMultitexture, doLighting
);
GLsizei i = 3;
for(; i < count; i += 4) {
ClipVertex* this = output + i;
ClipVertex* previous = output + (i - 1);
const ClipVertex* end = output + count;
while(this < end) {
previous = this - 1;
swapVertex(previous, this);
this->flags = PVR_CMD_VERTEX_EOL;
this += 4;
}
}
static void genArraysTriangleStrip(
ClipVertex* output,
GLsizei count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
const GLubyte* stptr, GLuint ststride,
const GLubyte* nptr, GLuint nstride,
GLboolean doTexture, GLboolean doMultitexture, GLboolean doLighting) {
genArraysCommon(
output, count,
vptr, vstride, cptr, cstride, uvptr, uvstride, stptr, ststride, nptr, nstride,
doTexture, doMultitexture, doLighting
);
static void genArraysTriangleStrip(ClipVertex* output, GLuint count) {
output[count - 1].flags = PVR_CMD_VERTEX_EOL;
}
#define MAX_POLYGON_SIZE 32
static ClipVertex buffer[MAX_POLYGON_SIZE];
static void genArraysTriangleFan(
ClipVertex* output,
GLsizei count,
const GLubyte* vptr, GLuint vstride,
const GLubyte* cptr, GLuint cstride,
const GLubyte* uvptr, GLuint uvstride,
const GLubyte* stptr, GLuint ststride,
const GLubyte* nptr, GLuint nstride,
GLboolean doTexture, GLboolean doMultitexture, GLboolean doLighting) {
static void genArraysTriangleFan(ClipVertex* output, GLuint count) {
assert(count < MAX_POLYGON_SIZE);
genArraysCommon(
output, count,
vptr, vstride, cptr, cstride, uvptr, uvstride, stptr, ststride, nptr, nstride,
doTexture, doMultitexture, doLighting
);
static ClipVertex buffer[MAX_POLYGON_SIZE];
if(count <= 3){
swapVertex(&output[1], &output[2]);
@ -806,7 +903,192 @@ static void genArraysTriangleFan(
}
}
static void generate(ClipVertex* output, const GLenum mode, const GLsizei first, const GLsizei count,
static inline void _readPositionData(const GLuint first, const GLuint count, ClipVertex* output) {
const GLubyte vstride = (VERTEX_POINTER.stride) ? VERTEX_POINTER.stride : VERTEX_POINTER.size * byte_size(VERTEX_POINTER.type);
const void* vptr = ((GLubyte*) VERTEX_POINTER.ptr + (first * vstride));
if(VERTEX_POINTER.size == 3) {
switch(VERTEX_POINTER.type) {
case GL_FLOAT:
_readVertexData3f3f(vptr, count, vstride, output[0].xyz);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData3ub3f(vptr, count, vstride, output[0].xyz);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData3us3f(vptr, count, vstride, output[0].xyz);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData3ui3f(vptr, count, vstride, output[0].xyz);
break;
default:
assert(0 && "Not Implemented");
}
} else if(VERTEX_POINTER.size == 2) {
switch(VERTEX_POINTER.type) {
case GL_FLOAT:
_readVertexData2f3f(vptr, count, vstride, output[0].xyz);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData2ub3f(vptr, count, vstride, output[0].xyz);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData2us3f(vptr, count, vstride, output[0].xyz);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData2ui3f(vptr, count, vstride, output[0].xyz);
break;
default:
assert(0 && "Not Implemented");
}
} else {
assert(0 && "Not Implemented");
}
}
static inline void _readUVData(const GLuint first, const GLuint count, ClipVertex* output) {
const GLubyte uvstride = (UV_POINTER.stride) ? UV_POINTER.stride : UV_POINTER.size * byte_size(UV_POINTER.type);
const void* uvptr = ((GLubyte*) UV_POINTER.ptr + (first * uvstride));
if(UV_POINTER.size == 2) {
switch(UV_POINTER.type) {
case GL_FLOAT:
_readVertexData2f2f(uvptr, count, uvstride, output[0].uv);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData2ub2f(uvptr, count, uvstride, output[0].uv);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData2us2f(uvptr, count, uvstride, output[0].uv);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData2ui2f(uvptr, count, uvstride, output[0].uv);
break;
default:
assert(0 && "Not Implemented");
}
} else {
assert(0 && "Not Implemented");
}
}
static inline void _readSTData(const GLuint first, const GLuint count, ClipVertex* output) {
const GLubyte ststride = (ST_POINTER.stride) ? ST_POINTER.stride : ST_POINTER.size * byte_size(ST_POINTER.type);
const void* stptr = ((GLubyte*) ST_POINTER.ptr + (first * ststride));
if(ST_POINTER.size == 2) {
switch(ST_POINTER.type) {
case GL_FLOAT:
_readVertexData2f2f(stptr, count, ststride, output[0].st);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData2ub2f(stptr, count, ststride, output[0].st);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData2us2f(stptr, count, ststride, output[0].st);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData2ui2f(stptr, count, ststride, output[0].st);
break;
default:
assert(0 && "Not Implemented");
}
} else {
assert(0 && "Not Implemented");
}
}
static inline void _readNormalData(const GLuint first, const GLuint count, ClipVertex* output) {
const GLuint nstride = (NORMAL_POINTER.stride) ? NORMAL_POINTER.stride : NORMAL_POINTER.size * byte_size(NORMAL_POINTER.type);
const void* nptr = ((GLubyte*) NORMAL_POINTER.ptr + (first * nstride));
if(NORMAL_POINTER.size == 3) {
switch(NORMAL_POINTER.type) {
case GL_FLOAT:
_readVertexData3f3f(nptr, count, nstride, output[0].nxyz);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData3ub3f(nptr, count, nstride, output[0].nxyz);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData3us3f(nptr, count, nstride, output[0].nxyz);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData3ui3f(nptr, count, nstride, output[0].nxyz);
break;
default:
assert(0 && "Not Implemented");
}
} else {
assert(0 && "Not Implemented");
}
}
static inline void _readDiffuseData(const GLuint first, const GLuint count, ClipVertex* output) {
const GLubyte cstride = (DIFFUSE_POINTER.stride) ? DIFFUSE_POINTER.stride : DIFFUSE_POINTER.size * byte_size(DIFFUSE_POINTER.type);
const void* cptr = ((GLubyte*) DIFFUSE_POINTER.ptr + (first * cstride));
if(DIFFUSE_POINTER.size == 3) {
switch(DIFFUSE_POINTER.type) {
case GL_FLOAT:
_readVertexData3fARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData3ubARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData3usARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData3uiARGB(cptr, count, cstride, output[0].bgra);
break;
default:
assert(0 && "Not Implemented");
}
} else if(DIFFUSE_POINTER.size == 4) {
switch(DIFFUSE_POINTER.type) {
case GL_FLOAT:
_readVertexData4fARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_BYTE:
case GL_UNSIGNED_BYTE:
_readVertexData4ubARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
_readVertexData4usARGB(cptr, count, cstride, output[0].bgra);
break;
case GL_INT:
case GL_UNSIGNED_INT:
_readVertexData4uiARGB(cptr, count, cstride, output[0].bgra);
break;
default:
assert(0 && "Not Implemented");
}
} else {
assert(0 && "Not Implemented");
}
}
static void generate(ClipVertex* output, const GLenum mode, const GLsizei first, const GLuint count,
const GLubyte* indices, const GLenum type, const GLboolean doTexture, const GLboolean doMultitexture, const GLboolean doLighting) {
/* Read from the client buffers and generate an array of ClipVertices */
@ -824,57 +1106,35 @@ static void generate(ClipVertex* output, const GLenum mode, const GLsizei first,
const GLsizei istride = byte_size(type);
if(!indices) {
_readPositionData(first, count, output);
_readDiffuseData(first, count, output);
if(doTexture) _readUVData(first, count, output);
if(doLighting) _readNormalData(first, count, output);
if(doTexture && doMultitexture) _readSTData(first, count, output);
ClipVertex* it = output;
const ClipVertex* end = output + count;
while(it < end) {
(it++)->flags = PVR_CMD_VERTEX;
}
// Drawing arrays
switch(mode) {
case GL_TRIANGLES:
genArraysTriangles(
output,
count,
vptr, vstride,
cptr, cstride,
uvptr, uvstride,
stptr, ststride,
nptr, nstride,
doTexture, doMultitexture, doLighting
);
genArraysTriangles(output, count);
break;
case GL_QUADS:
genArraysQuads(
output,
count,
vptr, vstride,
cptr, cstride,
uvptr, uvstride,
stptr, ststride,
nptr, nstride,
doTexture, doMultitexture, doLighting
);
genArraysQuads(output, count);
break;
case GL_POLYGON:
case GL_TRIANGLE_FAN:
genArraysTriangleFan(
output,
count,
vptr, vstride,
cptr, cstride,
uvptr, uvstride,
stptr, ststride,
nptr, nstride,
doTexture, doMultitexture, doLighting
);
genArraysTriangleFan(output, count);
break;
case GL_TRIANGLE_STRIP:
genArraysTriangleStrip(output, count);
break;
default:
genArraysTriangleStrip(
output,
count,
vptr, vstride,
cptr, cstride,
uvptr, uvstride,
stptr, ststride,
nptr, nstride,
doTexture, doMultitexture, doLighting
);
assert(0 && "Not Implemented");
}
} else if(mode == GL_TRIANGLES) {
genElementsTriangles(
@ -927,7 +1187,7 @@ static void generate(ClipVertex* output, const GLenum mode, const GLsizei first,
}
}
static void transform(ClipVertex* output, const GLsizei count) {
static void transform(ClipVertex* output, const GLuint count) {
/* Perform modelview transform, storing W */
ClipVertex* vertex = output;
@ -957,7 +1217,7 @@ static void transform(ClipVertex* output, const GLsizei count) {
}
}
static GLsizei clip(AlignedVector* polylist, uint32_t offset, const GLsizei count) {
static GLsizei clip(AlignedVector* polylist, uint32_t offset, const GLuint count) {
/* Perform clipping, generating new vertices as necessary */
clipTriangleStrip2(polylist, offset, _glGetShadeModel() == GL_FLAT);
@ -997,7 +1257,7 @@ static void mat_transform_normal3(const float* xyz, const float* xyzOut, const u
}
}
static void light(ClipVertex* output, const GLsizei count) {
static void light(ClipVertex* output, const GLuint count) {
if(!_glIsLightingEnabled()) {
return;
}
@ -1054,7 +1314,7 @@ static void light(ClipVertex* output, const GLsizei count) {
}
}
static void divide(ClipVertex* output, const GLsizei count) {
static void divide(ClipVertex* output, const GLuint count) {
/* Perform perspective divide on each vertex */
ClipVertex* vertex = output;
@ -1067,7 +1327,7 @@ static void divide(ClipVertex* output, const GLsizei count) {
}
}
static void push(PVRHeader* header, ClipVertex* output, const GLsizei count, PolyList* activePolyList, GLshort textureUnit) {
static void push(PVRHeader* header, ClipVertex* output, const GLuint count, PolyList* activePolyList, GLshort textureUnit) {
// Compile the header
pvr_poly_cxt_t cxt = *_glGetPVRContext();
cxt.list_type = activePolyList->list_type;
@ -1087,7 +1347,7 @@ static void push(PVRHeader* header, ClipVertex* output, const GLsizei count, Pol
#define DEBUG_CLIPPING 0
static void submitVertices(GLenum mode, GLsizei first, GLsizei count, GLenum type, const GLvoid* indices) {
static void submitVertices(GLenum mode, GLsizei first, GLuint count, GLenum type, const GLvoid* indices) {
/* Do nothing if vertices aren't enabled */
if(!(ENABLED_VERTEX_ATTRIBUTES & VERTEX_ENABLED_FLAG)) {
return;

13
GL/flush.c
View File

@ -78,7 +78,10 @@ void APIENTRY glFinish() {
void APIENTRY glKosInitConfig(GLdcConfig* config) {
config->autosort_enabled = GL_FALSE;
config->initial_vbuf_capacity = 1024;
config->initial_op_capacity = 1024;
config->initial_pt_capacity = 512;
config->initial_tr_capacity = 1024;
config->initial_immediate_capacity = 1024;
config->internal_palette_format = GL_RGBA4;
}
@ -91,7 +94,7 @@ void APIENTRY glKosInitEx(GLdcConfig* config) {
_glInitAttributePointers();
_glInitContext();
_glInitLights();
_glInitImmediateMode();
_glInitImmediateMode(config->initial_immediate_capacity);
_glInitFramebuffers();
_glSetInternalPaletteFormat(config->internal_palette_format);
@ -106,9 +109,9 @@ void APIENTRY glKosInitEx(GLdcConfig* config) {
aligned_vector_init(&PT_LIST.vector, sizeof(ClipVertex));
aligned_vector_init(&TR_LIST.vector, sizeof(ClipVertex));
aligned_vector_reserve(&OP_LIST.vector, config->initial_vbuf_capacity);
aligned_vector_reserve(&PT_LIST.vector, config->initial_vbuf_capacity);
aligned_vector_reserve(&TR_LIST.vector, config->initial_vbuf_capacity);
aligned_vector_reserve(&OP_LIST.vector, config->initial_op_capacity);
aligned_vector_reserve(&PT_LIST.vector, config->initial_pt_capacity);
aligned_vector_reserve(&TR_LIST.vector, config->initial_tr_capacity);
}
void APIENTRY glKosInit() {

9
GL/immediate.c
View File

@ -28,12 +28,18 @@ static GLfloat UV_COORD[2] = {0.0f, 0.0f};
static GLfloat ST_COORD[2] = {0.0f, 0.0f};
void _glInitImmediateMode() {
void _glInitImmediateMode(GLuint initial_size) {
aligned_vector_init(&VERTICES, sizeof(GLfloat));
aligned_vector_init(&COLOURS, sizeof(GLfloat));
aligned_vector_init(&UV_COORDS, sizeof(GLfloat));
aligned_vector_init(&ST_COORDS, sizeof(GLfloat));
aligned_vector_init(&NORMALS, sizeof(GLfloat));
aligned_vector_reserve(&VERTICES, initial_size);
aligned_vector_reserve(&COLOURS, initial_size);
aligned_vector_reserve(&UV_COORDS, initial_size);
aligned_vector_reserve(&ST_COORDS, initial_size);
aligned_vector_reserve(&NORMALS, initial_size);
}
GLubyte _glCheckImmediateModeInactive(const char* func) {
@ -92,6 +98,7 @@ void APIENTRY glColor3fv(const GLfloat* v) {
}
void APIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
aligned_vector_reserve(&VERTICES, VERTICES.size + 3);
aligned_vector_push_back(&VERTICES, &x, 1);
aligned_vector_push_back(&VERTICES, &y, 1);
aligned_vector_push_back(&VERTICES, &z, 1);

2
GL/lighting.c
View File

@ -230,7 +230,7 @@ void APIENTRY glColorMaterial(GLenum face, GLenum mode) {
return;
}
GLenum validModes[] = {GL_AMBIENT, GL_DIFFUSE, GL_AMBIENT_AND_DIFFUSE, GL_EMISSION, GL_SPECULAR, 0};
GLint validModes[] = {GL_AMBIENT, GL_DIFFUSE, GL_AMBIENT_AND_DIFFUSE, GL_EMISSION, GL_SPECULAR, 0};
if(_glCheckValidEnum(mode, validModes, __func__) != 0) {
return;

4
GL/private.h
View File

@ -104,7 +104,7 @@ PolyList *_glTransparentPolyList();
void _glInitAttributePointers();
void _glInitContext();
void _glInitLights();
void _glInitImmediateMode();
void _glInitImmediateMode(GLuint initial_size);
void _glInitMatrices();
void _glInitFramebuffers();
@ -131,7 +131,7 @@ typedef struct {
GLint size;
} AttribPointer;
GLboolean _glCheckValidEnum(GLenum param, GLenum* values, const char* func);
GLboolean _glCheckValidEnum(GLint param, GLint* values, const char* func);
GLuint _glGetEnabledAttributes();
AttribPointer* _glGetVertexAttribPointer();

18
GL/state.c
View File

@ -110,7 +110,7 @@ static int _calcPVRBlendFactor(GLenum factor) {
case GL_ONE:
return PVR_BLEND_ONE;
default:
fprintf(stderr, "Invalid blend mode: %d\n", factor);
fprintf(stderr, "Invalid blend mode: %u\n", (unsigned int) factor);
return PVR_BLEND_ONE;
}
}
@ -131,7 +131,7 @@ static void _updatePVRBlend(pvr_poly_cxt_t* context) {
}
}
GLboolean _glCheckValidEnum(GLenum param, GLenum* values, const char* func) {
GLboolean _glCheckValidEnum(GLint param, GLint* values, const char* func) {
GLubyte found = 0;
while(*values != 0) {
if(*values == (GLenum)param) {
@ -478,7 +478,7 @@ GLAPI void APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor) {
#define PT_ALPHA_REF 0x011c
GLAPI void APIENTRY glAlphaFunc(GLenum func, GLclampf ref) {
GLenum validFuncs[] = {
GLint validFuncs[] = {
GL_GREATER,
0
};
@ -662,20 +662,20 @@ void APIENTRY glGetIntegerv(GLenum pname, GLint *params) {
}
}
const GLbyte *glGetString(GLenum name) {
const GLubyte *glGetString(GLenum name) {
switch(name) {
case GL_VENDOR:
return "KallistiOS / Kazade";
return (const GLubyte*) "KallistiOS / Kazade";
case GL_RENDERER:
return "PowerVR2 CLX2 100mHz";
return (const GLubyte*) "PowerVR2 CLX2 100mHz";
case GL_VERSION:
return "1.2 (partial) - GLdc 1.0";
return (const GLubyte*) "1.2 (partial) - GLdc 1.0";
case GL_EXTENSIONS:
return "GL_ARB_framebuffer_object, GL_ARB_multitexture, GL_ARB_texture_rg, GL_EXT_paletted_texture, GL_EXT_shared_texture_palette, GL_KOS_multiple_shared_palette";
return (const GLubyte*) "GL_ARB_framebuffer_object, GL_ARB_multitexture, GL_ARB_texture_rg, GL_EXT_paletted_texture, GL_EXT_shared_texture_palette, GL_KOS_multiple_shared_palette";
}
return "GL_KOS_ERROR: ENUM Unsupported\n";
return (const GLubyte*) "GL_KOS_ERROR: ENUM Unsupported\n";
}

26
GL/texture.c
View File

@ -4,6 +4,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "config.h"
#include "../include/glext.h"
@ -39,11 +40,8 @@ static TexturePalette* _initTexturePalette() {
//memset(palette, 0x0, sizeof(TexturePalette));
sq_clr(palette, (sizeof(TexturePalette) & 0xfffffffc) + 4);
palette->data = NULL;
palette->format = 0;
palette->width = 0;
memset(palette, 0x0, sizeof(TexturePalette));
palette->bank = -1;
palette->size = 0;
return palette;
}
@ -225,8 +223,8 @@ GLubyte _glInitTextures() {
SHARED_PALETTES[2] = _initTexturePalette();
SHARED_PALETTES[3] = _initTexturePalette();
memset((void*)BANKS_USED,0x0,sizeof(BANKS_USED));
memset((void*) BANKS_USED, 0x0, sizeof(BANKS_USED));
memset((void*) SUBBANKS_USED, 0x0, sizeof(SUBBANKS_USED));
return 1;
}
@ -330,7 +328,7 @@ void APIENTRY glDeleteTextures(GLsizei n, GLuint *textures) {
void APIENTRY glBindTexture(GLenum target, GLuint texture) {
TRACE();
GLenum target_values [] = {GL_TEXTURE_2D, 0};
GLint target_values [] = {GL_TEXTURE_2D, 0};
if(_glCheckValidEnum(target, target_values, __func__) != 0) {
return;
@ -353,9 +351,9 @@ void APIENTRY glBindTexture(GLenum target, GLuint texture) {
void APIENTRY glTexEnvi(GLenum target, GLenum pname, GLenum param) {
TRACE();
GLenum target_values [] = {GL_TEXTURE_ENV, 0};
GLenum pname_values [] = {GL_TEXTURE_ENV_MODE, 0};
GLenum param_values [] = {GL_MODULATE, GL_DECAL, GL_REPLACE, 0};
GLint target_values [] = {GL_TEXTURE_ENV, 0};
GLint pname_values [] = {GL_TEXTURE_ENV_MODE, 0};
GLint param_values [] = {GL_MODULATE, GL_DECAL, GL_REPLACE, 0};
GLubyte failures = 0;
@ -1073,7 +1071,7 @@ void APIENTRY glTexParameterf(GLenum target, GLenum pname, GLint param) {
}
GLAPI void APIENTRY glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *data) {
GLenum validTargets[] = {
GLint validTargets[] = {
GL_TEXTURE_2D,
GL_SHARED_TEXTURE_PALETTE_EXT,
GL_SHARED_TEXTURE_PALETTE_0_KOS,
@ -1083,9 +1081,9 @@ GLAPI void APIENTRY glColorTableEXT(GLenum target, GLenum internalFormat, GLsize
0
};
GLenum validInternalFormats[] = {GL_RGB8, GL_RGBA8, 0};
GLenum validFormats[] = {GL_RGB, GL_RGBA, 0};
GLenum validTypes[] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, 0};
GLint validInternalFormats[] = {GL_RGB8, GL_RGBA8, 0};
GLint validFormats[] = {GL_RGB, GL_RGBA, 0};
GLint validTypes[] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, 0};
if(_glCheckValidEnum(target, validTargets, __func__) != 0) {
return;

6
include/gl.h
View File

@ -369,11 +369,11 @@ __BEGIN_DECLS
#define GLushort unsigned short
#define GLuint unsigned int
#define GLenum unsigned int
#define GLsizei unsigned long
#define GLsizei unsigned int
#define GLfixed const unsigned int
#define GLclampf float
#define GLubyte unsigned char
#define GLbitfield unsigned long
#define GLbitfield unsigned int
#define GLboolean unsigned char
#define GL_FALSE 0
#define GL_TRUE 1
@ -620,7 +620,7 @@ GLAPI void APIENTRY glGetBooleanv(GLenum pname, GLboolean* params);
GLAPI void APIENTRY glGetIntegerv(GLenum pname, GLint *params);
GLAPI void APIENTRY glGetFloatv(GLenum pname, GLfloat *params);
GLAPI GLboolean APIENTRY glIsEnabled(GLenum cap);
GLAPI const GLbyte* APIENTRY glGetString(GLenum name);
GLAPI const GLubyte* APIENTRY glGetString(GLenum name);
/* Error handling */
GLAPI GLenum APIENTRY glGetError(void);

5
include/glkos.h
View File

@ -46,7 +46,10 @@ typedef struct {
GLenum internal_palette_format;
/* Initial capacity of each of the OP, TR and PT lists in vertices */
GLuint initial_vbuf_capacity;
GLuint initial_op_capacity;
GLuint initial_tr_capacity;
GLuint initial_pt_capacity;
GLuint initial_immediate_capacity;
} GLdcConfig;