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

#Initial Commit for new Open GL API, replacing the old KGL

Browse Source
This commit is contained in:
U-PH3NOM-PC\PH3NOM 2014-08-16 11:09:37 -07:00
parent efe60e2ccd
commit 5c5a0196c5
18 changed files with 567 additions and 3390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Makefile
View File

@ -1,13 +1,16 @@
# KallistiOS ##version##
#
# addons/libgl Makefile
# (c)2001 Dan Potter
# kos-ports/libgl Makefile
# Copyright (C) 2013, 2014 Josh Pearson
# Copyright (C) 2014 Lawrence Sebald
TARGET = libgl.a
OBJS = gldepth.o gldraw.o glkos.o gllight.o glmisc.o
OBJS += gltex.o gltrans.o glvars.o glblend.o glfog.o glmodifier.o glnzclip.o
OBJS = gl-rgb.o gl-fog.o gl-sh4-light.o gl-light.o gl-clip.o gl-pvr.o
OBJS += gl-arrays.o gl-matrix.o gl-api.o
SUBDIRS =
KOS_CFLAGS += -ffast-math -O3 -Iinclude
defaultall: create_kos_link $(OBJS) subdirs linklib
include $(KOS_BASE)/addons/Makefile.prefab

77
glblend.c
View File

@ -1,77 +0,0 @@
/* KallistiGL for KOS ##version##
glblend.c
(c)2002 Benoit Miller
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
/* Blending */
void glBlendFunc(GLenum sfactor, GLenum dfactor) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(sfactor) {
case GL_ZERO:
gl_blend_src = PVR_BLEND_ZERO;
break;
case GL_ONE:
gl_blend_src = PVR_BLEND_ONE;
break;
case GL_DST_COLOR:
gl_blend_src = PVR_BLEND_DESTCOLOR;
break;
case GL_ONE_MINUS_DST_COLOR:
gl_blend_src = PVR_BLEND_INVDESTCOLOR;
break;
case GL_SRC_ALPHA:
gl_blend_src = PVR_BLEND_SRCALPHA;
break;
case GL_ONE_MINUS_SRC_ALPHA:
gl_blend_src = PVR_BLEND_INVSRCALPHA;
break;
case GL_DST_ALPHA:
gl_blend_src = PVR_BLEND_DESTALPHA;
break;
case GL_ONE_MINUS_DST_ALPHA:
gl_blend_src = PVR_BLEND_INVDESTALPHA;
break;
default:
assert_msg(0, "Invalid source blending function.");
}
switch(dfactor) {
case GL_ZERO:
gl_blend_dst = PVR_BLEND_ZERO;
break;
case GL_ONE:
gl_blend_dst = PVR_BLEND_ONE;
break;
case GL_SRC_COLOR:
gl_blend_dst = PVR_BLEND_DESTCOLOR;
break;
case GL_ONE_MINUS_SRC_COLOR:
gl_blend_dst = PVR_BLEND_INVDESTCOLOR;
break;
case GL_SRC_ALPHA:
gl_blend_dst = PVR_BLEND_SRCALPHA;
break;
case GL_ONE_MINUS_SRC_ALPHA:
gl_blend_dst = PVR_BLEND_INVSRCALPHA;
break;
case GL_DST_ALPHA:
gl_blend_dst = PVR_BLEND_DESTALPHA;
break;
case GL_ONE_MINUS_DST_ALPHA:
gl_blend_dst = PVR_BLEND_INVDESTALPHA;
break;
default:
assert_msg(0, "Invalid destination blending function");
}
gl_pbuf_submitted = GL_FALSE;
}

96
glclip.h
View File

@ -1,96 +0,0 @@
/* KallistiGL for KOS ##version##
Near Z Clipper
(c) Trilinear
Trilinear@hotmail.com
*/
#ifndef __GLCLIP_H
#define __GLCLIP_H
#include <GL/gl.h>
#include "glinternal.h"
#define MAXZ 0.0001f /* if z is negative, it is behind the camera */
inline void CopyV(gl_vertex_t *vertold, gl_vertex_t *vertnew) {
/* memcpy(vertnew, vertold, sizeof(gl_vertex_t)); */
vertnew->flags = vertold->flags;
vertnew->x = vertold->x;
vertnew->y = vertold->y;
vertnew->z = vertold->z;
vertnew->w = vertold->w;
vertnew->u = vertold->u;
vertnew->v = vertold->v;
vertnew->argb = vertold->argb;
vertnew->oargb = vertold->oargb;
}
inline void FindZ(gl_vertex_t *vertnew, gl_vertex_t *vert1, gl_vertex_t *vert2) {
float diffz;
/* z is indp variable because we know it changes, thus no div 0 error */
vertnew->z = gl_frustum.znear;
vertnew->w = vert1->w + (gl_frustum.znear-vert1->z)*(vert1->w - vert2->w)/(vert1->z - vert2->z);
vertnew->x = vert1->x + (gl_frustum.znear-vert1->z)*(vert1->x - vert2->x)/(vert1->z - vert2->z);
vertnew->y = vert1->y + (gl_frustum.znear-vert1->z)*(vert1->y - vert2->y)/(vert1->z - vert2->z);
diffz = (vert1->z-vertnew->z)/(vert1->z-vert2->z);
vertnew->u = (diffz)*vert2->u + (1.0f-diffz)*vert1->u;
vertnew->v = (diffz)*vert2->v + (1.0f-diffz)*vert1->v;
}
inline int ZClipTex(gl_vertex_t *vert)
/* returns 0 for full clip, 3 for triangle output and 4 for quad output
based on sutherland-hodgeman clip algorithm */
{
int i,j;
gl_vertex_t tempvert[4];
if (vert[0].z < gl_frustum.znear || vert[1].z < gl_frustum.znear || vert[2].z < gl_frustum.znear) {/* one or more parts behind camera */
j=0;
CopyV(&vert[0],&vert[3]);/* copy first to next after last to make cyclic */
for(i=0; i<3; i++) {
if (vert[i].z >= gl_frustum.znear && vert[i+1].z >= gl_frustum.znear) { /* both in */
CopyV(&vert[i],&tempvert[j]);
j++;
}else if (vert[i].z < gl_frustum.znear && vert[i+1].z >= gl_frustum.znear) {/* this out, next in */
CopyV(&vert[i],&tempvert[j]);
FindZ(&tempvert[j],&vert[i],&vert[i+1]);
j++;
}else if (vert[i].z >= gl_frustum.znear && vert[i+1].z < gl_frustum.znear) {/* this in, next out */
CopyV(&vert[i],&tempvert[j]);
CopyV(&vert[i+1],&tempvert[j+1]);
FindZ(&tempvert[j+1],&vert[i],&vert[i+1]);
j+=2;
}/* both out, ignore */
}
switch (j) {
case 3:
CopyV(&tempvert[0],&vert[0]);
CopyV(&tempvert[1],&vert[1]);
CopyV(&tempvert[2],&vert[2]);
return 3;
case 4:
CopyV(&tempvert[0],&vert[0]);
CopyV(&tempvert[1],&vert[1]);
CopyV(&tempvert[2],&vert[3]);
CopyV(&tempvert[3],&vert[2]);
return 4;
}/* if j==0 we return 0 which we are about to do anyway */
}else{/* is all in front of camera */
return 3;
}
return 0;/* if it isn't one of the above it is an invalid poly or completely behind camera */
}
#endif /* __GLCLIP_H */

72
gldepth.c
View File

@ -1,72 +0,0 @@
/* KallistiGL for KOS ##version##
gldepth.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
#include <stdio.h>
/* Depth buffer (non-functional, just stubs) */
void glClearDepth(GLclampd depth) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
}
void glDepthFunc(GLenum func) {
/* Note regarding the mapping of OpenGL depth stuff to the PVR2DC:
The depth compare modes should be "conceptually" the same except
for two points:
1) You have a floating point "Depth buffer" and
2) DC uses 1/W to compare so 1 (or higher if your clipping
is off!) = near and 0=infinity.
Therefore > or >= is probably what you want for closer objects to be visible. - Simon Fenney
*/
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(func)
{
case GL_ALWAYS:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_ALWAYS;
break;
case GL_LESS:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_GEQUAL;
break;
case GL_NOTEQUAL:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_NOTEQUAL;
break;
case GL_LEQUAL:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_GREATER;
break;
case GL_GREATER:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_LEQUAL;
break;
case GL_EQUAL:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_EQUAL;
break;
case GL_GEQUAL:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_LESS;
break;
case GL_NEVER:
gl_poly_cxt.depth.comparison = PVR_DEPTHCMP_NEVER;
break;
default:
assert_msg(0, "Invalid depth comparison function.");
}
gl_pbuf_submitted = GL_FALSE;
}
void glDepthMask(GLboolean flag) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
if (flag) {
gl_poly_cxt.depth.write = PVR_DEPTHWRITE_ENABLE;
} else {
gl_poly_cxt.depth.write = PVR_DEPTHWRITE_DISABLE;
}
gl_pbuf_submitted = GL_FALSE;
}

663
gldraw.c
View File

@ -1,663 +0,0 @@
/* KallistiGL for KOS ##version##
gldraw.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
#include <string.h>
#include <malloc.h>
#include <dc/pvr.h>
/* internal prototypes */
static void send_user_clip();
/* Drawing functions */
/* This portion of the pipeline will change drastically */
/* Current vertex attributes (move to global?) */
static GLuint vert_rgba = 0xffffffff;
static GLfloat vert_u = 0.0f, vert_v = 0.0f;
/* Make sure the proper matrices are in the matrix registers */
static void fix_matrices() {
if (gl_matrix_dirty) {
mat_identity();
glKosMatrixApply(GL_KOS_SCREENVIEW);
glKosMatrixApply(GL_PROJECTION);
glKosMatrixApply(GL_MODELVIEW);
gl_matrix_dirty = GL_FALSE;
}
}
/* Negative 1/w values annoy the pvr, so check for them */
static inline int check_w(gl_vertex_t *vert, int n) {
int i;
for(i=0; i<n; i++)
if (vert[i].z < 0) return 0;
return 1;
}
static short xor[2][2] ={
{1,0}, /* FFCW, FFCCW */
{0,1} /* BFCW, BFCCW */
};
/* GL_POINTS always visible! */
static void end_points() {
int i;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
float size1 = (xor[(gl_cull_mode == GL_BACK)][(gl_front_face == GL_CCW)]) ?
gl_point_size : -gl_point_size;
float size2 = ABS(size1);
pvr_dr_init(dr_state);
/* Should be one point in the buffer */
assert_msg(gl_vbuf_top >= 1, "Need at least one point.");
/* create a point using a quad */
memcpy(&gl_vbuf[1], &gl_vbuf[0], sizeof(gl_vertex_t));
memcpy(&gl_vbuf[2], &gl_vbuf[0], sizeof(gl_vertex_t));
memcpy(&gl_vbuf[3], &gl_vbuf[0], sizeof(gl_vertex_t));
gl_vbuf[3].flags = PVR_CMD_VERTEX_EOL;
mat_transform((vector_t*)&gl_vbuf[0].x, (vector_t*)&gl_xbuf[0].x, 4, sizeof(gl_vertex_t));
gl_xbuf[0].x += size1;
gl_xbuf[0].y += size2;
gl_xbuf[1].x += size1;
gl_xbuf[1].y -= size2;
gl_xbuf[2].x -= size1;
gl_xbuf[2].y += size2;
gl_xbuf[3].x -= size1;
gl_xbuf[3].y -= size2;
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, 4))
for (i=0; i<4; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
}
}
static void end_triangles() {
int i;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be three points in the buffer */
assert_msg(gl_vbuf_top == 3, "Wrong number of vertices.");
gl_vbuf[2].flags = PVR_CMD_VERTEX_EOL;
/* mat_transform((vector_t*)&gl_vbuf[0].x, (vector_t*)&gl_xbuf[0].x, 3,
sizeof(gl_vertex_t)); */
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, 3))
for (i=0; i<3; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
}
}
static void end_triangle_fan() {
int i;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be at least 3 points in the buffer */
assert_msg(gl_vbuf_top >= 3, "Need at least three vertices.");
gl_vbuf[0].flags = PVR_CMD_VERTEX_EOL;
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, gl_vbuf_top))
for (i=1; i<gl_vbuf_top-1; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i+1].flags;
vert->x = gl_xbuf[i+1].x;
vert->y = gl_xbuf[i+1].y;
vert->z = gl_xbuf[i+1].z;
vert->u = gl_vbuf[i+1].u;
vert->v = gl_vbuf[i+1].v;
vert->argb = gl_vbuf[i+1].argb;
vert->oargb = gl_vbuf[i+1].oargb;
pvr_dr_commit(vert);
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[0].flags;
vert->x = gl_xbuf[0].x;
vert->y = gl_xbuf[0].y;
vert->z = gl_xbuf[0].z;
vert->u = gl_vbuf[0].u;
vert->v = gl_vbuf[0].v;
vert->argb = gl_vbuf[0].argb;
vert->oargb = gl_vbuf[0].oargb;
pvr_dr_commit(vert);
}
}
static void end_triangle_strip() {
int i;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be at least 3 points in the buffer */
assert_msg(gl_vbuf_top >= 3, "Need at least three vertices.");
gl_vbuf[gl_vbuf_top-1].flags = PVR_CMD_VERTEX_EOL;
/* mat_transform((vector_t*)&gl_vbuf[0].x, (vector_t*)&gl_xbuf[0].x,
gl_vbuf_top, sizeof(gl_vertex_t)); */
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, gl_vbuf_top))
for (i=0; i<gl_vbuf_top; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
}
}
static void end_quads() {
int i, j, order[4] = {3, 0, 2, 1};
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be four points in the buffer */
assert_msg(gl_vbuf_top == 4, "Wrong number of vertices.");
gl_vbuf[order[3]].flags = PVR_CMD_VERTEX_EOL;
/* mat_transform((vector_t*)&gl_vbuf[0].x, (vector_t*)&gl_xbuf[0].x, 4,
sizeof(gl_vertex_t)); */
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, 4))
for (i=0; i<4; i++) {
j = order[i];
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[j].flags;
vert->x = gl_xbuf[j].x;
vert->y = gl_xbuf[j].y;
vert->z = gl_xbuf[j].z;
vert->u = gl_vbuf[j].u;
vert->v = gl_vbuf[j].v;
vert->argb = gl_vbuf[j].argb;
vert->oargb = gl_vbuf[j].oargb;
pvr_dr_commit(vert);
}
}
static void end_quad_strip() {
int i;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be at least 4 points in the buffer */
assert_msg(gl_vbuf_top >= 4, "Need at least four vertices.");
/* OpenGL specs that any dangling vertex be chopped, which
we have to do since we're rendering as a tri-strip. */
if(gl_vbuf_top & 0x0001)
gl_vbuf_top--;
gl_vbuf[gl_vbuf_top-1].flags = PVR_CMD_VERTEX_EOL;
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, gl_vbuf_top))
for (i=0; i<gl_vbuf_top; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
}
}
static void end_polygon() {
int i, j_frn, j_bck;
volatile pvr_vertex_t *vert;
gl_vertex_t *gl_tvbuf;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be at least 3 points in the buffer */
assert_msg(gl_vbuf_top >= 3, "Need at least three vertices.");
/* Have to alter linear vertex order to staggered Triangle strip order
performance will suffer, but it does on all cards. */
gl_tvbuf = malloc(sizeof(gl_vertex_t) * (gl_vbuf_top));
assert_msg(gl_tvbuf != NULL, "Not enough memory for GL_POLYGON");
gl_tvbuf[0] = gl_vbuf[0];
gl_tvbuf[1] = gl_vbuf[1];
i = 2; /* the first 2 vertices are in proper order. */
j_frn = i;
j_bck = gl_vbuf_top - 1;
do {
gl_tvbuf[i++] = gl_vbuf[j_bck]; /* move data */
if (i < gl_vbuf_top) {
gl_tvbuf[i++] = gl_vbuf[j_frn];
j_frn++;
j_bck--;
}
} while (i < gl_vbuf_top);
memcpy(gl_vbuf, gl_tvbuf, sizeof(gl_vertex_t) * gl_vbuf_top);
free(gl_tvbuf);
gl_vbuf[gl_vbuf_top-1].flags = PVR_CMD_VERTEX_EOL;
for (i=0; i<gl_vbuf_top; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, gl_vbuf_top))
for (i=0; i<gl_vbuf_top; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_vbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_vbuf[i].u;
vert->v = gl_vbuf[i].v;
vert->argb = gl_vbuf[i].argb;
vert->oargb = gl_vbuf[i].oargb;
pvr_dr_commit(vert);
}
}
static void check_end() {
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
end_points();
gl_vbuf_top = 0;
break;
case GL_TRIANGLES:
if (gl_vbuf_top == 3) {
end_triangles();
gl_vbuf_top = 0;
}
break;
case GL_TRIANGLE_STRIP:
break;
case GL_TRIANGLE_FAN:
break;
case GL_QUADS:
if (gl_vbuf_top == 4) {
end_quads();
gl_vbuf_top = 0;
}
break;
case GL_QUAD_STRIP:
break;
case GL_POLYGON:
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
}
static pvr_poly_hdr_t polyhdr;
void send_poly_hdr(void) {
if (TXR_ENABLED) {
memcpy(&gl_poly_cxt.txr, &gl_cur_texture->txr, sizeof(gl_poly_cxt.txr));
}
switch(gl_active_list) {
case GL_LIST_OPAQUE_POLY:
gl_poly_cxt.gen.alpha = PVR_ALPHA_DISABLE;
gl_poly_cxt.txr.alpha = PVR_TXRALPHA_ENABLE;
gl_poly_cxt.blend.src = PVR_BLEND_ONE;
gl_poly_cxt.blend.dst = PVR_BLEND_ZERO;
break;
case GL_LIST_OPAQUE_MOD:
break;
case GL_LIST_TRANS_POLY:
case GL_LIST_PUNCHTHRU:
gl_poly_cxt.gen.alpha = PVR_ALPHA_ENABLE;
gl_poly_cxt.txr.alpha = PVR_TXRALPHA_ENABLE;
gl_poly_cxt.blend.src = gl_blend_src;
gl_poly_cxt.blend.dst = gl_blend_dst;
break;
case GL_LIST_TRANS_MOD:
break;
}
/* Set states that we couldn't before */
if (gl_cull_face)
{
if (gl_cull_mode == GL_BACK)
if (gl_front_face == GL_CW)
gl_poly_cxt.gen.culling = PVR_CULLING_CCW;
else
gl_poly_cxt.gen.culling = PVR_CULLING_CW;
else
if (gl_front_face == GL_CCW)
gl_poly_cxt.gen.culling = PVR_CULLING_CCW;
else
gl_poly_cxt.gen.culling = PVR_CULLING_CW;
} else
gl_poly_cxt.gen.culling = PVR_CULLING_NONE;
pvr_poly_compile(&polyhdr, &gl_poly_cxt);
pvr_prim(&polyhdr, sizeof(pvr_poly_hdr_t));
}
/* This can be used for KGL Direct Rendering */
void glKosPolyHdrSend() {
send_poly_hdr();
}
void glBegin(GLenum mode) {
/* Submit the user clip rectangle (if necessary) */
if (gl_scissor_dirty) {
send_user_clip();
gl_scissor_dirty = GL_FALSE;
}
/* Submit the poly buffer (if necessary) */
if (!gl_pbuf_submitted) {
send_poly_hdr();
gl_pbuf_submitted = GL_TRUE;
}
if (ZCLIP_ENABLED || LIGHTING_ENABLED)
fix_vfzclip_matrices();
else
fix_matrices();
gl_prim_type = mode;
gl_vbuf_top = 0;
}
void glEnd(void) {
if (MODIFIER_ENABLED) {
modifier_end();
return;
} else if (ZCLIP_ENABLED || LIGHTING_ENABLED) {
vfzclip_end();
return;
}
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
break;
case GL_TRIANGLES:
break;
case GL_TRIANGLE_STRIP:
end_triangle_strip();
break;
case GL_TRIANGLE_FAN:
end_triangle_fan();
break;
case GL_QUADS:
break;
case GL_QUAD_STRIP:
end_quad_strip();
break;
case GL_POLYGON:
end_polygon();
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
gl_prim_type = 0;
}
static float autouv[4][2] = {
{0.0f, 0.0f},
{1.0f, 0.0f},
{1.0f, 1.0f},
{0.0f, 1.0f}
};
void glVertex2f(GLfloat x, GLfloat y) {
glVertex3f(x, y, (GLfloat)0.0f);
}
void glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
gl_vbuf[gl_vbuf_top].flags = PVR_CMD_VERTEX;
gl_vbuf[gl_vbuf_top].x = x;
gl_vbuf[gl_vbuf_top].y = y;
gl_vbuf[gl_vbuf_top].z = z;
gl_vbuf[gl_vbuf_top].w = 1.0f;
if (AUTOUV_ENABLED) {
vert_u = autouv[gl_vbuf_top][0];
vert_v = autouv[gl_vbuf_top][1];
}
gl_vbuf[gl_vbuf_top].u = vert_u;
gl_vbuf[gl_vbuf_top].v = vert_v;
gl_vbuf[gl_vbuf_top].argb = vert_rgba;
gl_vbuf[gl_vbuf_top].oargb = 0xff000000;
gl_vbuf_top++;
assert_msg(gl_vbuf_top < VBUF_SIZE, "Vertex buffer overflow");
if (MODIFIER_ENABLED)
modifier_check_end();
else if (ZCLIP_ENABLED || LIGHTING_ENABLED)
vfzclip_check_end();
else
check_end();
}
void glVertex3fv(GLfloat *v) {
glVertex3f(*v, *(v+1), *(v+2));
}
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
}
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
vert_rgba = (alpha << 24) | (red << 16) | (green << 8) | blue;
}
void glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
vert_rgba = (0xff << 24) |
((uint32)(red * 0xff) << 16) |
((uint32)(green * 0xff) << 8) |
((uint32)(blue * 0xff));
}
void glColor3fv(GLfloat *v) {
glColor3f(*v, *(v+1), *(v+2));
}
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
vert_rgba = ((uint32)(alpha * 0xff) << 24) |
((uint32)(red * 0xff) << 16) |
((uint32)(green * 0xff) << 8) |
((uint32)(blue * 0xff));
}
void glColor4fv(GLfloat *v) {
glColor4f(*v, *(v+1), *(v+2), *(v+3));
}
void glTexCoord2f(GLfloat s, GLfloat t) {
vert_u = s;
vert_v = t;
}
void glTexCoord2fv(GLfloat *v) {
vert_u = *v;
vert_v = *(v+1);
}
static pvr_poly_hdr_t user_clip = {
PVR_CMD_USERCLIP, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000
};
static void send_user_clip() {
pvr_prim(&user_clip, sizeof(pvr_poly_hdr_t));
}
/* Setup the hardware user clip rectangle. It will be sent during glBegin.
The minimum clip rectangle is a 32x32 area which is dependent on the tile
size use by the tile accelerator. The PVR swithes off rendering to tiles
outside or inside the defined rectangle dependant upon the 'clipmode'
bits
in the polygon header.
Clip rectangles therefore must have a size that is some multiple of 32.
glScissor(0, 0, 32, 32) allows only the 'tile' in the lower left
hand corner of the screen to be modified and glScissor(0, 0, 0, 0)
disallows modification to all 'tiles' on the screen.
*/
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
GLint minx, miny, maxx, maxy;
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
assert((width >= 0) && (height >= 0));
gl_scissor_x = x;
gl_scissor_y = y;
gl_scissor_width = CLAMP(width, 0, gl_screen_width);
gl_scissor_height = CLAMP(height, 0, gl_screen_height);
minx = gl_scissor_x;
/* force the origin to the lower left-hand corner of the screen */
miny = /**/(gl_screen_height - gl_scissor_height) - /**/ gl_scissor_y;
maxx = (gl_scissor_width + minx);
maxy = (gl_scissor_height + miny);
/* load command structure while mapping screen coords to TA tiles */
user_clip.d1 = CLAMP(minx/32, 0, gl_screen_width/32);
user_clip.d2 = CLAMP(miny/32, 0, gl_screen_height/32);
user_clip.d3 = CLAMP((maxx/32)-1, 0, gl_screen_width/32);
user_clip.d4 = CLAMP((maxy/32)-1, 0, gl_screen_height/32);
gl_scissor_dirty = GL_TRUE;
gl_pbuf_submitted = GL_FALSE;
}

178
glfog.c
View File

@ -1,178 +0,0 @@
/* KallistiGL for KOS ##version##
glfog.c
(c)2002 Paul Boese
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include <assert.h>
#include <dc/pvr.h>
#define TEST_EQ_4V(a,b) ((a)[0] == (b)[0] && \
(a)[1] == (b)[1] && \
(a)[2] == (b)[2] && \
(a)[3] == (b)[3])
/* Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0] */
#define INT_TO_FLOAT(I) ((2.0F * (I) + 1.0F) * (1.0F/4294967294.0F))
/* prototypes */
void Fogfv( GLenum pname, const GLfloat *params );
void DCFogfv( GLenum pname, const GLfloat *params );
/* functions */
void glFogf(GLenum pname, GLfloat param)
{
glFogfv(pname, &param);
}
void glFogi(GLenum pname, GLint param )
{
GLfloat fparam = (GLfloat) param;
glFogfv(pname, &fparam);
}
void glFogiv(GLenum pname, const GLint *params )
{
GLfloat p[4];
switch (pname) {
case GL_FOG_MODE:
case GL_FOG_DENSITY:
case GL_FOG_START:
case GL_FOG_END:
case GL_FOG_INDEX:
p[0] = (GLfloat) *params;
break;
case GL_FOG_COLOR:
p[0] = INT_TO_FLOAT( params[0] );
p[1] = INT_TO_FLOAT( params[1] );
p[2] = INT_TO_FLOAT( params[2] );
p[3] = INT_TO_FLOAT( params[3] );
break;
default:
/* Error will be caught later in Fogfv */
;
}
glFogfv(pname, p);
}
void glFogfv( GLenum pname, const GLfloat *params )
{
GLenum m;
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch (pname) {
case GL_FOG_MODE:
m = (GLenum) (GLint) *params;
switch (m) {
case GL_LINEAR:
case GL_EXP:
case GL_EXP2:
break;
default:
assert_msg(0, "Unknown fog mode.");
return;
}
if (gl_fog_mode == m)
return;
/* flush vertices here */
gl_fog_mode = m;
break;
case GL_FOG_DENSITY:
if (*params<0.0) {
assert_msg(0, "Invalid value - fog density < zero.");
return;
}
if (gl_fog_density == *params)
return;
/* flush vertices here */
gl_fog_density = *params;
break;
case GL_FOG_START:
if (gl_fog_start == *params)
return;
/* flush vertices here */
gl_fog_start = *params;
break;
case GL_FOG_END:
if (gl_fog_end == *params)
return;
/* flush vertices here */
gl_fog_end = *params;
break;
case GL_FOG_INDEX:
if (gl_fog_index == *params)
return;
/* flush vertices here */
gl_fog_index = *params;
break;
case GL_FOG_COLOR:
if (TEST_EQ_4V(gl_fog_color, params))
return;
/* flush vertices here */
gl_fog_color[0] = params[0];
gl_fog_color[1] = params[1];
gl_fog_color[2] = params[2];
gl_fog_color[3] = params[3];
break;
default:
assert_msg(0, "Invalid parameter.");
return;
}
DCFogfv( pname, params );
}
/* DC specific interface for fog */
void fog_table_color4fv(GLfloat *v) {
pvr_fog_table_color(*(v+3), *v, *(v+1), *(v+2));
}
/* void fog_set_vertex_color4fv(GLfloat *v) {
pvr_fog_vertex_color(*(v+3), *v, *(v+1), *(v+2));
} */
void DCFogfv( GLenum pname, const GLfloat *params ) {
/* Just drop thru here and setup DC registers using dcutils fog.
**
** Future Note:
** We should have a GL_KOS_FOG_TYPE enum that will give the user
** a choice of GL_KOS_FOG_TABLE, GL_KOS_FOG_VERTEX, and maybe
** GL_KOS_FOG_TABLE2
*/
switch (pname) {
case GL_FOG_START:
case GL_FOG_END:
pvr_fog_far_depth(gl_fog_end);
case GL_FOG_INDEX:
case GL_FOG_DENSITY:
case GL_FOG_COLOR:
fog_table_color4fv(gl_fog_color);
/* fog_set_vertex_color4fv(gl_fog_color); */
case GL_FOG_MODE:
switch (gl_fog_mode) {
case GL_EXP:
pvr_fog_table_exp(gl_fog_density);
break;
case GL_EXP2:
pvr_fog_table_exp2(gl_fog_density);
break;
case GL_LINEAR:
pvr_fog_table_linear(gl_fog_start, gl_fog_end);
break;
}
default:
;
}
}

165
glinternal.h
View File

@ -1,165 +0,0 @@
/* KallistiGL for KOS ##version##
glinternal.c
(c)2001 Dan Potter
*/
#ifndef __GL_GLINTERNAL_H
#define __GL_GLINTERNAL_H
/* Implementation details; not to be used externally */
#include <GL/gl.h>
#include <dc/pvr.h>
#include <dc/matrix.h>
/* AFAIK, the PowerVR simulates a 32bit depth buffer */
#define DEPTHBUFFER_MAX ((GLfloat)0xffffffff)
/* "Clear color" -- really the background plane color */
extern GLfloat gl_clear_color[4];
/* Capability mask (for glEnable() and glDisable()) */
extern GLbitfield gl_capabilities;
/* Enabled lists (PVR specific) */
extern GLbitfield gl_enabled_lists;
/* Current primitive type (GL_TRIANGLES, etc) */
extern GLenum gl_prim_type;
/* Current polygon context */
extern pvr_poly_cxt_t gl_poly_cxt;
/* Poly header buffer submitted? */
extern GLboolean gl_pbuf_submitted;
/* Current Blend functions */
extern GLint gl_blend_src;
extern GLint gl_blend_dst;
/* Currently selected texture header */
extern pvr_poly_cxt_t *gl_cur_texture;
/* a "null" texture header for colored polys */
extern pvr_poly_cxt_t gl_null_texture;
/* Depth range */
extern GLclampf gl_depthrange_near;
extern GLclampf gl_depthrange_far;
/* Screen size */
extern GLsizei gl_screen_width;
extern GLsizei gl_screen_height;
/* Viewport size */
extern GLint gl_viewport_x1, gl_viewport_y1,
gl_viewport_width, gl_viewport_height;
/* Viewport mapping */
extern GLfloat gl_viewport_scale[3];
extern GLfloat gl_viewport_offset[3];
/* Scissor clipping */
extern GLint gl_scissor_x;
extern GLint gl_scissor_y;
extern GLsizei gl_scissor_width;
extern GLsizei gl_scissor_height;
extern GLboolean gl_scissor_dirty;
/* Transformation matrices; possibilities are:
GL_MODELVIEW
GL_PROJECTION
GL_TEXTURE
*/
extern matrix_t gl_trans_mats[GL_MATRIX_COUNT] __attribute__((aligned(32)));
extern int gl_matrix_mode;
extern GLboolean gl_matrix_dirty;
/* Frustum attributes */
typedef struct {
float left, right, bottom, top, znear, zfar;
} gl_frustum_t;
extern gl_frustum_t gl_frustum;
/* Some happy macros */
#define TXR_ENABLED (gl_capabilities & GL_TEXTURE_2D)
#define AUTOUV_ENABLED (gl_capabilities & GL_KOS_AUTO_UV)
#define FOG_ENABLED (gl_capabilities & GL_FOG)
#define BLEND_ENABLED (gl_capabilities & GL_BLEND)
#define SCISSOR_ENABLED (gl_capabilities & GL_SCISSOR_TEST)
#define USERCLIP_OUTSIDE_ENABLED (gl_capabilities & GL_KOS_USERCLIP_OUTSIDE)
#define MODIFIER_ENABLED (gl_capabilities & GL_KOS_MODIFIER)
#define CHEAP_SHADOW_ENABLED (gl_capabilities & GL_KOS_CHEAP_SHADOW)
#define ZCLIP_ENABLED (gl_capabilities & GL_KOS_NEARZ_CLIPPING)
#define LIGHTING_ENABLED (gl_capabilities & GL_LIGHT0)
/* Currently active list */
extern GLbitfield gl_active_list;
/* Face culling enabled/disabled */
extern GLboolean gl_cull_face;
/* Front face */
extern GLenum gl_front_face;
/* Culling mode */
extern GLenum gl_cull_mode;
/* Fog Attributes */
extern GLfloat gl_fog_color[4];
extern GLfloat gl_fog_density;
extern GLfloat gl_fog_start;
extern GLfloat gl_fog_end;
extern GLfloat gl_fog_index; /* unused */
extern GLenum gl_fog_mode;
/* Point size */
extern GLfloat gl_point_size;
/* Vertex buffers
It is important to align the vertex buffers for use with the
the direct render API. I found 8192 gave the best results, but 32,
64, and 1024 also worked well. To see cache thrashing in action try
setting the alignment to 16384 or 32768. The polys per second will
drop by about half.
mat_transform seems to work best when the source and destination buffers
are seperate. Therefore we have a pre and post transform vertex buffer
I'm quite aware of how wasteful this is. It's a simple matter that this
is how you have to treat the PVR to get decent poly drawing rates.
What's needed is a way to collect long vertex [Strips, Fans, Polygons]
and blast them to the store queue every 16 to 32 verts all the while
maintaining the proper PVR_CMD_VERTEX and ...EOL requirements. One
way might be to keep a copy of the last vertex submitted and toss
it to the PVR in the glEnd statement. You will have to keep track of
verts whose z values go < 0 and either clip them to the view frustum or
cull them entirely. But you'll have to do this carefully because the PVR
does not like degenerate triangles or strips. */
typedef struct {
uint32 flags;
float x, y, z, w;
float u, v;
uint32 argb, oargb;
} gl_vertex_t;
#define VBUF_SIZE 128
/* Pre-xformed vertex buffer */
extern gl_vertex_t gl_vbuf[VBUF_SIZE] __attribute__((aligned(8192)));
/* Post-xformed vertex buffer */
extern gl_vertex_t gl_xbuf[VBUF_SIZE] __attribute__((aligned(8192)));
extern int gl_vbuf_top;
/* some internal prototypes */
extern void modifier_check_end();
extern void modifier_end();
extern void fix_vfzclip_matrices();
extern void vfzclip_check_end();
extern void vfzclip_end();
#endif /* __GL_GLINTERNAL_H */

210
glkos.c
View File

@ -1,210 +0,0 @@
/* KallistiGL for KOS ##version##
glkos.c
(c)2001 Dan Potter
*/
#include <stdio.h>
#include <string.h>
#include <dc/video.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
/* KOS-specific APIs */
int glKosInit() {
GLfloat w, h;
static pvr_stats_t pvr_stats;
if (pvr_get_stats(&pvr_stats)) {
dbglog(DBG_ERROR, "gl: glKosInit - No PVR lists enabled!");
return -1;
}
/* Pre-initialize all the globals */
gl_clear_color[0] =
gl_clear_color[1] =
gl_clear_color[2] =
gl_clear_color[3] = 0.0f;
gl_capabilities = 0;
gl_prim_type = 0;
gl_pbuf_submitted = GL_FALSE;
gl_enabled_lists = pvr_stats.enabled_list_mask | GL_LIST_END;
gl_active_list = GL_LIST_NONE;
/* Reset all matrices */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
/* Setup the basic polygon context */
pvr_poly_cxt_col(&gl_poly_cxt, PVR_LIST_OP_POLY);
/* Adjust context for GL conformance */
gl_poly_cxt.gen.culling = PVR_CULLING_NONE;
/* Make a NULL Texture */
pvr_poly_cxt_col(&gl_null_texture, PVR_LIST_OP_POLY);
gl_cur_texture = &gl_null_texture;
glKosGetScreenSize(&w, &h);
/* The screen w & h is used internally by some functions */
gl_screen_width = (GLsizei)w; gl_screen_height = (GLsizei)h;
/* Initialize the viewport */
glDepthRange(0.0f, 1.0f);
glViewport(0, 0, (GLsizei)w, (GLsizei)h);
/* Initialize the scissor test rectangle */
glScissor(0, 0, (GLsizei)w, (GLsizei)h);
/* Initialize fog */
glFogi(GL_FOG_MODE, GL_EXP);
return 0;
}
void glKosShutdown() {
}
void glKosGetScreenSize(GLfloat *w, GLfloat *h) {
*w = vid_mode->width;
*h = vid_mode->height;
}
static void _gl_list_begin(uint32 list) {
pvr_list_begin(list);
gl_poly_cxt.list_type = list;
}
void glKosBeginFrame() {
uint32 tmp_list;
pvr_wait_ready();
pvr_scene_begin();
gl_pbuf_submitted = GL_FALSE;
gl_active_list = GL_LIST_FIRST;
/* we can't assume GL_LIST_OPAQUE_POLY is the first enabled list
anymore! Advance to the first enabled list if opaque list is
not first already. */
tmp_list = gl_active_list;
if (!(gl_active_list&gl_enabled_lists)) {
do {
tmp_list = gl_active_list = (gl_active_list << 1);
tmp_list &= gl_enabled_lists;
} while(tmp_list==0);
}
switch(gl_active_list) {
case GL_LIST_OPAQUE_POLY:
_gl_list_begin(PVR_LIST_OP_POLY);
break;
case GL_LIST_OPAQUE_MOD:
_gl_list_begin(PVR_LIST_OP_MOD);
break;
case GL_LIST_TRANS_POLY:
_gl_list_begin(PVR_LIST_TR_POLY);
break;
case GL_LIST_TRANS_MOD:
_gl_list_begin(PVR_LIST_TR_MOD);
break;
case GL_LIST_PUNCHTHRU:
_gl_list_begin(PVR_LIST_PT_POLY);
break;
case GL_LIST_END:
/* no lists were enabled!?! */
dbglog(DBG_ERROR, "gl: no lists enabled in glKosBeginFrame!");
/* this is probably a bailout condition! */
break;
}
}
void glKosFinishFrame() {
while (gl_active_list != GL_LIST_NONE)
glKosFinishList();
pvr_scene_finish();
}
void glKosFinishList() {
uint32 tmp_list;
if (gl_active_list == GL_LIST_NONE)
return;
pvr_list_finish();
/* Advance to the next list */
tmp_list = gl_active_list;
do {
tmp_list = gl_active_list = (gl_active_list << 1);
tmp_list &= gl_enabled_lists;
} while(tmp_list==0);
switch(gl_active_list) {
case GL_LIST_OPAQUE_MOD:
_gl_list_begin(PVR_LIST_OP_MOD);
break;
case GL_LIST_TRANS_POLY:
_gl_list_begin(PVR_LIST_TR_POLY);
break;
case GL_LIST_TRANS_MOD:
_gl_list_begin(PVR_LIST_TR_MOD);
break;
case GL_LIST_PUNCHTHRU:
_gl_list_begin(PVR_LIST_PT_POLY);
break;
case GL_LIST_END:
gl_active_list = GL_LIST_NONE;
}
/* We haven't submitted the new poly headers */
gl_pbuf_submitted = GL_FALSE;
}
/* This can be used for KGL Direct Rendering: applies one of the GL
matrices to the matrix registers and lets you do whatever you
want after that. */
static matrix_t msv __attribute__((aligned(32))) = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
void glKosMatrixApply(GLenum mode) {
gl_matrix_dirty = GL_TRUE;
if (mode < GL_KOS_SCREENVIEW) {
mat_apply(gl_trans_mats + mode);
} else {
msv[0][0] = gl_viewport_scale[0];
msv[1][1] = -gl_viewport_scale[1];
msv[3][0] = gl_viewport_offset[0];
msv[3][1] = gl_screen_height - gl_viewport_offset[1];
mat_apply(&msv);
}
}
/* A matrix clear function, for completeness */
void glKosMatrixIdent() {
gl_matrix_dirty = GL_TRUE;
mat_identity();
}
/* Tell KGL that the poly header is dirty again (i.e., you did something
manually that it doesn't know about) */
void glKosPolyHdrDirty() {
gl_pbuf_submitted = GL_FALSE;
}
/* Tell KGL that the matrix registers are dirty (i.e., you did something
manually that it doesn't know about). Note that this does not include
the above functions because those already take this step. */
void glKosMatrixDirty() {
gl_matrix_dirty = GL_TRUE;
}

27
gllight.c
View File

@ -1,27 +0,0 @@
/* KallistiGL for KOS ##version##
gllight.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include "assert.h"
/* Lighting */
void glShadeModel(GLenum mode) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(mode)
{
case GL_FLAT:
gl_poly_cxt.gen.shading = PVR_SHADE_FLAT;
break;
case GL_SMOOTH:
gl_poly_cxt.gen.shading = PVR_SHADE_GOURAUD;
break;
}
}

19
glmacros.h
View File

@ -1,19 +0,0 @@
/* GL for KOS ##version##
glmacros.c
(c)2001 Paul Boese
*/
#ifndef __GL_GLMACROS_H
#define __GL_GLMACROS_H
#define ABS(n) ( (n)<(0.0f) ? (-n):(n) )
#define NEG(n) ( (n)>(0.0f) ? (-n):(n) )
#define CLAMP01(x) ( (x)<(0.0f) ? ((0.0f)) : ((x)>(1.0f) ? ((1.0f)) : (x)) )
/* Clamp X to [MIN,MAX]: */
#define CLAMP( X, MIN, MAX ) ( (X)<(MIN) ? (MIN) : ((X)>(MAX) ? (MAX) : (X)) )
#endif /* __GL_GLMACROS_H */

230
glmisc.c
View File

@ -1,230 +0,0 @@
/* KallistiGL for KOS ##version##
glmisc.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
/* Miscellaneous APIs */
/* Set the background clear color */
void glClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
GLclampf alpha) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
gl_clear_color[0] = CLAMP01(red);
gl_clear_color[1] = CLAMP01(green);
gl_clear_color[2] = CLAMP01(blue);
gl_clear_color[3] = CLAMP01(alpha);
pvr_set_bg_color(gl_clear_color[0]*gl_clear_color[3],
gl_clear_color[1]*gl_clear_color[3],
gl_clear_color[2]*gl_clear_color[3]);
}
/* NOP: there's nothing to clear on the PVR2 */
void glClear(GLbitfield mask) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
}
/* Set front face */
void glFrontFace(GLenum mode) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(mode) {
case GL_CW:
case GL_CCW:
gl_front_face = mode;
gl_pbuf_submitted = GL_FALSE;
break;
}
}
/* Set face culling mode */
void glCullFace(GLenum mode) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(mode) {
case GL_FRONT:
case GL_BACK:
gl_cull_mode = mode;
gl_pbuf_submitted = GL_FALSE;
break;
}
}
/* Enable / disable capabilities */
void glEnable(GLenum cap) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(cap) {
case GL_TEXTURE_2D:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.txr.enable = PVR_TEXTURE_ENABLE;
break;
case GL_BLEND:
if (gl_active_list != GL_LIST_TRANS_POLY) {
dbglog(DBG_ERROR, "gl: invalid list to enable GL_BLEND inside");
return;
}
break;
case GL_CULL_FACE:
gl_pbuf_submitted = GL_FALSE;
gl_cull_face = GL_TRUE;
break;
case GL_FOG:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.fog_type = PVR_FOG_TABLE;
break;
case GL_SCISSOR_TEST:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.clip_mode = PVR_USERCLIP_INSIDE;
if (USERCLIP_OUTSIDE_ENABLED)
gl_capabilities &= ~((GLbitfield)GL_KOS_USERCLIP_OUTSIDE);
break;
case GL_KOS_USERCLIP_OUTSIDE:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.clip_mode = PVR_USERCLIP_OUTSIDE;
if (SCISSOR_ENABLED)
gl_capabilities &= ~((GLbitfield)GL_SCISSOR_TEST);
break;
case GL_KOS_MODIFIER:
assert_msg(0, "GL_KOS_MODIFER not implemented");
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.fmt.modifier = PVR_MODIFIER_ENABLE;
break;
case GL_KOS_CHEAP_SHADOW:
assert_msg(0, "GL_KOS_CHEAP_SHADOW not implemented");
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.modifier_mode = PVR_MODIFIER_CHEAP_SHADOW;
break;
case GL_KOS_NEARZ_CLIPPING:
gl_matrix_dirty = GL_TRUE;
break;
case GL_LIGHT0:
assert_msg(0, "GL_LIGHTi not implemented");
break;
}
gl_capabilities |= (GLbitfield)cap;
}
void glDisable(GLenum cap) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(cap) {
case GL_TEXTURE_2D:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.txr.enable = PVR_TEXTURE_DISABLE;
break;
case GL_BLEND:
if (gl_active_list == GL_LIST_TRANS_POLY) {
dbglog(DBG_ERROR, "gl: invalid list to disable GL_BLEND inside");
return;
}
break;
case GL_CULL_FACE:
gl_pbuf_submitted = GL_FALSE;
gl_cull_face = GL_FALSE;
break;
case GL_FOG:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.fog_type = PVR_FOG_DISABLE;
break;
case GL_SCISSOR_TEST:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.clip_mode = PVR_USERCLIP_DISABLE;
if (USERCLIP_OUTSIDE_ENABLED)
gl_capabilities &= ~((GLbitfield)GL_KOS_USERCLIP_OUTSIDE);
break;
case GL_KOS_USERCLIP_OUTSIDE:
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.clip_mode = PVR_USERCLIP_DISABLE;
if (SCISSOR_ENABLED)
gl_capabilities &= ~((GLbitfield)GL_SCISSOR_TEST);
break;
case GL_KOS_MODIFIER:
assert_msg(0, "GL_KOS_MODIFER not implemented");
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.fmt.modifier = PVR_MODIFIER_DISABLE;
break;
case GL_KOS_CHEAP_SHADOW:
assert_msg(0, "GL_KOS_CHEAP_SHADOW not implemented");
gl_pbuf_submitted = GL_FALSE;
gl_poly_cxt.gen.modifier_mode = PVR_MODIFIER_NORMAL;
break;
case GL_KOS_NEARZ_CLIPPING:
gl_matrix_dirty = GL_TRUE;
break;
case GL_LIGHT0:
assert_msg(0, "GL_LIGHTi not implemented");
break;
}
gl_capabilities &= ~((GLbitfield)cap);
}
/* We have no rendering pipeline yet, so this is a NOP */
void glFlush() {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
}
/* There aren't any useful hints to set yet, so this is a NOP */
void glHint(GLenum target, GLenum mode) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
}
void glPointSize(GLfloat size) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
gl_point_size = CLAMP(size, 0.0f, 100.0f);
}
/* These strings should go somewhere else */
const GLubyte *glGetString(GLenum name) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(name) {
case GL_VENDOR:
return "Cryptic Allusions";
case GL_RENDERER:
return "KallistiOS";
case GL_VERSION:
return "1.1";
case GL_EXTENSIONS:
return "GL_ARB_transpose_matrix ";
}
return "";
}
/* A limited view into the guts of KGL - This will change! */
void glGetFloatv(GLenum pname, GLfloat *params) {
int i, j;
matrix_t *pmat = (matrix_t*)params;
switch(pname) {
case GL_MODELVIEW_MATRIX:
for (i=0; i<4; i++)
for (j=0; j<4; j++)
(*pmat)[i][j] = gl_trans_mats[GL_MODELVIEW][i][j];
break;
case GL_PROJECTION_MATRIX:
for (i=0; i<4; i++)
for (j=0; j<4; j++)
(*pmat)[i][j] = gl_trans_mats[GL_PROJECTION][i][j];
break;
case GL_TEXTURE_MATRIX:
for (i=0; i<4; i++)
for (j=0; j<4; j++)
(*pmat)[i][j] = gl_trans_mats[GL_TEXTURE][i][j];
break;
default:
assert_msg(0, "not glGet param not implemented");
}
}

212
glmodifier.c
View File

@ -1,212 +0,0 @@
/* KallistiGL for KOS ##version##
glmodifier.c
(c)2002 Paul Boese
NOTE: This module is experimental, incomplete, and non-working
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
#include <string.h>
#include <malloc.h>
#include <dc/matrix.h>
#include <dc/pvr.h>
volatile pvr_modifier_vol_t *volume;
static pvr_modifier_vol_t vol_vbuf, vol_xbuf;
pvr_dr_state_t dr_state;
static GLint mod_type = -1;
/* local buffer for textured, packed-color, affected by modifier vertex */
pvr_vertex_tpcm_t vert_xbuf = {
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000
};
/* Negative 1/w values annoy the pvr, so check for them */
static inline int check_w(pvr_vertex_t *vert, int n) {
int i;
for(i=0; i<n; i++)
if (vert[i].z < 0) return 0;
return 1;
}
/* Make sure the proper matrices are in the matrix registers */
static void fix_matrices() {
if (gl_matrix_dirty) {
mat_identity();
glKosMatrixApply(GL_KOS_SCREENVIEW);
glKosMatrixApply(GL_PROJECTION);
glKosMatrixApply(GL_MODELVIEW);
gl_matrix_dirty = GL_FALSE;
}
}
static pvr_poly_hdr_t mod_hdr = {
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000
};
void send_mod_hdr(void) {
mod_hdr.cmd = PVR_CMD_MODIFIER;
mod_hdr.mode1 = (mod_type << PVR_TA_PM1_MODIFIERINST_SHIFT) & PVR_TA_PM1_MODIFIERINST_MASK;
switch(gl_active_list) {
case GL_LIST_OPAQUE_MOD:
mod_hdr.cmd |= (PVR_LIST_OP_MOD << PVR_TA_CMD_TYPE_SHIFT) & PVR_TA_CMD_TYPE_MASK;
break;
case GL_LIST_TRANS_MOD:
mod_hdr.cmd |= (PVR_LIST_TR_MOD << PVR_TA_CMD_TYPE_SHIFT) & PVR_TA_CMD_TYPE_MASK;
break;
default:
assert_msg(0, "wrong list specified");
break;
}
pvr_prim(&mod_hdr, sizeof(pvr_poly_hdr_t));
}
void glKosModBegin(GLenum mode) {
assert_msg(0,"not implemented");
mod_type = mode;
//pvr_dr_init(dr_state);
send_mod_hdr();
fix_matrices();
}
void glKosModEnd(void) {
assert_msg(0,"not implemented");
mod_type = -1;
}
void glKosModVolume9f(GLfloat ax, GLfloat ay, GLfloat az,
GLfloat bx, GLfloat by, GLfloat bz,
GLfloat cx, GLfloat cy, GLfloat cz) {
assert_msg(0,"not implemented");
vol_vbuf.flags = PVR_CMD_VERTEX_EOL;
vol_vbuf.ax = ax;
vol_vbuf.ay = ay;
vol_vbuf.az = az;
vol_vbuf.bx = bx;
vol_vbuf.by = by;
vol_vbuf.bz = bz;
vol_vbuf.cx = cx;
vol_vbuf.cy = cy;
vol_vbuf.cz = cz;
mat_transform((vector_t*)&vol_vbuf.ax, (vector_t*)&vol_xbuf.ax, 3, sizeof(vector_t));
/* Can't use the alternating store queues cuz we're sending
* 64 bytes at once with this vertex type
*/
vol_xbuf.flags = vol_vbuf.flags;
vol_xbuf.d1 = vol_xbuf.d2 = vol_xbuf.d3 = 0;
vol_xbuf.d4 = vol_xbuf.d5 = vol_xbuf.d6 = 0;
pvr_prim(&vol_xbuf, sizeof(pvr_modifier_vol_t));
//printf("[%2.2f, %2.2f]\n", cz, vol_xbuf.cz);
}
static void end_quads() {
int i, j, order[4] = {3, 0, 2, 1};
/* Should be four points in the buffer */
assert_msg(gl_vbuf_top == 4, "Wrong number of vertices.");
gl_vbuf[order[3]].flags = PVR_CMD_VERTEX_EOL;
/* mat_transform((vector_t*)&gl_vbuf[0].x, (vector_t*)&gl_xbuf[0].x, 4,
sizeof(pvr_vertex_t)); */
for (i=0; i<4; i++) {
float x = gl_vbuf[i].x, y = gl_vbuf[i].y, z = gl_vbuf[i].z, w = 1.0f;
mat_trans_single4(x, y, z, w);
gl_xbuf[i].x = x;
gl_xbuf[i].y = y;
if (w == 1.0f)
gl_xbuf[i].z = ((gl_viewport_scale[2] * z) + gl_viewport_offset[2]);
else
gl_xbuf[i].z = w;
}
/* Throw it all to the TA using direct render */
if (check_w(gl_xbuf, 4))
for (i=0; i<4; i++) {
j = order[i];
vert_xbuf.flags = gl_vbuf[j].flags;
vert_xbuf.x = gl_xbuf[j].x;
vert_xbuf.y = gl_xbuf[j].y;
vert_xbuf.z = gl_xbuf[j].z;
vert_xbuf.u0 = gl_vbuf[j].u;
vert_xbuf.v0 = gl_vbuf[j].v;
vert_xbuf.argb0 = gl_vbuf[j].argb;
vert_xbuf.oargb0 = gl_vbuf[j].oargb;
vert_xbuf.u1 = 0.0f;
vert_xbuf.v1 = 0.0f;
vert_xbuf.argb1 = 0xff00ff00;
vert_xbuf.oargb1 = 0xffff0000;
pvr_prim(&vert_xbuf, sizeof(pvr_vertex_tpcm_t));
}
}
void modifier_check_end() {
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
//end_points();
gl_vbuf_top = 0;
break;
case GL_TRIANGLES:
if (gl_vbuf_top == 3) {
//end_triangles();
gl_vbuf_top = 0;
}
break;
case GL_TRIANGLE_STRIP:
break;
case GL_QUADS:
if (gl_vbuf_top == 4) {
end_quads();
gl_vbuf_top = 0;
}
break;
case GL_QUAD_STRIP:
break;
case GL_POLYGON:
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
}
void modifier_end(void) {
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
break;
case GL_TRIANGLES:
break;
case GL_TRIANGLE_STRIP:
//end_triangle_strip();
break;
case GL_QUADS:
break;
case GL_QUAD_STRIP:
//end_quad_strip();
break;
case GL_POLYGON:
//end_polygon();
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
gl_prim_type = 0;
}

182
glnzclip.c
View File

@ -1,182 +0,0 @@
/* KallistiGL for KOS ##version##
glnzclip.c
(c)2002 Paul Boese
Near Z Clipped primatives
*/
/* This is experimental and subject to change - Currently only supports
GL_TRIANGLES.
Note: this file was originally named glvfzclip.c. Not entirely
correct. My Oops!
*/
#include <kos.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include "glclip.h" /* Trilinear's inline near z clipper code */
#include <assert.h>
#include <dc/matrix.h>
#include <dc/pvr.h>
/* Some local tranform stuff. It is generally faster to clip and
light verts in view-space. The transform has been broken into
two pieces to make that possibe. */
static matrix_t mvp __attribute__((aligned(32)));
/* Make sure the proper matrices are in the matrix registers */
void fix_vfzclip_matrices() {
if (gl_matrix_dirty) {
mat_load(gl_trans_mats + GL_PROJECTION);
mat_apply(gl_trans_mats + GL_MODELVIEW);
mat_store(&mvp);
gl_matrix_dirty = GL_FALSE;
}
}
static uint32 frms = 0;
/* translate verts from model-space to view-space */
static void xltmodel(gl_vertex_t *invert, gl_vertex_t *outvert, int num) {
int i;
gl_vertex_t *ip, *op;
for (i=0; i<num; i++) {
ip = &invert[i];
op = &outvert[i];
/* Transform the vertex position by the MVP matrices - assume invert.w is always 1.0 */
op->x = (mvp[0][0] * ip->x) + (mvp[1][0] * ip->y) + (mvp[2][0] * ip->z) + (mvp[3][0] * ip->w);
op->y = (mvp[0][1] * ip->x) + (mvp[1][1] * ip->y) + (mvp[2][1] * ip->z) + (mvp[3][1] * ip->w);
op->z = (mvp[0][2] * ip->x) + (mvp[1][2] * ip->y) + (mvp[2][2] * ip->z) + (mvp[3][2] * ip->w);
op->w = (mvp[0][3] * ip->x) + (mvp[1][3] * ip->y) + (mvp[2][3] * ip->z) + (mvp[3][3] * ip->w);
/* copy other attributes */
op->flags = ip->flags;
op->u = ip->u;
op->v = ip->v;
op->argb = ip->argb;
op->oargb = ip ->oargb;
if ((frms++)%20000 == 0)
printf("z=%03.3f, w=%03.3f\n", op->z, op->w);
}
}
/* translate verts from view-space to the screen */
static void xltview(gl_vertex_t *invert, gl_vertex_t *outvert, int num) {
int i;
gl_vertex_t *ip, *op;
for (i=0; i<num; i++) {
ip = &invert[i];
op = &outvert[i];
/* perspective divide */
op->x = (ip->x /= ip->w);
op->y = (ip->y /= ip->w);
op->z = (ip->z /= ip->w);
/* Perform viewport mapping (note: this implicitly flips the y-axis) */
op->x = (gl_viewport_scale[0] * op->x) + gl_viewport_offset[0];
op->y = gl_screen_height - ((gl_viewport_scale[1] * op->y) + gl_viewport_offset[1]);
op->z = (ip->w == 1.0) ? (gl_viewport_scale[2] * op->z) + gl_viewport_offset[2] : 1.0f / ip->w;
}
}
static void end_triangles() {
int i, rslt;
volatile pvr_vertex_t *vert;
pvr_dr_state_t dr_state;
pvr_dr_init(dr_state);
/* Should be three points in the buffer */
assert_msg(gl_vbuf_top == 3, "Wrong number of vertices.");
xltmodel(gl_vbuf, gl_xbuf, 3);
rslt = ZClipTex(gl_xbuf);
xltview(gl_xbuf, gl_xbuf, rslt);
/* Throw it all to the TA using direct render */
if (rslt!=0) {
gl_xbuf[rslt-1].flags = PVR_CMD_VERTEX_EOL;
for (i=0; i<rslt; i++) {
vert = pvr_dr_target(dr_state);
vert->flags = gl_xbuf[i].flags;
vert->x = gl_xbuf[i].x;
vert->y = gl_xbuf[i].y;
vert->z = gl_xbuf[i].z;
vert->u = gl_xbuf[i].u;
vert->v = gl_xbuf[i].v;
vert->argb = gl_xbuf[i].argb;
vert->oargb = gl_xbuf[i].oargb;
pvr_dr_commit(vert);
}
}
}
void vfzclip_check_end() {
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
//end_points();
assert_msg(0, "GL_POINTS not supported");
gl_vbuf_top = 0;
break;
case GL_TRIANGLES:
if (gl_vbuf_top == 3) {
end_triangles();
gl_vbuf_top = 0;
}
break;
case GL_TRIANGLE_STRIP:
assert_msg(0, "GL_TRIANGE_STRIP not supported");
break;
case GL_QUADS:
assert_msg(0, "GL_QUADS not supported");
if (gl_vbuf_top == 4) {
//end_quads();
gl_vbuf_top = 0;
}
break;
case GL_QUAD_STRIP:
assert_msg(0, "GL_QUAD_STRIP not supported");
break;
case GL_POLYGON:
assert_msg(0, "GL_POLYGON not supported");
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
}
void vfzclip_end(void) {
/* What type of primitive was it? */
switch(gl_prim_type) {
case GL_POINTS:
break;
case GL_TRIANGLES:
break;
case GL_TRIANGLE_STRIP:
//end_triangle_strip();
break;
case GL_QUADS:
break;
case GL_QUAD_STRIP:
//end_quad_strip();
break;
case GL_POLYGON:
//end_polygon();
break;
default:
assert_msg(0, "gl_prim_type: Unknown primitive type.");
}
gl_prim_type = 0;
}

188
gltex.c
View File

@ -1,188 +0,0 @@
/* KallistiGL for KOS ##version##
gltex.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include "glmacros.h"
#include <assert.h>
#include <malloc.h>
#include <stdio.h>
/* Texture handling */
/* Allocate "texture structures" (really poly context structs) */
void glGenTextures(GLsizei n, GLuint *textures) {
int i;
pvr_poly_cxt_t *p;
for (i=0; i<n; i++) {
p = (pvr_poly_cxt_t*)malloc(sizeof(pvr_poly_cxt_t));
/* initial state for this texture object */
p->txr.env = PVR_TXRENV_MODULATE;
p->txr.enable = PVR_TEXTURE_ENABLE;
p->txr.filter = PVR_FILTER_NONE;
p->txr.alpha = PVR_TXRALPHA_DISABLE;
p->txr.mipmap = PVR_MIPMAP_DISABLE;
p->txr.mipmap_bias = PVR_MIPBIAS_NORMAL;
p->txr.uv_flip = PVR_UVFLIP_NONE;
p->txr.uv_clamp = PVR_UVCLAMP_NONE;
p->txr.format = PVR_TXRFMT_NONE;
p->txr.base = NULL;
p->txr.width = -1;
p->txr.height = -1;
textures[i] = (GLuint)p;
}
}
/* Delete textures from VRAM */
void glDeleteTextures(GLsizei n, const GLuint *textures) {
int i;
for (i=0; i<n; i++) {
pvr_mem_free(((pvr_poly_cxt_t *)textures[i])->txr.base);
free((void*)textures[i]);
}
}
/* Bind a texture */
void glBindTexture(GLenum type, GLuint texture) {
assert(type == GL_TEXTURE_2D);
gl_cur_texture = (pvr_poly_cxt_t *)texture;
gl_pbuf_submitted = GL_FALSE;
}
/* Load a texture from a 2D image */
void glTexImage2D(GLenum target, GLint level,
GLint internal_fmt,
GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type,
const GLvoid *pixels) {
pvr_ptr_t txr;
assert_msg(border == 0 && level == 0, "Borders and levels not supported.");
assert_msg((internal_fmt & ~1) == (format & ~1), "Pixel conversion not supported.");
/* Allocate space for it */
txr = pvr_mem_malloc(width * height * 2);
/* Load the texture data */
if ((internal_fmt & 1) != (format & 1))
pvr_txr_load_ex((GLvoid *)pixels, txr, width, height, PVR_TXRLOAD_16BPP);
else
pvr_txr_load((GLvoid *)pixels, txr, width * height * 2);
/* Store texture state in context */
gl_cur_texture->txr.width = width;
gl_cur_texture->txr.height = height;
gl_cur_texture->txr.format = internal_fmt;
gl_cur_texture->txr.base = txr;
gl_pbuf_submitted = GL_FALSE;
}
/* KOS shortcut function (if you loaded your own texture) */
void glKosTex2D(GLint internal_fmt, GLsizei width, GLsizei height,
pvr_ptr_t txr_address) {
/* Store texture state in context */
gl_cur_texture->txr.width = width;
gl_cur_texture->txr.height = height;
gl_cur_texture->txr.format = internal_fmt;
gl_cur_texture->txr.base = txr_address;
gl_pbuf_submitted = GL_FALSE;
}
/* Texture environment */
void glTexEnvi(GLenum target, GLenum pname, GLint param) {
assert(target == GL_TEXTURE_2D);
assert(pname == GL_TEXTURE_ENV_MODE);
switch(param) {
case GL_REPLACE:
gl_cur_texture->txr.env = PVR_TXRENV_REPLACE;
break;
case GL_MODULATE:
gl_cur_texture->txr.env = PVR_TXRENV_MODULATE;
break;
case GL_DECAL:
gl_cur_texture->txr.env = PVR_TXRENV_DECAL;
break;
case GL_MODULATEALPHA:
gl_cur_texture->txr.env = PVR_TXRENV_MODULATEALPHA;
break;
}
gl_pbuf_submitted = GL_FALSE;
}
/* Texture parameter */
void glTexParameteri(GLenum target, GLenum pname, GLint param) {
assert(target == GL_TEXTURE_2D);
switch(pname) {
case GL_TEXTURE_FILTER:
switch(param) {
case GL_FILTER_NONE:
gl_cur_texture->txr.filter = PVR_FILTER_NONE;
break;
case GL_FILTER_BILINEAR:
gl_cur_texture->txr.filter = PVR_FILTER_BILINEAR;
break;
default:
assert_msg(0, "Unknown texture filter.");
break;
}
break;
case GL_TEXTURE_WRAP_S: /* adjust state of UVCLAMP_U */
switch(param) {
case GL_REPEAT:
if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_UV)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_V;
else if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_U)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_NONE;
break;
case GL_CLAMP:
if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_NONE)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_U;
else if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_V)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_UV;
break;
default:
assert_msg(0, "Unknown texture wrap mode.");
break;
}
break;
case GL_TEXTURE_WRAP_T: /* adjust state of UVCLAMP_V */
switch(param) {
case GL_REPEAT:
if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_UV)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_U;
else if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_V)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_NONE;
break;
case GL_CLAMP:
if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_NONE)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_V;
else if (gl_cur_texture->txr.uv_clamp == PVR_UVCLAMP_U)
gl_cur_texture->txr.uv_clamp = PVR_UVCLAMP_UV;
break;
default:
assert_msg(0, "Unknown texture wrap mode.");
break;
}
break;
default:
assert_msg(0, "Unknown parameter name (pname).");
break;
}
gl_pbuf_submitted = GL_FALSE;
}

518
gltrans.c
View File

@ -1,518 +0,0 @@
/* KallistiGL for KOS ##version##
gltrans.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
#include <assert.h>
#include <string.h>
#include <dc/fmath.h>
#include <dc/matrix.h>
/* Transformation APIs */
/* Modus operandi, as it were
The transformation API will store N matrices, representing the various
GL matrix modes (projection, modelview, texture) and gl_matrix_mode will
point to the currently selected on. All matrix operations will load the matrix
from its array position, perform the math on that matrix, and store it back
into the array.
When gldraw() uses the matrices, it will pull the matrices it needs and
multiply them out in registers before applying them to vectors.
*/
#define DEG2RAD (F_PI / 180.0f)
#define RAD2DEG (180.0f / F_PI)
/* Matrix stacks (move to global?) */
#define MAT_MV_STACK_CNT 32
#define MAT_P_STACK_CNT 2
#define MAT_T_STACK_CNT 2
static matrix_t gl_mat_mv_stack[MAT_MV_STACK_CNT] __attribute__((aligned(32)));
static int gl_mat_mv_stack_top = 0;
static matrix_t gl_mat_p_stack[MAT_P_STACK_CNT] __attribute__((aligned(32)));
static int gl_mat_p_stack_top = 0;
static matrix_t gl_mat_t_stack[MAT_T_STACK_CNT] __attribute__((aligned(32)));
static int gl_mat_t_stack_top = 0;
/* Frustum stack */
static gl_frustum_t gl_frustum_stack[MAT_P_STACK_CNT];
static int gl_frustum_stack_top = 0;
/* Set which matrix we are working on */
void glMatrixMode(GLenum mode) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
gl_matrix_mode = mode;
gl_matrix_dirty = GL_TRUE;
}
/* Load the identitiy matrix */
void glLoadIdentity(void) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
mat_identity();
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
static matrix_t ml __attribute__((aligned(32)));
/* Load an arbitrary matrix */
void glLoadMatrixf(const GLfloat *m) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
memcpy(ml, m, sizeof(matrix_t));
mat_load(&ml);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
/* Load an arbitrary transposed matrix */
void glLoadTransposeMatrixf(const GLfloat *m) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
ml[0][0] = m[0];
ml[0][1] = m[4];
ml[0][2] = m[8];
ml[0][3] = m[12];
ml[1][0] = m[1];
ml[1][1] = m[5];
ml[1][2] = m[9];
ml[1][3] = m[13];
ml[2][0] = m[2];
ml[2][1] = m[6];
ml[2][2] = m[10];
ml[2][3] = m[14];
ml[3][0] = m[3];
ml[3][1] = m[7];
ml[3][2] = m[11];
ml[3][3] = m[15];
mat_load(&ml);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
/* Multiply the current matrix by an arbitrary matrix */
void glMultMatrixf(const GLfloat *m) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
memcpy(ml, m, sizeof(matrix_t));
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&ml);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
/* Multiply the current matrix by an arbitrary transposed matrix */
void glMultTransposeMatrixf(const GLfloat *m) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
ml[0][0] = m[0];
ml[0][1] = m[4];
ml[0][2] = m[8];
ml[0][3] = m[12];
ml[1][0] = m[1];
ml[1][1] = m[5];
ml[1][2] = m[9];
ml[1][3] = m[13];
ml[2][0] = m[2];
ml[2][1] = m[6];
ml[2][2] = m[10];
ml[2][3] = m[14];
ml[3][0] = m[3];
ml[3][1] = m[7];
ml[3][2] = m[11];
ml[3][3] = m[15];
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&ml);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
/* Set the depth range */
void glDepthRange(GLclampf n, GLclampf f) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
/* clamp the values... */
if (n < 0.0f) n = 0.0f;
if (n > 1.0f) n = 1.0f;
if (f < 0.0f) f = 0.0f;
if (f > 1.0f) f = 1.0f;
gl_depthrange_near = n;
gl_depthrange_far = f;
/* Adjust the viewport scale and offset for Z */
gl_viewport_scale[2] = ((f - n) / 2.0f);
gl_viewport_offset[2] = (n + f) / 2.0f;
}
/* Set the GL viewport */
void glViewport(GLint x, GLint y,
GLsizei width, GLsizei height) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
gl_viewport_x1 = x;
gl_viewport_y1 = y;
gl_viewport_width = width;
gl_viewport_height = height;
/* Calculate the viewport scale and offset */
gl_viewport_scale[0] = (GLfloat)width / 2.0f;
gl_viewport_offset[0] = gl_viewport_scale[0] + (GLfloat)x;
gl_viewport_scale[1] = (GLfloat)height / 2.0f;
gl_viewport_offset[1] = gl_viewport_scale[1] + (GLfloat)y;
gl_viewport_scale[2] = (gl_depthrange_far - gl_depthrange_near) / 2.0f;
gl_viewport_offset[2] = (gl_depthrange_near + gl_depthrange_far) / 2.0f;
/* Flip the Y-axis */
//gl_viewport_scale[1] *= -1.0f;
/* FIXME: Why does the depth value need some nudging?
* This makes polys with Z=0 work.
*/
gl_viewport_offset[2] += 0.0001f;
}
/* Located here for now */
void gluPerspective(GLfloat angle, GLfloat aspect,
GLfloat znear, GLfloat zfar) {
GLfloat xmin, xmax, ymin, ymax;
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
ymax = znear * ftan(angle * F_PI / 360.0f);
ymin = -ymax;
xmin = ymin * aspect;
xmax = ymax * aspect;
glFrustum(xmin, xmax, ymin, ymax, znear, zfar);
}
static matrix_t mf __attribute__((aligned(32))) = {
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, -1.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f }
};
void glFrustum(GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat znear, GLfloat zfar) {
GLfloat x, y, a, b, c, d;
gl_frustum.left = left;
gl_frustum.right = right;
gl_frustum.bottom = bottom;
gl_frustum.top = top;
gl_frustum.znear = znear;
gl_frustum.zfar = zfar;
assert(znear > 0.0f);
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
x = (2.0f * znear) / (right - left);
y = (2.0f * znear) / (top - bottom);
a = (right + left) / (right - left);
b = (top + bottom) / (top - bottom);
c = -(zfar + znear) / (zfar - znear);
d = -(2.0f * zfar * znear) / (zfar - znear);
mf[0][0] = x;
mf[2][0] = a;
mf[1][1] = y;
mf[2][1] = b;
mf[2][2] = c;
mf[3][2] = d;
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&mf);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
static matrix_t mo __attribute__((aligned(32))) = {
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
void glOrtho(GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat znear, GLfloat zfar) {
GLfloat x, y, z;
GLfloat tx, ty, tz;
gl_frustum.znear = 0.001;
gl_frustum.zfar = 100;
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
x = 2.0f / (right - left);
y = 2.0f / (top - bottom);
z = -2.0f / (zfar - znear);
tx = -(right + left) / (right - left);
ty = -(top + bottom) / (top - bottom);
tz = -(zfar + znear) / (zfar - znear);
mo[0][0] = x;
mo[1][1] = y;
mo[2][2] = z;
mo[3][0] = tx;
mo[3][1] = ty;
mo[3][2] = tz;
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&mo);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
void glPushMatrix(void) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch (gl_matrix_mode)
{
case GL_MODELVIEW:
assert_msg(gl_mat_mv_stack_top < MAT_MV_STACK_CNT, "Modelview stack overflow.");
memcpy(gl_mat_mv_stack + gl_mat_mv_stack_top,
gl_trans_mats + gl_matrix_mode,
sizeof(matrix_t));
gl_mat_mv_stack_top++;
break;
case GL_PROJECTION:
assert_msg(gl_mat_p_stack_top < MAT_P_STACK_CNT, "Projection stack overflow.");
memcpy(gl_mat_p_stack + gl_mat_p_stack_top,
gl_trans_mats + gl_matrix_mode,
sizeof(matrix_t));
gl_mat_p_stack_top++;
memcpy(gl_frustum_stack + gl_frustum_stack_top,
&gl_frustum,
sizeof(gl_frustum_t));
gl_frustum_stack_top++;
break;
case GL_TEXTURE:
assert_msg(gl_mat_t_stack_top < MAT_T_STACK_CNT, "Texture stack overflow.");
memcpy(gl_mat_t_stack + gl_mat_t_stack_top,
gl_trans_mats + gl_matrix_mode,
sizeof(matrix_t));
gl_mat_t_stack_top++;
break;
}
}
void glPopMatrix(void) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
switch(gl_matrix_mode)
{
case GL_MODELVIEW:
assert_msg(gl_mat_mv_stack_top > 0, "Modelview stack underflow.");
gl_mat_mv_stack_top--;
memcpy(gl_trans_mats + gl_matrix_mode,
gl_mat_mv_stack + gl_mat_mv_stack_top,
sizeof(matrix_t));
break;
case GL_PROJECTION:
assert_msg(gl_mat_p_stack_top > 0, "Projection stack underflow.");
gl_mat_p_stack_top--;
memcpy(gl_trans_mats + gl_matrix_mode,
gl_mat_p_stack + gl_mat_p_stack_top,
sizeof(matrix_t));
gl_frustum_stack_top--;
memcpy(&gl_frustum,
gl_frustum_stack + gl_frustum_stack_top,
sizeof(gl_frustum_t));
break;
case GL_TEXTURE:
assert_msg(gl_mat_t_stack_top > 0, "Texture stack underflow.");
gl_mat_t_stack_top--;
memcpy(gl_trans_mats + gl_matrix_mode,
gl_mat_t_stack + gl_mat_t_stack_top,
sizeof(matrix_t));
break;
}
gl_matrix_dirty = GL_TRUE;
}
static matrix_t mr __attribute__((aligned(32))) = {
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
void glRotatef(GLfloat angle,
GLfloat x, GLfloat y, GLfloat z) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
GLfloat rcos = fcos(angle * DEG2RAD);
GLfloat rsin = fsin(angle * DEG2RAD);
GLfloat invrcos = (1.0f - rcos);
GLfloat mag = fsqrt(x*x + y*y + z*z);
GLfloat xx, yy, zz, xy, yz, zx;
if (mag < 1.0e-6) {
/* Rotation vector is too small to be significant */
return;
}
/* Normalize the rotation vector */
x /= mag;
y /= mag;
z /= mag;
xx = x * x;
yy = y * y;
zz = z * z;
xy = (x * y * invrcos);
yz = (y * z * invrcos);
zx = (z * x * invrcos);
/* Generate the rotation matrix */
mr[0][0] = xx + rcos * (1.0f - xx);
mr[2][1] = yz - x * rsin;
mr[1][2] = yz + x * rsin;
mr[1][1] = yy + rcos * (1.0f - yy);
mr[2][0] = zx + y * rsin;
mr[0][2] = zx - y * rsin;
mr[2][2] = zz + rcos * (1.0f - zz);
mr[1][0] = xy - z * rsin;
mr[0][1] = xy + z * rsin;
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&mr);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
static matrix_t ms __attribute__((aligned(32))) = {
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
void glScalef(GLfloat x, GLfloat y, GLfloat z) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
ms[0][0] = x;
ms[1][1] = y;
ms[2][2] = z;
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&ms);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
static matrix_t mt __attribute__((aligned(32))) = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
mt[3][0] = x;
mt[3][1] = y;
mt[3][2] = z;
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&mt);
mat_store(gl_trans_mats + gl_matrix_mode);
gl_matrix_dirty = GL_TRUE;
}
/* XXX - these should be in glu */
void normalize(float v[3])
{
float r;
r = fsqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
if (r == 0.0) return;
v[0] /= r;
v[1] /= r;
v[2] /= r;
}
void cross(float v1[3], float v2[3], float result[3])
{
result[0] = v1[1]*v2[2] - v1[2]*v2[1];
result[1] = v1[2]*v2[0] - v1[0]*v2[2];
result[2] = v1[0]*v2[1] - v1[1]*v2[0];
}
static matrix_t ml __attribute__((aligned(32))) = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
/* XXX - should move to glu */
void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez, GLfloat centerx,
GLfloat centery, GLfloat centerz, GLfloat upx, GLfloat upy,
GLfloat upz)
{
float forward[3], side[3], up[3];
assert_msg(!gl_prim_type, "Not allowed within glBegin/glEnd pair.");
forward[0] = centerx - eyex;
forward[1] = centery - eyey;
forward[2] = centerz - eyez;
up[0] = upx;
up[1] = upy;
up[2] = upz;
normalize(forward);
/* Side = forward x up */
cross(forward, up, side);
normalize(side);
/* Recompute up as: up = side x forward */
cross(side, forward, up);
ml[0][0] = side[0];
ml[1][0] = side[1];
ml[2][0] = side[2];
ml[0][1] = up[0];
ml[1][1] = up[1];
ml[2][1] = up[2];
ml[0][2] = -forward[0];
ml[1][2] = -forward[1];
ml[2][2] = -forward[2];
mat_load(gl_trans_mats + gl_matrix_mode);
mat_apply(&ml);
mat_store(gl_trans_mats + gl_matrix_mode);
glTranslatef(-eyex, -eyey, -eyez);
}

101
glvars.c
View File

@ -1,101 +0,0 @@
/* KallistiGL for KOS ##version##
glvars.c
(c)2001 Dan Potter
*/
#include <GL/gl.h>
#include <GL/glu.h>
#include "glinternal.h"
/* Variable definitions */
/* Background clear color (not currently used) */
GLfloat gl_clear_color[4];
/* Capabilities bitfield: toggles for glEnable() / glDisable() */
GLbitfield gl_capabilities;
/* Current primitive type (or -1) */
GLenum gl_prim_type;
/* Current polygon context */
pvr_poly_cxt_t gl_poly_cxt;
/* Poly header buffer submitted? */
GLboolean gl_pbuf_submitted;
/* Current Blend functions */
GLint gl_blend_src = PVR_BLEND_SRCALPHA;
GLint gl_blend_dst = PVR_BLEND_INVSRCALPHA;
/* Currently selected texture */
pvr_poly_cxt_t *gl_cur_texture;
/* Null texture for colored polys */
pvr_poly_cxt_t gl_null_texture;
/* Screen size */
GLsizei gl_screen_width;
GLsizei gl_screen_height;
/* Viewport size */
GLint gl_viewport_x1, gl_viewport_y1,
gl_viewport_width, gl_viewport_height;
/* Viewport mapping */
GLfloat gl_viewport_scale[3];
GLfloat gl_viewport_offset[3];
/* Scissor clipping */
GLint gl_scissor_x;
GLint gl_scissor_y;
GLsizei gl_scissor_width;
GLsizei gl_scissor_height;
GLboolean gl_scissor_dirty = GL_FALSE;
/* Depth range */
GLclampf gl_depthrange_near;
GLclampf gl_depthrange_far;
/* Transformation matrices */
matrix_t gl_trans_mats[GL_MATRIX_COUNT] __attribute__((aligned(32)));
int gl_matrix_mode;
GLboolean gl_matrix_dirty;
/* Frustum attributes */
gl_frustum_t gl_frustum;
/* Enabled lists */
GLbitfield gl_enabled_lists;
/* Currently active list */
GLbitfield gl_active_list;
/* Face culling enabled/disabled */
GLboolean gl_cull_face = GL_FALSE;
/* Front face */
GLenum gl_front_face = GL_CCW;
/* Culling mode */
GLenum gl_cull_mode = GL_BACK;
/* Fog Attributes */
GLfloat gl_fog_color[4] = {0.5f, 0.5f, 0.5f, 1.0f}; /* r, g, b, a */
GLfloat gl_fog_density = 1.0f; /* Density >= 0.0 - exp exp2 fog */
GLfloat gl_fog_start = 0.0f; /* linear fog */
GLfloat gl_fog_end = 1.0f; /* linear fog */
GLfloat gl_fog_index = 0.0f; /* unused */
GLenum gl_fog_mode = GL_EXP;
/* Point size */
GLfloat gl_point_size = 1.0f;
/* Vertex buffers */
/* Pre-xformed vertex buffer */
gl_vertex_t gl_vbuf[VBUF_SIZE] __attribute__((aligned(8192)));
/* Post-xformed vertex buffer */
gl_vertex_t gl_xbuf[VBUF_SIZE] __attribute__((aligned(8192)));
int gl_vbuf_top;

941
include/gl.h Normal file → Executable file
View File

@ -1,426 +1,515 @@
#ifndef __GL_GL_H
#define __GL_GL_H
#include <sys/cdefs.h>
__BEGIN_DECLS
/* This file was created using Mesa 3-D 3.4's gl.h as a reference. It is not a
complete gl.h header, but includes enough to use GL effectively. */
/* This is currently DC specific, so I don't feel toooo bad about this =) */
#include <dc/pvr.h>
/* GL data types */
#include <arch/types.h>
typedef unsigned int GLenum;
typedef int GLboolean;
typedef unsigned int GLbitfield;
typedef void GLvoid;
typedef int8 GLbyte; /* 1-byte signed */
typedef int16 GLshort; /* 2-byte signed */
typedef int32 GLint; /* 4-byte signed */
typedef uint8 GLubyte; /* 1-byte unsigned */
typedef uint16 GLushort; /* 2-byte unsigned */
typedef uint32 GLuint; /* 4-byte unsigned */
typedef int32 GLsizei; /* 4-byte signed */
typedef float GLfloat; /* single precision float */
typedef float GLclampf; /* single precision float in [0,1] */
/* For these next two, KOS is generally compiled in m4-single-only, so we
just use floats for everything anyway. */
typedef float GLdouble; /* double precision float */
typedef float GLclampd; /* double precision float in [0,1] */
/* Constants */
#define GL_FALSE 0
#define GL_TRUE 1
/* Data types */
#define GL_BYTE 0x1400
#define GL_UNSIGNED_BYTE 0x1401
#define GL_SHORT 0x1402
#define GL_UNSIGNED_SHORT 0x1403
#define GL_INT 0x1404
#define GL_UNSIGNED_INT 0x1405
#define GL_FLOAT 0x1406
#define GL_DOUBLE 0x140A
#define GL_2_BYTES 0x1407
#define GL_3_BYTES 0x1408
#define GL_4_BYTES 0x1409
/* StringName */
#define GL_VENDOR 0x1F00
#define GL_RENDERER 0x1F01
#define GL_VERSION 0x1F02
#define GL_EXTENSIONS 0x1F03
/* Gets */
#define GL_ATTRIB_STACK_DEPTH 0x0BB0
#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
#define GL_COLOR_CLEAR_VALUE 0x0C22
#define GL_COLOR_WRITEMASK 0x0C23
#define GL_CURRENT_INDEX 0x0B01
#define GL_CURRENT_COLOR 0x0B00
#define GL_CURRENT_NORMAL 0x0B02
#define GL_CURRENT_RASTER_COLOR 0x0B04
#define GL_CURRENT_RASTER_DISTANCE 0x0B09
#define GL_CURRENT_RASTER_INDEX 0x0B05
#define GL_CURRENT_RASTER_POSITION 0x0B07
#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
#define GL_CURRENT_TEXTURE_COORDS 0x0B03
#define GL_INDEX_CLEAR_VALUE 0x0C20
#define GL_INDEX_MODE 0x0C30
#define GL_INDEX_WRITEMASK 0x0C21
#define GL_MODELVIEW_MATRIX 0x0BA6
#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
#define GL_NAME_STACK_DEPTH 0x0D70
#define GL_PROJECTION_MATRIX 0x0BA7
#define GL_PROJECTION_STACK_DEPTH 0x0BA4
#define GL_RENDER_MODE 0x0C40
#define GL_RGBA_MODE 0x0C31
#define GL_TEXTURE_MATRIX 0x0BA8
#define GL_TEXTURE_STACK_DEPTH 0x0BA5
#define GL_VIEWPORT 0x0BA2
/* Primitives types: all 0's are unsupported for now */
#define GL_POINTS 1
#define GL_LINES 0 /*2*/
#define GL_LINE_LOOP 0 /*3*/
#define GL_LINE_STRIP 0 /*4*/
#define GL_TRIANGLES 5
#define GL_TRIANGLE_STRIP 6
#define GL_TRIANGLE_FAN 7
#define GL_QUADS 8
#define GL_QUAD_STRIP 9
#define GL_POLYGON 10
/* FrontFaceDirection */
#define GL_CW 0x0900
#define GL_CCW 0x0901
#define GL_CULL_FACE 0x0B44
#define GL_FRONT 0x0404
#define GL_BACK 0x0405
#define GL_FRONT_AND_BACK 0x0408
/* Scissor box */
#define GL_SCISSOR_TEST 0x0008 /* capability bit */
#define GL_KOS_USERCLIP_OUTSIDE 0x4000 /* capability bit */
#define GL_SCISSOR_BOX 0x0C10
/* Matrix modes */
#define GL_MATRIX_MODE 0x0BA0
#define GL_MATRIX_MODE_FIRST 1
#define GL_MODELVIEW 1
#define GL_PROJECTION 2
#define GL_TEXTURE 3
#define GL_MATRIX_COUNT 4
/* Special KOS "matrix mode" (for glKosMatrixApply only) */
#define GL_KOS_SCREENVIEW 0x100
/* "Depth buffer" -- we don't actually support a depth buffer because
the PVR does all of that internally. But these constants are to
ease porting. */
#define GL_NEVER 0x0200
#define GL_LESS 0x0201
#define GL_EQUAL 0x0202
#define GL_LEQUAL 0x0203
#define GL_GREATER 0x0204
#define GL_NOTEQUAL 0x0205
#define GL_GEQUAL 0x0206
#define GL_ALWAYS 0x0207
#define GL_DEPTH_TEST 0
#define GL_DEPTH_BITS 0
#define GL_DEPTH_CLEAR_VALUE 0
#define GL_DEPTH_FUNC 0
#define GL_DEPTH_RANGE 0
#define GL_DEPTH_WRITEMASK 0
#define GL_DEPTH_COMPONENT 0
/* Lighting constants */
#define GL_LIGHTING 0x0b50
#define GL_LIGHT0 0x0010 /* capability bit */
#define GL_LIGHT1 0x0000
#define GL_LIGHT2 0x0000
#define GL_LIGHT3 0x0000
#define GL_LIGHT4 0x0000
#define GL_LIGHT5 0x0000
#define GL_LIGHT6 0x0000
#define GL_LIGHT7 0x0000
#define GL_AMBIENT 0x1200
#define GL_DIFFUSE 0x1201
#define GL_SPECULAR 0
#define GL_SHININESS 0
#define GL_EMISSION 0
#define GL_POSITION 0x1203
#define GL_SHADE_MODEL 0x0b54
#define GL_FLAT 0x1d00
#define GL_SMOOTH 0x1d01
/* Fog */
#define GL_FOG 0x0004 /* capability bit */
#define GL_FOG_MODE 0x0B65
#define GL_FOG_DENSITY 0x0B62
#define GL_FOG_COLOR 0x0B66
#define GL_FOG_INDEX 0x0B61
#define GL_FOG_START 0x0B63
#define GL_FOG_END 0x0B64
#define GL_LINEAR 0x2601
#define GL_EXP 0x0800
#define GL_EXP2 0x0801
/* Hints */
#define GL_FOG_HINT 0x0C54
#define GL_PERSPECTIVE_CORRECTION_HINT 0x0c50
#define GL_POINT_SMOOTH_HINT 0x0C51
#define GL_LINE_SMOOTH_HINT 0x0C52
#define GL_POLYGON_SMOOTH_HINT 0x0C53
#define GL_DONT_CARE 0x1100
#define GL_FASTEST 0x1101
#define GL_NICEST 0x1102
/* Misc bitfield things; we don't really use these either */
#define GL_COLOR_BUFFER_BIT 0
#define GL_DEPTH_BUFFER_BIT 0
/* Blending: not sure how we'll use these yet; the PVR supports a few
of these so we'll want to eventually */
#define GL_BLEND 0x0002 /* capability bit */
#define GL_BLEND_SRC 2
#define GL_BLEND_DST 3
#define GL_ZERO 0
#define GL_ONE 1
#define GL_SRC_COLOR 0x0300
#define GL_ONE_MINUS_SRC_COLOR 0x0301
#define GL_SRC_ALPHA 0x0302
#define GL_ONE_MINUS_SRC_ALPHA 0x0303
#define GL_DST_ALPHA 0x0304
#define GL_ONE_MINUS_DST_ALPHA 0x0305
#define GL_DST_COLOR 0x0306
#define GL_ONE_MINUS_DST_COLOR 0x0307
/*#define GL_SRC_ALPHA_SATURATE 0x0308 unsupported */
/* Misc texture constants */
#define GL_TEXTURE_2D 0x0001 /* capability bit */
#define GL_KOS_AUTO_UV 0x8000 /* capability bit */
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_TEXTURE_MIN_FILTER 1
#define GL_TEXTURE_MAG_FILTER 1
#define GL_TEXTURE_FILTER GL_TEXTURE_MIN_FILTER
#define GL_FILTER_NONE 0
#define GL_FILTER_BILINEAR 1
#define GL_REPEAT 0x2901
#define GL_CLAMP 0x2900
/* Texture Environment */
#define GL_TEXTURE_ENV_MODE 0x2200
#define GL_REPLACE 0
#define GL_MODULATE 1
#define GL_DECAL 2
#define GL_MODULATEALPHA 3
/* Texture format definitions (yes, these vary from real GL) */
#define GL_ARGB1555 (PVR_TXRFMT_ARGB1555 | PVR_TXRFMT_NONTWIDDLED)
#define GL_RGB565 (PVR_TXRFMT_RGB565 | PVR_TXRFMT_NONTWIDDLED)
#define GL_ARGB4444 (PVR_TXRFMT_ARGB4444 | PVR_TXRFMT_NONTWIDDLED)
#define GL_YUV422 (PVR_TXRFMT_YUV422 | PVR_TXRFMT_NONTWIDDLED)
#define GL_BUMP (PVR_TXRFMT_BUMP | PVR_TXRFMT_NONTWIDDLED)
#define GL_ARGB1555_TWID PVR_TXRFMT_ARGB1555
#define GL_RGB565_TWID PVR_TXRFMT_RGB565
#define GL_ARGB4444_TWID PVR_TXRFMT_ARGB4444
#define GL_YUV422_TWID PVR_TXRFMT_YUV422
#define GL_BUMP_TWID PVR_TXRFMT_BUMP
#define GL_VQ_ENABLE PVR_TXRFMT_VQ_ENABLE
/* KOS-specific defines */
#define GL_LIST_NONE 0x00
#define GL_LIST_FIRST 0x01
#define GL_LIST_OPAQUE_POLY 0x01 /* PVR2 modes */
#define GL_LIST_OPAQUE_MOD 0x02
#define GL_LIST_TRANS_POLY 0x04
#define GL_LIST_TRANS_MOD 0x08
#define GL_LIST_PUNCHTHRU 0x10
#define GL_LIST_END 0x20 /* no more lists */
#define GL_LIST_COUNT 5
/* KOS-DCPVR-Modifier-specific '?primatives?'*/
#define GL_KOS_MODIFIER_OTHER_POLY PVR_MODIFIER_OTHER_POLY
#define GL_KOS_MODIFIER_FIRST_POLY PVR_MODIFIER_FIRST_POLY
#define GL_KOS_MODIFIER_LAST_POLY PVR_MODIFIER_LAST_POLY
/* Applied to primatives that will be affected by modifier volumes
or cheap shadows */
#define GL_KOS_MODIFIER 0x2000 /* capability bit */
#define GL_KOS_CHEAP_SHADOW 0x1000 /* capability bit */
/* KOS near Z-CLIPPING */
#define GL_KOS_NEARZ_CLIPPING 0x0020 /* capability bit */
/* KOS-specific APIs */
int glKosInit(); /* Call before using GL */
void glKosShutdown(); /* Call after finishing with it */
void glKosGetScreenSize(GLfloat *x, GLfloat *y); /* Get screen size */
void glKosBeginFrame(); /* Begin frame sequence */
void glKosFinishFrame(); /* Finish frame sequence */
void glKosFinishList(); /* Finish with the current list */
void glKosMatrixIdent(); /* Set the DC's matrix regs to an identity */
void glKosMatrixApply(GLenum mode); /* Apply one of the GL matrices to the DC's matrix regs */
void glKosMatrixDirty(); /* Set matrix regs as dirtied */
void glKosPolyHdrDirty(); /* Set poly header context as dirtied */
void glKosPolyHdrSend(); /* Send the current KGL poly header */
/* Miscellaneous APIs */
void glClearColor(GLclampf red,
GLclampf green,
GLclampf blue,
GLclampf alpha);
void glClear(GLbitfield mask);
void glEnable(GLenum cap);
void glDisable(GLenum cap);
void glFrontFace(GLenum mode);
void glCullFace(GLenum mode);
void glFlush();
void glHint(GLenum target, GLenum mode);
void glPointSize(GLfloat size);
const GLubyte *glGetString(GLenum name);
void glGetFloatv(GLenum pname, GLfloat *param);
/* Blending functions */
void glBlendFunc(GLenum sfactor, GLenum dfactor);
/* Depth buffer (non-functional, just stubs) */
void glClearDepth(GLclampd depth);
void glDepthMask(GLboolean flag);
void glDepthFunc(GLenum func);
/* Transformation */
void glMatrixMode(GLenum mode);
void glFrustum(GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat znear, GLfloat zfar);
void glOrtho(GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat znear, GLfloat zfar);
void glDepthRange(GLclampf n, GLclampf f);
void glViewport(GLint x, GLint y,
GLsizei width, GLsizei height);
void glPushMatrix(void);
void glPopMatrix(void);
void glLoadIdentity(void);
void glLoadMatrixf(const GLfloat *m);
void glLoadTransposeMatrixf(const GLfloat *m);
void glMultMatrixf(const GLfloat *m);
void glMultTransposeMatrixf(const GLfloat *m);
void glRotatef(GLfloat angle,
GLfloat x, GLfloat y, GLfloat z);
void glScalef(GLfloat x, GLfloat y, GLfloat z);
void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
/* Display lists */
/* (need to complete) */
/* Drawing functions */
void glBegin(GLenum mode);
void glEnd(void);
void glVertex2f(GLfloat x, GLfloat y);
void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
void glVertex3fv(GLfloat *v);
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
void glColor3fv(GLfloat *v);
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void glColor4fv(GLfloat *v);
void glTexCoord2f(GLfloat s, GLfloat t);
void glTexCoord2fv(GLfloat *v);
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
/* Texture API */
void glGenTextures(GLsizei n, GLuint *textures);
void glDeleteTextures(GLsizei n, const GLuint *textures);
void glBindTexture(GLenum target, GLuint texture);
void glTexImage2D(GLenum target, GLint level,
GLint internalFormat,
GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type,
const GLvoid *pixels);
void glKosTex2D(GLint internal_fmt, GLsizei width, GLsizei height,
pvr_ptr_t txr_address);
void glTexEnvi(GLenum target, GLenum pname, GLint param);
void glTexParameteri(GLenum target, GLenum pname, GLint param);
/* Lighting */
void glShadeModel(GLenum mode);
/* Fog */
void glFogf( GLenum pname, GLfloat param );
void glFogi( GLenum pname, GLint param );
void glFogfv( GLenum pname, const GLfloat *params );
void glFogiv( GLenum pname, const GLint *params );
/* Modifier Volumes - currently non-functional */
void glKosModBegin(GLenum mode);
void glKosModEnd(void);
void glKosModVolume9f(GLfloat ax, GLfloat ay, GLfloat az,
GLfloat bx, GLfloat by, GLfloat bz,
GLfloat cx, GLfloat cy, GLfloat cz);
__END_DECLS
#endif /* __GL_GL_H */
/* KallistiGL for KallistiOS ##version##
libgl/gl.h
Copyright (C) 2013-2014 Josh "PH3NOM" Pearson
Some functionality adapted from the original KOS libgl:
Copyright (C) 2001 Dan Potter
Copyright (C) 2002 Benoit Miller
This API implements much but not all of the OpenGL 1.1 for KallistiOS.
*/
#ifndef __GL_GL_H
#define __GL_GL_H
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <math.h>
#include <dc/fmath.h>
#include <dc/matrix.h>
#include <dc/matrix3d.h>
#include <dc/pvr.h>
#include <dc/vec3f.h>
#include <dc/video.h>
/* Primitive Types taken from GL for compatability */
/* Not all types are implemented in Open GL DC V.1.0 */
#define GL_POINTS 0x01
#define GL_LINES 0x02
#define GL_LINE_LOOP 0x03
#define GL_LINE_STRIP 0x04
#define GL_TRIANGLES 0x05
#define GL_TRIANGLE_STRIP 0x06
#define GL_TRIANGLE_FAN 0x07
#define GL_QUADS 0x08
#define GL_QUAD_STRIP 0x09
#define GL_POLYGON 0x0A
/* FrontFaceDirection */
#define GL_CW 0x0900
#define GL_CCW 0x0901
#define GL_FRONT 0x0404
#define GL_BACK 0x0405
#define GL_FRONT_AND_BACK 0x0408
#define GL_CULL_FACE 0x0B44
#define GL_CULL_FACE_MODE 0x0B45
#define GL_FRONT_FACE 0x0B46
/* Scissor box */
#define GL_SCISSOR_TEST 0x0008 /* capability bit */
#define GL_SCISSOR_BOX 0x0C10
/* Matrix modes */
#define GL_MATRIX_MODE 0x0BA0
#define GL_SCREENVIEW 0x00
#define GL_MODELVIEW 0x01
#define GL_PROJECTION 0x02
#define GL_TEXTURE 0x03
#define GL_IDENTITY 0x04
#define GL_RENDER 0x05
#define GL_MATRIX_COUNT 0x06
/* Depth buffer */
#define GL_NEVER 0x0200
#define GL_LESS 0x0201
#define GL_EQUAL 0x0202
#define GL_LEQUAL 0x0203
#define GL_GREATER 0x0204
#define GL_NOTEQUAL 0x0205
#define GL_GEQUAL 0x0206
#define GL_ALWAYS 0x0207
#define GL_DEPTH_TEST 0x0B71
#define GL_DEPTH_BITS 0x0D56
#define GL_DEPTH_CLEAR_VALUE 0x0B73
#define GL_DEPTH_FUNC 0x0B74
#define GL_DEPTH_RANGE 0x0B70
#define GL_DEPTH_WRITEMASK 0x0B72
#define GL_DEPTH_COMPONENT 0x1902
/* Blending: Simply Need to Map GL constants to PVR constants */
#define GL_BLEND 0x0BE2 /* capability bit */
#define GL_BLEND_DST 0x0BE0
#define GL_BLEND_SRC 0x0BE1
#define GL_ZERO 0x0
#define GL_ONE 0x1
#define GL_SRC_COLOR 0x0300
#define GL_ONE_MINUS_SRC_COLOR 0x0301
#define GL_SRC_ALPHA 0x0302
#define GL_ONE_MINUS_SRC_ALPHA 0x0303
#define GL_DST_ALPHA 0x0304
#define GL_ONE_MINUS_DST_ALPHA 0x0305
#define GL_DST_COLOR 0x0306
#define GL_ONE_MINUS_DST_COLOR 0x0307
#define GL_SRC_ALPHA_SATURATE 0x0308
/* Misc texture constants */
#define GL_TEXTURE_2D 0x0001 /* capability bit */
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_TEXTURE_FILTER GL_TEXTURE_MIN_FILTER
#define GL_FILTER_NONE 0x0
#define GL_FILTER_BILINEAR 0x1
#define GL_REPEAT 0x2901
#define GL_CLAMP 0x2900
/* Texture Environment */
#define GL_TEXTURE_ENV_MODE 0x2200
#define GL_REPLACE 0x0
#define GL_MODULATE 0x1
#define GL_DECAL 0x2
#define GL_MODULATEALPHA 0x3
/* TextureMagFilter */
#define GL_NEAREST 0x2600
#define GL_LINEAR 0x2601
/* Texture mapping */
#define GL_TEXTURE_ENV 0x2300
#define GL_TEXTURE_ENV_COLOR 0x2201
#define GL_NEAREST_MIPMAP_NEAREST 0x2700
#define GL_NEAREST_MIPMAP_LINEAR 0x2702
#define GL_LINEAR_MIPMAP_NEAREST 0x2701
#define GL_LINEAR_MIPMAP_LINEAR 0x2703
#define GL_MAX_TEXTURE_UNITS 0x2 /* 0 = Opaque, 1 = Translucent / Blended */
#define GL_TEXTURE_BINDING_2D 0x8069
/* TextureUnit */
#define GL_TEXTURE0 0x84C0
#define GL_TEXTURE1 0x84C1
#define GL_TEXTURE2 0x84C2
#define GL_TEXTURE3 0x84C3
#define GL_TEXTURE4 0x84C4
#define GL_TEXTURE5 0x84C5
#define GL_TEXTURE6 0x84C6
#define GL_TEXTURE7 0x84C7
#define GL_TEXTURE8 0x84C8
#define GL_TEXTURE9 0x84C9
#define GL_TEXTURE10 0x84CA
#define GL_TEXTURE11 0x84CB
#define GL_TEXTURE12 0x84CC
#define GL_TEXTURE13 0x84CD
#define GL_TEXTURE14 0x84CE
#define GL_TEXTURE15 0x84CF
#define GL_TEXTURE16 0x84D0
#define GL_TEXTURE17 0x84D1
#define GL_TEXTURE18 0x84D2
#define GL_TEXTURE19 0x84D3
#define GL_TEXTURE20 0x84D4
#define GL_TEXTURE21 0x84D5
#define GL_TEXTURE22 0x84D6
#define GL_TEXTURE23 0x84D7
#define GL_TEXTURE24 0x84D8
#define GL_TEXTURE25 0x84D9
#define GL_TEXTURE26 0x84DA
#define GL_TEXTURE27 0x84DB
#define GL_TEXTURE28 0x84DC
#define GL_TEXTURE29 0x84DD
#define GL_TEXTURE30 0x84DE
#define GL_TEXTURE31 0x84DF
#define GL_ACTIVE_TEXTURE 0x84E0
#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1
#define GL_CURRENT_BIT 0x00000001
#define GL_POINT_BIT 0x00000002
#define GL_LINE_BIT 0x00000004
#define GL_POLYGON_BIT 0x00000008
#define GL_POLYGON_STIPPLE_BIT 0x00000010
#define GL_PIXEL_MODE_BIT 0x00000020
#define GL_LIGHTING_BIT 0x00000040
#define GL_FOG_BIT 0x00000080
#define GL_DEPTH_BUFFER_BIT 0x00000100
#define GL_ACCUM_BUFFER_BIT 0x00000200
#define GL_STENCIL_BUFFER_BIT 0x00000400
#define GL_VIEWPORT_BIT 0x00000800
#define GL_TRANSFORM_BIT 0x00001000
#define GL_ENABLE_BIT 0x00002000
#define GL_COLOR_BUFFER_BIT 0x00004000
#define GL_HINT_BIT 0x00008000
#define GL_EVAL_BIT 0x00010000
#define GL_LIST_BIT 0x00020000
#define GL_TEXTURE_BIT 0x00040000
#define GL_SCISSOR_BIT 0x00080000
#define GL_ALL_ATTRIB_BITS 0x000FFFFF
/* Fog */
#define GL_FOG 0x0004 /* capability bit */
#define GL_FOG_MODE 0x0B65
#define GL_FOG_DENSITY 0x0B62
#define GL_FOG_COLOR 0x0B66
#define GL_FOG_INDEX 0x0B61
#define GL_FOG_START 0x0B63
#define GL_FOG_END 0x0B64
#define GL_LINEAR 0x2601
#define GL_EXP 0x0800
#define GL_EXP2 0x0801
/* Hints - Not used by the API, only here for compatibility */
#define GL_DONT_CARE 0x1100
#define GL_FASTEST 0x1101
#define GL_NICEST 0x1102
#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
#define GL_POINT_SMOOTH_HINT 0x0C51
#define GL_LINE_SMOOTH_HINT 0x0C52
#define GL_POLYGON_SMOOTH_HINT 0x0C53
#define GL_FOG_HINT 0x0C54
/* Lighting constants */
#define GL_MAX_LIGHTS 0x0008
#define GL_LIGHTING 0x0b50
#define GL_LIGHT0 0x4000
#define GL_LIGHT1 0x4001
#define GL_LIGHT2 0x4002
#define GL_LIGHT3 0x4003
#define GL_LIGHT4 0x4004
#define GL_LIGHT5 0x4005
#define GL_LIGHT6 0x4006
#define GL_LIGHT7 0x4007
/* LightParameter */
#define GL_AMBIENT 0x1200
#define GL_DIFFUSE 0x1201
#define GL_SPECULAR 0x1202
#define GL_POSITION 0x1203
#define GL_SPOT_DIRECTION 0x1204
#define GL_SPOT_EXPONENT 0x1205
#define GL_SPOT_CUTOFF 0x1206
#define GL_CONSTANT_ATTENUATION 0x1207
#define GL_LINEAR_ATTENUATION 0x1208
#define GL_QUADRATIC_ATTENUATION 0x1209
/* MaterialParameter */
#define GL_EMISSION 0x1600
#define GL_SHININESS 0x1601
#define GL_AMBIENT_AND_DIFFUSE 0x1602
#define GL_COLOR_INDEXES 0x1603
#define GL_COLOR_MATERIAL 0x0B57
#define GL_COLOR_MATERIAL_FACE 0x0B55
#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
#define GL_NORMALIZE 0x0BA1
#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
#define GL_LIGHT_MODEL_AMBIENT 0x0B53
#define GL_FRONT_AND_BACK 0x0408
#define GL_FRONT 0x0404
#define GL_BACK 0x0405
#define GL_SHADE_MODEL 0x0b54
#define GL_FLAT 0x1d00
#define GL_SMOOTH 0x1d01
/* Data types */
#define GL_BYTE 0x1400
#define GL_UNSIGNED_BYTE 0x1401
#define GL_SHORT 0x1402
#define GL_UNSIGNED_SHORT 0x1403
#define GL_INT 0x1404
#define GL_UNSIGNED_INT 0x1405
#define GL_FLOAT 0x1406
#define GL_DOUBLE 0x140A
#define GL_2_BYTES 0x1407
#define GL_3_BYTES 0x1408
#define GL_4_BYTES 0x1409
/* ErrorCode */
#define GL_NO_ERROR 0
#define GL_INVALID_ENUM 0x0500
#define GL_INVALID_VALUE 0x0501
#define GL_INVALID_OPERATION 0x0502
#define GL_STACK_OVERFLOW 0x0503
#define GL_STACK_UNDERFLOW 0x0504
#define GL_OUT_OF_MEMORY 0x0505
/* KOS near Z-CLIPPING */
#define GL_KOS_NEARZ_CLIPPING 0x0020 /* capability bit */
#define GL_UNSIGNED_SHORT_5_6_5 PVR_TXRFMT_RGB565
#define GL_UNSIGNED_SHORT_5_6_5_REV PVR_TXRFMT_RGB565
#define GL_UNSIGNED_SHORT_1_5_5_5 PVR_TXRFMT_ARGB1555
#define GL_UNSIGNED_SHORT_1_5_5_5_REV PVR_TXRFMT_ARGB1555
#define GL_UNSIGNED_SHORT_4_4_4_4 PVR_TXRFMT_ARGB4444
#define GL_UNSIGNED_SHORT_4_4_4_4_REV PVR_TXRFMT_ARGB4444
#define GL_RGB565_TWID PVR_TXRFMT_RGB565 | PVR_TXRFMT_TWIDDLED
#define GL_ARGB4444_TWID PVR_TXRFMT_ARGB4444 | PVR_TXRFMT_TWIDDLED
#define GL_RED 0x00
#define GL_RG 0x01
#define GL_RGB 0x02
#define GL_BGR 0x03
#define GL_RGBA 0x04
#define GL_BGRA 0x05
#define GLbyte char
#define GLshort short
#define GLint int
#define GLfloat float
#define GLdouble float
#define GLvoid void
#define GLushort unsigned short
#define GLuint unsigned int
#define GLenum unsigned int
#define GLsizei unsigned long
#define GLfixed const unsigned int
#define GLclampf float
#define GLubyte unsigned char
#define GLboolean int
#define GL_FALSE 0
#define GL_TRUE 1
#define GLAPI
#define APIENTRY
/* Initialize the GL pipeline. GL will initialize the PVR. */
GLAPI void APIENTRY glKosInit();
/* Start Submission of Primitive Data */
/* Currently Supported Primitive Types:
-GL_POINTS ( does NOT work with glDrawArrays )( ZClipping NOT supported )
-GL_TRIANGLES ( works with glDrawArrays )( ZClipping supported )
-GL_TRIANLGLE_STRIP ( works with glDrawArrays )( ZClipping supported )
-GL_QUADS ( works with glDrawArrays )( ZClipping supported )
**/
GLAPI void APIENTRY glBegin(GLenum mode);
/* Finish Submission of Primitive Data */
GLAPI void APIENTRY glEnd();
/* Primitive Texture Coordinate Submission */
GLAPI void APIENTRY glTexCoord2f(GLfloat u, GLfloat v);
GLAPI void APIENTRY glTexCoord2fv(GLfloat *uv);
/* Primitive Color Submission */
GLAPI void APIENTRY glColor1ui(GLuint argb);
GLAPI void APIENTRY glColor4ub(GLubyte r, GLubyte g, GLubyte b, GLubyte a);
GLAPI void APIENTRY glColor3f(GLfloat r, GLfloat g, GLfloat b);
GLAPI void APIENTRY glColor3fv(GLfloat *rgb);
GLAPI void APIENTRY glColor4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
GLAPI void APIENTRY glColor4fv(GLfloat *rgba);
/* Primitive Normal Submission */
GLAPI void APIENTRY glNormal3f(float x, float y, float z);
GLAPI void APIENTRY glNormal3fv(float *xyz);
/* Primitive 2D Position Submission */
GLAPI void APIENTRY(*glVertex2f)(float, float);
GLAPI void APIENTRY(*glVertex2fv)(float *);
/* Primitive 3D Position Submission */
GLAPI void APIENTRY(*glVertex3f)(float, float, float);
GLAPI void APIENTRY(*glVertex3fv)(float *);
/* Enable / Disable Capability */
/* Currently Supported Capabilities:
GL_TEXTURE_2D
GL_BLEND
GL_DEPTH_TEST
GL_LIGHTING
GL_SCISSOR_TEST
GL_FOG
GL_CULL_FACE
GL_KOS_NEARZ_CLIPPING
*/
GLAPI void APIENTRY glEnable(GLenum cap);
GLAPI void APIENTRY glDisable(GLenum cap);
/* Clear Caps */
GLAPI void APIENTRY glClear(GLuint mode);
GLAPI void APIENTRY glClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
/* Depth Testing */
GLAPI void APIENTRY glClearDepthf(GLfloat depth);
#define glClearDepth glClearDepthf
GLAPI void APIENTRY glDepthMask(GLboolean flag);
GLAPI void APIENTRY glDepthFunc(GLenum func);
/* Hints */
/* Currently Supported Capabilities:
GL_PERSPECTIVE_CORRECTION_HINT - This will Enable Texture Super-Sampling on the PVR */
GLAPI void APIENTRY glHint(GLenum target, GLenum mode);
/* Culling */
GLAPI void APIENTRY glFrontFace(GLenum mode);
GLAPI void APIENTRY glCullFace(GLenum mode);
/* Shading - Flat or Goraud */
GLAPI void APIENTRY glShadeModel(GLenum mode);
/* Blending */
GLAPI void APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor);
/* Texturing */
GLAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY glGenTextures(GLsizei n, GLuint *textures);
GLAPI void APIENTRY glDelTextures(GLsizei n, GLuint *textures);
GLAPI void APIENTRY glBindTexture(GLenum target, GLuint texture);
/* Loads texture from SH4 RAM into PVR VRAM */
GLAPI void APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalFormat,
GLsizei width, GLsizei height, GLint border,
GLenum format, GLenum type, GLvoid *data);
/* Bind a Texture that is already in PVR VRAM */
GLAPI void APIENTRY glKosTexImage2D(GLenum target, GLint level, GLint internalFormat,
GLsizei width, GLsizei height, GLint border,
GLenum format, GLenum type, GLvoid *data);
/* GL Array API - Only GL_TRIANGLES, GL_TRIANGLE_STRIP, and GL_QUADS are supported */
GLAPI void APIENTRY glVertexPointer(GLint size, GLenum type,
GLsizei stride, const GLvoid *pointer);
GLAPI void APIENTRY glTexCoordPointer(GLint size, GLenum type,
GLsizei stride, const GLvoid *pointer);
/* If a Normal Pointer is set and GL Lighting has been enabled,
Vertex Lighting will be used instead of glColorPointer */
GLAPI void APIENTRY glNormalPointer(GLint size, GLenum type,
GLsizei stride, const GLvoid *pointer);
/* Use either this OR glNormalPointer to color vertices, NOT both */
GLAPI void APIENTRY glColorPointer(GLint size, GLenum type,
GLsizei stride, const GLvoid *pointer);
GLAPI void APIENTRY glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
/* Array Data Submission */
GLAPI void APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count);
GLAPI void APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
/* No need to Enable Array Client State... */
#define glEnableClientState(cap) {;}
#define glDisableClientState(cap) {;}
/* Transformation / Matrix Functions */
GLAPI void APIENTRY glMatrixMode(GLenum mode);
GLAPI void APIENTRY glLoadIdentity();
GLAPI void APIENTRY glLoadMatrixf(const GLfloat *m);
GLAPI void APIENTRY glLoadTransposeMatrixf(const GLfloat *m);
GLAPI void APIENTRY glMultMatrixf(const GLfloat *m);
GLAPI void APIENTRY glMultTransposeMatrixf(const GLfloat *m);
GLAPI void APIENTRY glPushMatrix();
GLAPI void APIENTRY glPopMatrix();
GLAPI void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z);
#define glTranslated glTranslatef
GLAPI void APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z);
#define glScaled glScalef
GLAPI void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
#define glRotated glRotatef
GLAPI void APIENTRY glOrtho(GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat znear, GLfloat zfar);
GLAPI void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
/* Fog Functions - client must enable GL_FOG for this to take effect */
GLAPI void APIENTRY glFogi(GLenum pname, GLint param);
GLAPI void APIENTRY glFogf(GLenum pname, GLfloat param);
GLAPI void APIENTRY glFogfv(GLenum pname, const GLfloat *params);
/* Lighting Functions - client must enable GL_LIGHTING for this to take effect */
/* Set Global Ambient Light Color */
GLAPI void APIENTRY glKosLightAmbient3f(GLfloat r, GLfloat g, GLfloat b);
GLAPI void APIENTRY glKosLightAmbient4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
GLAPI void APIENTRY glKosLightAmbient3fv(GLfloat *rgb);
GLAPI void APIENTRY glKosLightAmbient4fv(GLfloat *rgba);
/* Set Individual Light Parameters */
GLAPI void APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param);
/* Set Global Material Parameters */
GLAPI void APIENTRY glMateriali(GLenum face, GLenum pname, const GLint param);
GLAPI void APIENTRY glMaterialf(GLenum face, GLenum pname, const GLfloat param);
GLAPI void APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
/* Returns the size needed to store a mip-mapped texture generated by gluBuild2DMipmaps(...) */
GLAPI GLuint APIENTRY glKosMipMapTexSize(GLuint width, GLuint height);
/* glGet Functions */
void glGetIntegerv(GLenum pname, GLint *params);
/* Multi-Texture Extensions */
GLAPI void APIENTRY glActiveTexture(GLenum texture);
GLAPI void APIENTRY glClientActiveTexture(GLenum texture);
GLAPI void APIENTRY glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);
GLAPI void APIENTRY glMultiTexCoord2fv(GLenum target, const GLfloat *v);
__END_DECLS
#endif /* !__GL_GL_H */

67
include/glu.h Normal file → Executable file
View File

@ -1,22 +1,45 @@
#ifndef __GL_GLU_H
#define __GL_GLU_H
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <GL/gl.h>
#define GLU_FALSE 0
#define GLU_TRUE 1
void gluPerspective(GLfloat fovy, GLfloat aspect, GLfloat zNear,
GLfloat zFar);
void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez, GLfloat centerx,
GLfloat centery, GLfloat centerz, GLfloat upx, GLfloat upy,
GLfloat upz);
__END_DECLS
#endif /* __GL_GLU_H */
/* KallistiGL for KallistiOS ##version##
libgl/glu.h
Copyright (C) 2013-2014 Josh "PH3NOM" Pearson
Some functionality adapted from the original KOS libgl:
Copyright (C) 2001 Dan Potter
Copyright (C) 2002 Benoit Miller
*/
#ifndef __GL_GLU_H
#define __GL_GLU_H
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <GL/gl.h>
#define GLU_FALSE GL_FALSE
#define GLU_TRUE GL_TRUE
/* Mip-Mapped Textures MUST be square or rectangle */
GLAPI GLint APIENTRY gluBuild2DMipmaps(GLenum target, GLint internalFormat,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
const void *data);
/* gluPerspective - Set the Perspective for Rendering. */
GLAPI void APIENTRY gluPerspective(GLdouble fovy, GLdouble aspect,
GLdouble zNear, GLdouble zFar);
/* gluLookAt - Set Camera Position for Rendering. */
GLAPI void APIENTRY gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez,
GLfloat centerx, GLfloat centery, GLfloat centerz,
GLfloat upx, GLfloat upy, GLfloat upz);
/* glhLookAtf2 = gluLookAt operating on 3 float vectors. */
GLAPI void APIENTRY glhLookAtf2(GLfloat *eyePosition3D,
GLfloat *center3D,
GLfloat *upVector3D);
__END_DECLS
#endif /* !__GL_GLU_H */