remove unused api
This commit is contained in:
David Rose
parent
d0c4d4f8fc
commit
e7e305e522
|
|
@ -21,11 +21,11 @@
|
|||
tinyTextureContext.I tinyTextureContext.cxx tinyTextureContext.h \
|
||||
tinyXGraphicsPipe.I tinyXGraphicsPipe.cxx tinyXGraphicsPipe.h \
|
||||
tinyXGraphicsWindow.h tinyXGraphicsWindow.I tinyXGraphicsWindow.cxx \
|
||||
api.c arrays.c clear.c clip.c error.c get.c \
|
||||
glu.c image_util.c init.c light.c list.c \
|
||||
matrix.c memory.c misc.c msghandling.c msghandling.h \
|
||||
opinfo.h oscontext.c oscontext.h select.c specbuf.c \
|
||||
specbuf.h texture.c tinygl.h tinyglu.h vertex.c \
|
||||
clip.c error.c \
|
||||
image_util.c init.c light.c \
|
||||
memory.c msghandling.c msghandling.h \
|
||||
specbuf.c \
|
||||
texture.c vertex.c \
|
||||
zbuffer.c zbuffer.h zdither.c zfeatures.h zgl.h zline.c \
|
||||
zline.h zmath.c zmath.h ztriangle.c ztriangle.h ztriangle_two.h
|
||||
|
||||
|
|
|
|||
|
|
@ -1,589 +0,0 @@
|
|||
#include "zgl.h"
|
||||
#include <stdio.h>
|
||||
/* glVertex */
|
||||
|
||||
void glVertex4f(float x,float y,float z,float w)
|
||||
{
|
||||
GLParam p[5];
|
||||
|
||||
p[0].op=OP_Vertex;
|
||||
p[1].f=x;
|
||||
p[2].f=y;
|
||||
p[3].f=z;
|
||||
p[4].f=w;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glVertex2f(float x,float y)
|
||||
{
|
||||
glVertex4f(x,y,0,1);
|
||||
}
|
||||
|
||||
void glVertex3f(float x,float y,float z)
|
||||
{
|
||||
glVertex4f(x,y,z,1);
|
||||
}
|
||||
|
||||
void glVertex3fv(float *v)
|
||||
{
|
||||
glVertex4f(v[0],v[1],v[2],1);
|
||||
}
|
||||
|
||||
/* glNormal */
|
||||
|
||||
void glNormal3f(float x,float y,float z)
|
||||
{
|
||||
GLParam p[4];
|
||||
|
||||
p[0].op=OP_Normal;
|
||||
p[1].f=x;
|
||||
p[2].f=y;
|
||||
p[3].f=z;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glNormal3fv(float *v)
|
||||
{
|
||||
glNormal3f(v[0],v[1],v[2]);
|
||||
}
|
||||
|
||||
/* glColor */
|
||||
|
||||
void glColor4f(float r,float g,float b,float a)
|
||||
{
|
||||
GLParam p[8];
|
||||
|
||||
p[0].op=OP_Color;
|
||||
p[1].f=r;
|
||||
p[2].f=g;
|
||||
p[3].f=b;
|
||||
p[4].f=a;
|
||||
/* direct convertion to integer to go faster if no shading */
|
||||
p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) +
|
||||
ZB_POINT_RED_MIN);
|
||||
p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) +
|
||||
ZB_POINT_GREEN_MIN);
|
||||
p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) +
|
||||
ZB_POINT_BLUE_MIN);
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glColor4fv(float *v)
|
||||
{
|
||||
GLParam p[8];
|
||||
|
||||
p[0].op=OP_Color;
|
||||
p[1].f=v[0];
|
||||
p[2].f=v[1];
|
||||
p[3].f=v[2];
|
||||
p[4].f=v[3];
|
||||
/* direct convertion to integer to go faster if no shading */
|
||||
p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) +
|
||||
ZB_POINT_RED_MIN);
|
||||
p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) +
|
||||
ZB_POINT_GREEN_MIN);
|
||||
p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) +
|
||||
ZB_POINT_BLUE_MIN);
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glColor3f(float x,float y,float z)
|
||||
{
|
||||
glColor4f(x,y,z,1);
|
||||
}
|
||||
|
||||
void glColor3fv(float *v)
|
||||
{
|
||||
glColor4f(v[0],v[1],v[2],1);
|
||||
}
|
||||
|
||||
|
||||
/* TexCoord */
|
||||
|
||||
void glTexCoord4f(float s,float t,float r,float q)
|
||||
{
|
||||
GLParam p[5];
|
||||
|
||||
p[0].op=OP_TexCoord;
|
||||
p[1].f=s;
|
||||
p[2].f=t;
|
||||
p[3].f=r;
|
||||
p[4].f=q;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glTexCoord2f(float s,float t)
|
||||
{
|
||||
glTexCoord4f(s,t,0,1);
|
||||
}
|
||||
|
||||
void glTexCoord2fv(float *v)
|
||||
{
|
||||
glTexCoord4f(v[0],v[1],0,1);
|
||||
}
|
||||
|
||||
void glEdgeFlag(int flag)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_EdgeFlag;
|
||||
p[1].i=flag;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* misc */
|
||||
|
||||
void glShadeModel(int mode)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
assert(mode == GL_FLAT || mode == GL_SMOOTH);
|
||||
|
||||
p[0].op=OP_ShadeModel;
|
||||
p[1].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glCullFace(int mode)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
assert(mode == GL_BACK ||
|
||||
mode == GL_FRONT ||
|
||||
mode == GL_FRONT_AND_BACK);
|
||||
|
||||
p[0].op=OP_CullFace;
|
||||
p[1].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glFrontFace(int mode)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
assert(mode == GL_CCW || mode == GL_CW);
|
||||
|
||||
mode = (mode != GL_CCW);
|
||||
|
||||
p[0].op=OP_FrontFace;
|
||||
p[1].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glPolygonMode(int face,int mode)
|
||||
{
|
||||
GLParam p[3];
|
||||
|
||||
assert(face == GL_BACK ||
|
||||
face == GL_FRONT ||
|
||||
face == GL_FRONT_AND_BACK);
|
||||
assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
|
||||
|
||||
p[0].op=OP_PolygonMode;
|
||||
p[1].i=face;
|
||||
p[2].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
|
||||
/* glEnable / glDisable */
|
||||
|
||||
void glEnable(int cap)
|
||||
{
|
||||
GLParam p[3];
|
||||
|
||||
p[0].op=OP_EnableDisable;
|
||||
p[1].i=cap;
|
||||
p[2].i=1;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glDisable(int cap)
|
||||
{
|
||||
GLParam p[3];
|
||||
|
||||
p[0].op=OP_EnableDisable;
|
||||
p[1].i=cap;
|
||||
p[2].i=0;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* glBegin / glEnd */
|
||||
|
||||
void glBegin(int mode)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_Begin;
|
||||
p[1].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glEnd(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_End;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* matrix */
|
||||
|
||||
void glMatrixMode(int mode)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_MatrixMode;
|
||||
p[1].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLoadMatrixf(const float *m)
|
||||
{
|
||||
GLParam p[17];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_LoadMatrix;
|
||||
for(i=0;i<16;i++) p[i+1].f=m[i];
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLoadIdentity(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_LoadIdentity;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glMultMatrixf(const float *m)
|
||||
{
|
||||
GLParam p[17];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_MultMatrix;
|
||||
for(i=0;i<16;i++) p[i+1].f=m[i];
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glPushMatrix(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_PushMatrix;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glPopMatrix(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_PopMatrix;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glRotatef(float angle,float x,float y,float z)
|
||||
{
|
||||
GLParam p[5];
|
||||
|
||||
p[0].op=OP_Rotate;
|
||||
p[1].f=angle;
|
||||
p[2].f=x;
|
||||
p[3].f=y;
|
||||
p[4].f=z;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glTranslatef(float x,float y,float z)
|
||||
{
|
||||
GLParam p[4];
|
||||
|
||||
p[0].op=OP_Translate;
|
||||
p[1].f=x;
|
||||
p[2].f=y;
|
||||
p[3].f=z;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glScalef(float x,float y,float z)
|
||||
{
|
||||
GLParam p[4];
|
||||
|
||||
p[0].op=OP_Scale;
|
||||
p[1].f=x;
|
||||
p[2].f=y;
|
||||
p[3].f=z;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
|
||||
void glViewport(int x,int y,int width,int height)
|
||||
{
|
||||
GLParam p[5];
|
||||
|
||||
p[0].op=OP_Viewport;
|
||||
p[1].i=x;
|
||||
p[2].i=y;
|
||||
p[3].i=width;
|
||||
p[4].i=height;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glFrustum(double left,double right,double bottom,double top,
|
||||
double near,double farv)
|
||||
{
|
||||
GLParam p[7];
|
||||
|
||||
p[0].op=OP_Frustum;
|
||||
p[1].f=left;
|
||||
p[2].f=right;
|
||||
p[3].f=bottom;
|
||||
p[4].f=top;
|
||||
p[5].f=near;
|
||||
p[6].f=farv;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* lightening */
|
||||
|
||||
void glMaterialfv(int mode,int type,float *v)
|
||||
{
|
||||
GLParam p[7];
|
||||
int i,n;
|
||||
|
||||
assert(mode == GL_FRONT || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
|
||||
|
||||
p[0].op=OP_Material;
|
||||
p[1].i=mode;
|
||||
p[2].i=type;
|
||||
n=4;
|
||||
if (type == GL_SHININESS) n=1;
|
||||
for(i=0;i<4;i++) p[3+i].f=v[i];
|
||||
for(i=n;i<4;i++) p[3+i].f=0;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glMaterialf(int mode,int type,float v)
|
||||
{
|
||||
GLParam p[7];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_Material;
|
||||
p[1].i=mode;
|
||||
p[2].i=type;
|
||||
p[3].f=v;
|
||||
for(i=0;i<3;i++) p[4+i].f=0;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glColorMaterial(int mode,int type)
|
||||
{
|
||||
GLParam p[3];
|
||||
|
||||
p[0].op=OP_ColorMaterial;
|
||||
p[1].i=mode;
|
||||
p[2].i=type;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLightfv(int light,int type,float *v)
|
||||
{
|
||||
GLParam p[7];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_Light;
|
||||
p[1].i=light;
|
||||
p[2].i=type;
|
||||
/* TODO: 3 composants ? */
|
||||
for(i=0;i<4;i++) p[3+i].f=v[i];
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
|
||||
void glLightf(int light,int type,float v)
|
||||
{
|
||||
GLParam p[7];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_Light;
|
||||
p[1].i=light;
|
||||
p[2].i=type;
|
||||
p[3].f=v;
|
||||
for(i=0;i<3;i++) p[4+i].f=0;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLightModeli(int pname,int param)
|
||||
{
|
||||
GLParam p[6];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_LightModel;
|
||||
p[1].i=pname;
|
||||
p[2].f=(float)param;
|
||||
for(i=0;i<4;i++) p[3+i].f=0;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLightModelfv(int pname,float *param)
|
||||
{
|
||||
GLParam p[6];
|
||||
int i;
|
||||
|
||||
p[0].op=OP_LightModel;
|
||||
p[1].i=pname;
|
||||
for(i=0;i<4;i++) p[2+i].f=param[i];
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* clear */
|
||||
|
||||
void glClear(int mask)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_Clear;
|
||||
p[1].i=mask;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glClearColor(float r,float g,float b,float a)
|
||||
{
|
||||
GLParam p[5];
|
||||
|
||||
p[0].op=OP_ClearColor;
|
||||
p[1].f=r;
|
||||
p[2].f=g;
|
||||
p[3].f=b;
|
||||
p[4].f=a;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glClearDepth(double depth)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_ClearDepth;
|
||||
p[1].f=depth;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
|
||||
/* selection */
|
||||
|
||||
void glInitNames(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_InitNames;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glPushName(unsigned int name)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_PushName;
|
||||
p[1].i=name;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glPopName(void)
|
||||
{
|
||||
GLParam p[1];
|
||||
|
||||
p[0].op=OP_PopName;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glLoadName(unsigned int name)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_LoadName;
|
||||
p[1].i=name;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void
|
||||
glPolygonOffset(GLfloat factor, GLfloat units)
|
||||
{
|
||||
GLParam p[3];
|
||||
p[0].op = OP_PolygonOffset;
|
||||
p[1].f = factor;
|
||||
p[2].f = units;
|
||||
}
|
||||
|
||||
/* Special Functions */
|
||||
|
||||
void glCallList(unsigned int list)
|
||||
{
|
||||
GLParam p[2];
|
||||
|
||||
p[0].op=OP_CallList;
|
||||
p[1].i=list;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void glFlush(void)
|
||||
{
|
||||
/* nothing to do */
|
||||
}
|
||||
|
||||
void glHint(int target,int mode)
|
||||
{
|
||||
GLParam p[3];
|
||||
|
||||
p[0].op=OP_Hint;
|
||||
p[1].i=target;
|
||||
p[2].i=mode;
|
||||
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
/* Non standard functions */
|
||||
|
||||
void glDebug(int mode)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
c->print_flag=mode;
|
||||
}
|
||||
|
||||
|
|
@ -1,206 +0,0 @@
|
|||
#include "zgl.h"
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define VERTEX_ARRAY 0x0001
|
||||
#define COLOR_ARRAY 0x0002
|
||||
#define NORMAL_ARRAY 0x0004
|
||||
#define TEXCOORD_ARRAY 0x0008
|
||||
|
||||
void
|
||||
glopArrayElement(GLContext *c, GLParam *param)
|
||||
{
|
||||
int i;
|
||||
int states = c->client_states;
|
||||
int idx = param[1].i;
|
||||
|
||||
if (states & COLOR_ARRAY) {
|
||||
GLParam p[5];
|
||||
int size = c->color_array_size;
|
||||
i = idx * (size + c->color_array_stride);
|
||||
p[1].f = c->color_array[i];
|
||||
p[2].f = c->color_array[i+1];
|
||||
p[3].f = c->color_array[i+2];
|
||||
p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
|
||||
glopColor(c, p);
|
||||
}
|
||||
if (states & NORMAL_ARRAY) {
|
||||
i = idx * (3 + c->normal_array_stride);
|
||||
c->current_normal.X = c->normal_array[i];
|
||||
c->current_normal.Y = c->normal_array[i+1];
|
||||
c->current_normal.Z = c->normal_array[i+2];
|
||||
c->current_normal.Z = 0.0f;
|
||||
}
|
||||
if (states & TEXCOORD_ARRAY) {
|
||||
int size = c->texcoord_array_size;
|
||||
i = idx * (size + c->texcoord_array_stride);
|
||||
c->current_tex_coord.X = c->texcoord_array[i];
|
||||
c->current_tex_coord.Y = c->texcoord_array[i+1];
|
||||
c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
|
||||
c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
|
||||
}
|
||||
if (states & VERTEX_ARRAY) {
|
||||
GLParam p[5];
|
||||
int size = c->vertex_array_size;
|
||||
i = idx * (size + c->vertex_array_stride);
|
||||
p[1].f = c->vertex_array[i];
|
||||
p[2].f = c->vertex_array[i+1];
|
||||
p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
|
||||
p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
|
||||
glopVertex(c, p);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
glArrayElement(GLint i)
|
||||
{
|
||||
GLParam p[2];
|
||||
p[0].op = OP_ArrayElement;
|
||||
p[1].i = i;
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
glopEnableClientState(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->client_states |= p[1].i;
|
||||
}
|
||||
|
||||
void
|
||||
glEnableClientState(GLenum array)
|
||||
{
|
||||
GLParam p[2];
|
||||
p[0].op = OP_EnableClientState;
|
||||
|
||||
switch(array) {
|
||||
case GL_VERTEX_ARRAY:
|
||||
p[1].i = VERTEX_ARRAY;
|
||||
break;
|
||||
case GL_NORMAL_ARRAY:
|
||||
p[1].i = NORMAL_ARRAY;
|
||||
break;
|
||||
case GL_COLOR_ARRAY:
|
||||
p[1].i = COLOR_ARRAY;
|
||||
break;
|
||||
case GL_TEXTURE_COORD_ARRAY:
|
||||
p[1].i = TEXCOORD_ARRAY;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void
|
||||
glopDisableClientState(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->client_states &= p[1].i;
|
||||
}
|
||||
|
||||
void
|
||||
glDisableClientState(GLenum array)
|
||||
{
|
||||
GLParam p[2];
|
||||
p[0].op = OP_DisableClientState;
|
||||
|
||||
switch(array) {
|
||||
case GL_VERTEX_ARRAY:
|
||||
p[1].i = ~VERTEX_ARRAY;
|
||||
break;
|
||||
case GL_NORMAL_ARRAY:
|
||||
p[1].i = ~NORMAL_ARRAY;
|
||||
break;
|
||||
case GL_COLOR_ARRAY:
|
||||
p[1].i = ~COLOR_ARRAY;
|
||||
break;
|
||||
case GL_TEXTURE_COORD_ARRAY:
|
||||
p[1].i = ~TEXCOORD_ARRAY;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void
|
||||
glopVertexPointer(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->vertex_array_size = p[1].i;
|
||||
c->vertex_array_stride = p[2].i;
|
||||
c->vertex_array = p[3].p;
|
||||
}
|
||||
|
||||
void
|
||||
glVertexPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer)
|
||||
{
|
||||
GLParam p[4];
|
||||
assert(type == GL_FLOAT);
|
||||
p[0].op = OP_VertexPointer;
|
||||
p[1].i = size;
|
||||
p[2].i = stride;
|
||||
p[3].p = (void*)pointer;
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void
|
||||
glopColorPointer(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->color_array_size = p[1].i;
|
||||
c->color_array_stride = p[2].i;
|
||||
c->color_array = p[3].p;
|
||||
}
|
||||
|
||||
void
|
||||
glColorPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer)
|
||||
{
|
||||
GLParam p[4];
|
||||
assert(type == GL_FLOAT);
|
||||
p[0].op = OP_ColorPointer;
|
||||
p[1].i = size;
|
||||
p[2].i = stride;
|
||||
p[3].p = (void*)pointer;
|
||||
gl_add_op(p);
|
||||
}
|
||||
|
||||
void
|
||||
glopNormalPointer(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->normal_array_stride = p[1].i;
|
||||
c->normal_array = p[2].p;
|
||||
}
|
||||
|
||||
void
|
||||
glNormalPointer(GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer)
|
||||
{
|
||||
GLParam p[3];
|
||||
assert(type == GL_FLOAT);
|
||||
p[0].op = OP_NormalPointer;
|
||||
p[1].i = stride;
|
||||
p[2].p = (void*)pointer;
|
||||
}
|
||||
|
||||
void
|
||||
glopTexCoordPointer(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->texcoord_array_size = p[1].i;
|
||||
c->texcoord_array_stride = p[2].i;
|
||||
c->texcoord_array = p[3].p;
|
||||
}
|
||||
|
||||
void
|
||||
glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer)
|
||||
{
|
||||
GLParam p[4];
|
||||
assert(type == GL_FLOAT);
|
||||
p[0].op = OP_TexCoordPointer;
|
||||
p[1].i = size;
|
||||
p[2].i = stride;
|
||||
p[3].p = (void*)pointer;
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
#include "zgl.h"
|
||||
|
||||
|
||||
void glopClearColor(GLContext *c,GLParam *p)
|
||||
{
|
||||
c->clear_color.v[0]=p[1].f;
|
||||
c->clear_color.v[1]=p[2].f;
|
||||
c->clear_color.v[2]=p[3].f;
|
||||
c->clear_color.v[3]=p[4].f;
|
||||
}
|
||||
void glopClearDepth(GLContext *c,GLParam *p)
|
||||
{
|
||||
c->clear_depth=p[1].f;
|
||||
}
|
||||
|
||||
|
||||
void glopClear(GLContext *c,GLParam *p)
|
||||
{
|
||||
int mask=p[1].i;
|
||||
int z=0;
|
||||
int r=(int)(c->clear_color.v[0]*65535);
|
||||
int g=(int)(c->clear_color.v[1]*65535);
|
||||
int b=(int)(c->clear_color.v[2]*65535);
|
||||
|
||||
/* TODO : correct value of Z */
|
||||
|
||||
ZB_clear(c->zb,mask & GL_DEPTH_BUFFER_BIT,z,
|
||||
mask & GL_COLOR_BUFFER_BIT,r,g,b,0);
|
||||
}
|
||||
|
||||
|
|
@ -41,28 +41,12 @@ void gl_transform_to_viewport(GLContext *c,GLVertex *v)
|
|||
}
|
||||
|
||||
|
||||
static void gl_add_select1(GLContext *c,int z1,int z2,int z3)
|
||||
{
|
||||
unsigned int min,max;
|
||||
min=max=z1;
|
||||
if (z2<min) min=z2;
|
||||
if (z3<min) min=z3;
|
||||
if (z2>max) max=z2;
|
||||
if (z3>max) max=z3;
|
||||
|
||||
gl_add_select(c,0xffffffff-min,0xffffffff-max);
|
||||
}
|
||||
|
||||
/* point */
|
||||
|
||||
void gl_draw_point(GLContext *c,GLVertex *p0)
|
||||
{
|
||||
if (p0->clip_code == 0) {
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
gl_add_select(c,p0->zp.z,p0->zp.z);
|
||||
} else {
|
||||
ZB_plot(c->zb,&p0->zp);
|
||||
}
|
||||
ZB_plot(c->zb,&p0->zp);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -114,14 +98,10 @@ void gl_draw_line(GLContext *c,GLVertex *p1,GLVertex *p2)
|
|||
cc2=p2->clip_code;
|
||||
|
||||
if ( (cc1 | cc2) == 0) {
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
gl_add_select1(c,p1->zp.z,p2->zp.z,p2->zp.z);
|
||||
} else {
|
||||
if (c->depth_test)
|
||||
ZB_line_z(c->zb,&p1->zp,&p2->zp);
|
||||
else
|
||||
ZB_line(c->zb,&p1->zp,&p2->zp);
|
||||
}
|
||||
if (c->depth_test)
|
||||
ZB_line_z(c->zb,&p1->zp,&p2->zp);
|
||||
else
|
||||
ZB_line(c->zb,&p1->zp,&p2->zp);
|
||||
} else if ( (cc1&cc2) != 0 ) {
|
||||
return;
|
||||
} else {
|
||||
|
|
@ -209,7 +189,7 @@ float (*clip_proc[6])(V4 *,V4 *,V4 *)= {
|
|||
static inline void updateTmp(GLContext *c,
|
||||
GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
|
||||
{
|
||||
if (c->current_shade_model == GL_SMOOTH) {
|
||||
if (c->smooth_shade_model) {
|
||||
q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t;
|
||||
q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t;
|
||||
q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t;
|
||||
|
|
@ -260,14 +240,12 @@ void gl_draw_triangle(GLContext *c,
|
|||
/* back face culling */
|
||||
if (c->cull_face_enabled) {
|
||||
/* most used case first */
|
||||
if (c->current_cull_face == GL_BACK) {
|
||||
if (c->cull_clockwise) {
|
||||
if (front == 0) return;
|
||||
c->draw_triangle_front(c,p0,p1,p2);
|
||||
} else if (c->current_cull_face == GL_FRONT) {
|
||||
} else {
|
||||
if (front != 0) return;
|
||||
c->draw_triangle_back(c,p0,p1,p2);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
/* no culling */
|
||||
|
|
@ -366,12 +344,6 @@ static void gl_draw_triangle_clip(GLContext *c,
|
|||
}
|
||||
|
||||
|
||||
void gl_draw_triangle_select(GLContext *c,
|
||||
GLVertex *p0,GLVertex *p1,GLVertex *p2)
|
||||
{
|
||||
gl_add_select1(c,p0->zp.z,p1->zp.z,p2->zp.z);
|
||||
}
|
||||
|
||||
#ifdef PROFILE
|
||||
int count_triangles,count_triangles_textured,count_pixels;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,72 +0,0 @@
|
|||
#include "zgl.h"
|
||||
|
||||
void glGetIntegerv(int pname,int *params)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
|
||||
switch(pname) {
|
||||
case GL_VIEWPORT:
|
||||
params[0]=c->viewport.xmin;
|
||||
params[1]=c->viewport.ymin;
|
||||
params[2]=c->viewport.xsize;
|
||||
params[3]=c->viewport.ysize;
|
||||
break;
|
||||
case GL_MAX_MODELVIEW_STACK_DEPTH:
|
||||
*params = MAX_MODELVIEW_STACK_DEPTH;
|
||||
break;
|
||||
case GL_MAX_PROJECTION_STACK_DEPTH:
|
||||
*params = MAX_PROJECTION_STACK_DEPTH;
|
||||
break;
|
||||
case GL_MAX_LIGHTS:
|
||||
*params = MAX_LIGHTS;
|
||||
break;
|
||||
case GL_MAX_TEXTURE_SIZE:
|
||||
*params = 256; /* not completely true, but... */
|
||||
break;
|
||||
case GL_MAX_TEXTURE_STACK_DEPTH:
|
||||
*params = MAX_TEXTURE_STACK_DEPTH;
|
||||
break;
|
||||
default:
|
||||
gl_fatal_error("glGet: option not implemented");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void glGetFloatv(int pname, float *v)
|
||||
{
|
||||
int i;
|
||||
int mnr = 0; /* just a trick to return the correct matrix */
|
||||
GLContext *c = gl_get_context();
|
||||
switch (pname) {
|
||||
case GL_TEXTURE_MATRIX:
|
||||
mnr++;
|
||||
case GL_PROJECTION_MATRIX:
|
||||
mnr++;
|
||||
case GL_MODELVIEW_MATRIX:
|
||||
{
|
||||
float *p = &c->matrix_stack_ptr[mnr]->m[0][0];;
|
||||
for (i = 0; i < 4; i++) {
|
||||
*v++ = p[0];
|
||||
*v++ = p[4];
|
||||
*v++ = p[8];
|
||||
*v++ = p[12];
|
||||
p++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case GL_LINE_WIDTH:
|
||||
*v = 1.0f;
|
||||
break;
|
||||
case GL_LINE_WIDTH_RANGE:
|
||||
v[0] = v[1] = 1.0f;
|
||||
break;
|
||||
case GL_POINT_SIZE:
|
||||
*v = 1.0f;
|
||||
break;
|
||||
case GL_POINT_SIZE_RANGE:
|
||||
v[0] = v[1] = 1.0f;
|
||||
default:
|
||||
fprintf(stderr,"warning: unknown pname in glGetFloatv()\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,261 +0,0 @@
|
|||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "tinygl.h"
|
||||
#include "tinyglu.h"
|
||||
|
||||
|
||||
void drawTorus(float rc, int numc, float rt, int numt)
|
||||
{
|
||||
int i, j, k;
|
||||
double s, t;
|
||||
double x, y, z;
|
||||
double pi, twopi;
|
||||
|
||||
pi = 3.14159265358979323846;
|
||||
twopi = 2 * pi;
|
||||
|
||||
for (i = 0; i < numc; i++) {
|
||||
glBegin(GL_QUAD_STRIP);
|
||||
for (j = 0; j <= numt; j++) {
|
||||
for (k = 1; k >= 0; k--) {
|
||||
s = (i + k) % numc + 0.5;
|
||||
t = j % numt;
|
||||
|
||||
x = cos(t*twopi/numt) * cos(s*twopi/numc);
|
||||
y = sin(t*twopi/numt) * cos(s*twopi/numc);
|
||||
z = sin(s*twopi/numc);
|
||||
glNormal3f(x, y, z);
|
||||
|
||||
x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt);
|
||||
y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt);
|
||||
z = rc * sin(s*twopi/numc);
|
||||
glVertex3f(x, y, z);
|
||||
}
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
}
|
||||
|
||||
static void normal3f( GLfloat x, GLfloat y, GLfloat z )
|
||||
{
|
||||
GLdouble mag;
|
||||
|
||||
mag = sqrt( x*x + y*y + z*z );
|
||||
if (mag>0.00001F) {
|
||||
x /= mag;
|
||||
y /= mag;
|
||||
z /= mag;
|
||||
}
|
||||
glNormal3f( x, y, z );
|
||||
}
|
||||
|
||||
void gluPerspective( GLdouble fovy, GLdouble aspect,
|
||||
GLdouble zNear, GLdouble zFar )
|
||||
{
|
||||
GLdouble xmin, xmax, ymin, ymax;
|
||||
|
||||
ymax = zNear * tan( fovy * M_PI / 360.0 );
|
||||
ymin = -ymax;
|
||||
|
||||
xmin = ymin * aspect;
|
||||
xmax = ymax * aspect;
|
||||
|
||||
glFrustum( xmin, xmax, ymin, ymax, zNear, zFar );
|
||||
}
|
||||
|
||||
GLUquadricObj *gluNewQuadric(void)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void gluQuadricDrawStyle(GLUquadricObj *obj, int style)
|
||||
{
|
||||
}
|
||||
|
||||
void gluCylinder( GLUquadricObj *qobj,
|
||||
GLdouble baseRadius, GLdouble topRadius, GLdouble height,
|
||||
GLint slices, GLint stacks )
|
||||
{
|
||||
GLdouble da, r, dr, dz;
|
||||
GLfloat z, nz, nsign;
|
||||
GLint i, j;
|
||||
GLfloat du = 1.0 / slices;
|
||||
GLfloat dv = 1.0 / stacks;
|
||||
GLfloat tcx = 0.0, tcy = 0.0;
|
||||
|
||||
nsign = 1.0;
|
||||
|
||||
da = 2.0*M_PI / slices;
|
||||
dr = (topRadius-baseRadius) / stacks;
|
||||
dz = height / stacks;
|
||||
nz = (baseRadius-topRadius) / height; /* Z component of normal vectors */
|
||||
|
||||
for (i=0;i<slices;i++) {
|
||||
GLfloat x1 = -sin(i*da);
|
||||
GLfloat y1 = cos(i*da);
|
||||
GLfloat x2 = -sin((i+1)*da);
|
||||
GLfloat y2 = cos((i+1)*da);
|
||||
z = 0.0;
|
||||
r = baseRadius;
|
||||
tcy = 0.0;
|
||||
glBegin( GL_QUAD_STRIP );
|
||||
for (j=0;j<=stacks;j++) {
|
||||
if (nsign==1.0) {
|
||||
normal3f( x1*nsign, y1*nsign, nz*nsign );
|
||||
glTexCoord2f(tcx, tcy);
|
||||
glVertex3f( x1*r, y1*r, z );
|
||||
normal3f( x2*nsign, y2*nsign, nz*nsign );
|
||||
glTexCoord2f(tcx+du, tcy);
|
||||
glVertex3f( x2*r, y2*r, z );
|
||||
}
|
||||
else {
|
||||
normal3f( x2*nsign, y2*nsign, nz*nsign );
|
||||
glTexCoord2f(tcx, tcy);
|
||||
glVertex3f( x2*r, y2*r, z );
|
||||
normal3f( x1*nsign, y1*nsign, nz*nsign );
|
||||
glTexCoord2f(tcx+du, tcy);
|
||||
glVertex3f( x1*r, y1*r, z );
|
||||
}
|
||||
z += dz;
|
||||
r += dr;
|
||||
tcy += dv;
|
||||
}
|
||||
glEnd();
|
||||
tcx += du;
|
||||
}
|
||||
}
|
||||
|
||||
/* Disk (adapted from Mesa) */
|
||||
|
||||
void gluDisk( GLUquadricObj *qobj,
|
||||
GLdouble innerRadius, GLdouble outerRadius,
|
||||
GLint slices, GLint loops )
|
||||
{
|
||||
GLdouble a, da;
|
||||
GLfloat dr;
|
||||
GLfloat r1, r2, dtc;
|
||||
GLint s, l;
|
||||
GLfloat sa,ca;
|
||||
|
||||
/* Normal vectors */
|
||||
glNormal3f( 0.0, 0.0, +1.0 );
|
||||
|
||||
da = 2.0*M_PI / slices;
|
||||
dr = (outerRadius-innerRadius) / (GLfloat) loops;
|
||||
|
||||
/* texture of a gluDisk is a cut out of the texture unit square */
|
||||
/* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
|
||||
dtc = 2.0f * outerRadius;
|
||||
|
||||
r1 = innerRadius;
|
||||
for (l=0;l<loops;l++) {
|
||||
r2 = r1 + dr;
|
||||
glBegin( GL_QUAD_STRIP );
|
||||
for (s=0;s<=slices;s++) {
|
||||
if (s==slices) a = 0.0;
|
||||
else a = s * da;
|
||||
sa = sin(a); ca = cos(a);
|
||||
glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc);
|
||||
glVertex2f( r2*sa, r2*ca );
|
||||
glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc);
|
||||
glVertex2f( r1*sa, r1*ca );
|
||||
}
|
||||
glEnd();
|
||||
r1 = r2;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Sphère (adapted from Mesa)
|
||||
*/
|
||||
|
||||
void gluSphere(GLUquadricObj *qobj,
|
||||
float radius,int slices,int stacks)
|
||||
{
|
||||
float rho, drho, theta, dtheta;
|
||||
float x, y, z;
|
||||
float s, t, ds, dt;
|
||||
int i, j, imin, imax;
|
||||
int normals;
|
||||
float nsign;
|
||||
|
||||
normals=1;
|
||||
nsign=1;
|
||||
|
||||
drho = M_PI / (float) stacks;
|
||||
dtheta = 2.0 * M_PI / (float) slices;
|
||||
|
||||
/* draw +Z end as a triangle fan */
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glNormal3f( 0.0, 0.0, 1.0 );
|
||||
glTexCoord2f(0.5,0.0);
|
||||
glVertex3f( 0.0, 0.0, nsign * radius );
|
||||
for (j=0;j<=slices;j++) {
|
||||
theta = (j==slices) ? 0.0 : j * dtheta;
|
||||
x = -sin(theta) * sin(drho);
|
||||
y = cos(theta) * sin(drho);
|
||||
z = nsign * cos(drho);
|
||||
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign );
|
||||
glVertex3f( x*radius, y*radius, z*radius );
|
||||
}
|
||||
glEnd();
|
||||
|
||||
|
||||
ds = 1.0 / slices;
|
||||
dt = 1.0 / stacks;
|
||||
t = 1.0; /* because loop now runs from 0 */
|
||||
if (1) {
|
||||
imin = 0;
|
||||
imax = stacks;
|
||||
}
|
||||
else {
|
||||
imin = 1;
|
||||
imax = stacks-1;
|
||||
}
|
||||
|
||||
/* draw intermediate stacks as quad strips */
|
||||
for (i=imin;i<imax;i++) {
|
||||
rho = i * drho;
|
||||
glBegin( GL_QUAD_STRIP );
|
||||
s = 0.0;
|
||||
for (j=0;j<=slices;j++) {
|
||||
theta = (j==slices) ? 0.0 : j * dtheta;
|
||||
x = -sin(theta) * sin(rho);
|
||||
y = cos(theta) * sin(rho);
|
||||
z = nsign * cos(rho);
|
||||
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign );
|
||||
glTexCoord2f(s,1-t);
|
||||
glVertex3f( x*radius, y*radius, z*radius );
|
||||
x = -sin(theta) * sin(rho+drho);
|
||||
y = cos(theta) * sin(rho+drho);
|
||||
z = nsign * cos(rho+drho);
|
||||
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign );
|
||||
glTexCoord2f(s,1-(t-dt));
|
||||
s += ds;
|
||||
glVertex3f( x*radius, y*radius, z*radius );
|
||||
}
|
||||
glEnd();
|
||||
t -= dt;
|
||||
}
|
||||
|
||||
/* draw -Z end as a triangle fan */
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glNormal3f( 0.0, 0.0, -1.0 );
|
||||
glTexCoord2f(0.5,1.0);
|
||||
glVertex3f( 0.0, 0.0, -radius*nsign );
|
||||
rho = M_PI - drho;
|
||||
s = 1.0;
|
||||
t = dt;
|
||||
for (j=slices;j>=0;j--) {
|
||||
theta = (j==slices) ? 0.0 : j * dtheta;
|
||||
x = -sin(theta) * sin(rho);
|
||||
y = cos(theta) * sin(rho);
|
||||
z = nsign * cos(rho);
|
||||
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign );
|
||||
glTexCoord2f(s,1-t);
|
||||
s -= ds;
|
||||
glVertex3f( x*radius, y*radius, z*radius );
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
|
@ -2,21 +2,12 @@
|
|||
|
||||
GLContext *gl_ctx;
|
||||
|
||||
void glInit(void *zbuffer1)
|
||||
void glInit(GLContext *c, ZBuffer *zbuffer)
|
||||
{
|
||||
ZBuffer *zbuffer=(ZBuffer *)zbuffer1;
|
||||
GLContext *c;
|
||||
GLViewport *v;
|
||||
int i;
|
||||
|
||||
c=gl_zalloc(sizeof(GLContext));
|
||||
gl_ctx=c;
|
||||
|
||||
c->zb=zbuffer;
|
||||
|
||||
/* allocate GLVertex array */
|
||||
c->vertex_max = POLYGON_MAX_VERTEX;
|
||||
c->vertex = gl_malloc(POLYGON_MAX_VERTEX*sizeof(GLVertex));
|
||||
|
||||
/* viewport */
|
||||
v=&c->viewport;
|
||||
|
|
@ -26,31 +17,7 @@ void glInit(void *zbuffer1)
|
|||
v->ysize=zbuffer->ysize;
|
||||
v->updated=1;
|
||||
|
||||
/* lists */
|
||||
|
||||
c->exec_flag=1;
|
||||
c->compile_flag=0;
|
||||
c->print_flag=0;
|
||||
|
||||
c->in_begin=0;
|
||||
|
||||
/* lights */
|
||||
for(i=0;i<MAX_LIGHTS;i++) {
|
||||
GLLight *l=&c->lights[i];
|
||||
l->ambient=gl_V4_New(0,0,0,1);
|
||||
l->diffuse=gl_V4_New(1,1,1,1);
|
||||
l->specular=gl_V4_New(1,1,1,1);
|
||||
l->position=gl_V4_New(0,0,1,0);
|
||||
l->norm_position=gl_V3_New(0,0,1);
|
||||
l->spot_direction=gl_V3_New(0,0,-1);
|
||||
l->norm_spot_direction=gl_V3_New(0,0,-1);
|
||||
l->spot_exponent=0;
|
||||
l->spot_cutoff=180;
|
||||
l->attenuation[0]=1;
|
||||
l->attenuation[1]=0;
|
||||
l->attenuation[2]=0;
|
||||
l->enabled=0;
|
||||
}
|
||||
c->first_light=NULL;
|
||||
c->ambient_light_model=gl_V4_New(0.2,0.2,0.2,1);
|
||||
c->local_light_model=0;
|
||||
|
|
@ -66,9 +33,6 @@ void glInit(void *zbuffer1)
|
|||
m->specular=gl_V4_New(0,0,0,1);
|
||||
m->shininess=0;
|
||||
}
|
||||
c->current_color_material_mode=GL_FRONT_AND_BACK;
|
||||
c->current_color_material_type=GL_AMBIENT_AND_DIFFUSE;
|
||||
c->color_material_enabled=0;
|
||||
|
||||
/* default state */
|
||||
c->current_color.X=1.0;
|
||||
|
|
@ -91,12 +55,7 @@ void glInit(void *zbuffer1)
|
|||
c->current_tex_coord.Z=0;
|
||||
c->current_tex_coord.W=1;
|
||||
|
||||
c->polygon_mode_front=GL_FILL;
|
||||
c->polygon_mode_back=GL_FILL;
|
||||
|
||||
c->current_front_face=0; /* 0 = GL_CCW 1 = GL_CW */
|
||||
c->current_cull_face=GL_BACK;
|
||||
c->current_shade_model=GL_SMOOTH;
|
||||
c->cull_face_enabled=0;
|
||||
|
||||
/* clear */
|
||||
|
|
@ -105,42 +64,10 @@ void glInit(void *zbuffer1)
|
|||
c->clear_color.v[2]=0;
|
||||
c->clear_color.v[3]=0;
|
||||
c->clear_depth=0;
|
||||
|
||||
/* selection */
|
||||
c->render_mode=GL_RENDER;
|
||||
c->select_buffer=NULL;
|
||||
c->name_stack_size=0;
|
||||
|
||||
/* matrix */
|
||||
c->matrix_mode=0;
|
||||
|
||||
c->matrix_stack_depth_max[0]=MAX_MODELVIEW_STACK_DEPTH;
|
||||
c->matrix_stack_depth_max[1]=MAX_PROJECTION_STACK_DEPTH;
|
||||
c->matrix_stack_depth_max[2]=MAX_TEXTURE_STACK_DEPTH;
|
||||
|
||||
for(i=0;i<3;i++) {
|
||||
c->matrix_stack[i]=gl_zalloc(c->matrix_stack_depth_max[i] * sizeof(M4));
|
||||
c->matrix_stack_ptr[i]=c->matrix_stack[i];
|
||||
}
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
glMatrixMode(GL_TEXTURE);
|
||||
glLoadIdentity();
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
c->matrix_model_projection_updated=1;
|
||||
|
||||
/* opengl 1.1 arrays */
|
||||
c->client_states = 0;
|
||||
|
||||
/* opengl 1.1 polygon offset */
|
||||
c->offset_states = 0;
|
||||
|
||||
/* clear the resize callback function pointer */
|
||||
c->gl_resize_viewport = NULL;
|
||||
|
||||
/* specular buffer */
|
||||
c->specbuf_first = NULL;
|
||||
c->specbuf_used_counter = 0;
|
||||
|
|
@ -150,8 +77,7 @@ void glInit(void *zbuffer1)
|
|||
c->depth_test = 0;
|
||||
}
|
||||
|
||||
void glClose(void)
|
||||
void glClose(GLContext *c)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
gl_free(c);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,161 +1,6 @@
|
|||
#include "zgl.h"
|
||||
#include "msghandling.h"
|
||||
|
||||
void glopMaterial(GLContext *c,GLParam *p)
|
||||
{
|
||||
int mode=p[1].i;
|
||||
int type=p[2].i;
|
||||
float *v=&p[3].f;
|
||||
int i;
|
||||
GLMaterial *m;
|
||||
|
||||
if (mode == GL_FRONT_AND_BACK) {
|
||||
p[1].i=GL_FRONT;
|
||||
glopMaterial(c,p);
|
||||
mode=GL_BACK;
|
||||
}
|
||||
if (mode == GL_FRONT) m=&c->materials[0];
|
||||
else m=&c->materials[1];
|
||||
|
||||
switch(type) {
|
||||
case GL_EMISSION:
|
||||
for(i=0;i<4;i++)
|
||||
m->emission.v[i]=v[i];
|
||||
break;
|
||||
case GL_AMBIENT:
|
||||
for(i=0;i<4;i++)
|
||||
m->ambient.v[i]=v[i];
|
||||
break;
|
||||
case GL_DIFFUSE:
|
||||
for(i=0;i<4;i++)
|
||||
m->diffuse.v[i]=v[i];
|
||||
break;
|
||||
case GL_SPECULAR:
|
||||
for(i=0;i<4;i++)
|
||||
m->specular.v[i]=v[i];
|
||||
break;
|
||||
case GL_SHININESS:
|
||||
m->shininess=v[0];
|
||||
m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION;
|
||||
break;
|
||||
case GL_AMBIENT_AND_DIFFUSE:
|
||||
for(i=0;i<4;i++)
|
||||
m->diffuse.v[i]=v[i];
|
||||
for(i=0;i<4;i++)
|
||||
m->ambient.v[i]=v[i];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
void glopColorMaterial(GLContext *c,GLParam *p)
|
||||
{
|
||||
int mode=p[1].i;
|
||||
int type=p[2].i;
|
||||
|
||||
c->current_color_material_mode=mode;
|
||||
c->current_color_material_type=type;
|
||||
}
|
||||
|
||||
void glopLight(GLContext *c,GLParam *p)
|
||||
{
|
||||
int light=p[1].i;
|
||||
int type=p[2].i;
|
||||
V4 v;
|
||||
GLLight *l;
|
||||
int i;
|
||||
|
||||
assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS );
|
||||
|
||||
l=&c->lights[light-GL_LIGHT0];
|
||||
|
||||
for(i=0;i<4;i++) v.v[i]=p[3+i].f;
|
||||
|
||||
switch(type) {
|
||||
case GL_AMBIENT:
|
||||
l->ambient=v;
|
||||
break;
|
||||
case GL_DIFFUSE:
|
||||
l->diffuse=v;
|
||||
break;
|
||||
case GL_SPECULAR:
|
||||
l->specular=v;
|
||||
break;
|
||||
case GL_POSITION:
|
||||
{
|
||||
V4 pos;
|
||||
gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v);
|
||||
|
||||
l->position=pos;
|
||||
|
||||
if (l->position.v[3] == 0) {
|
||||
l->norm_position.X=pos.X;
|
||||
l->norm_position.Y=pos.Y;
|
||||
l->norm_position.Z=pos.Z;
|
||||
|
||||
gl_V3_Norm(&l->norm_position);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case GL_SPOT_DIRECTION:
|
||||
for(i=0;i<3;i++) {
|
||||
l->spot_direction.v[i]=v.v[i];
|
||||
l->norm_spot_direction.v[i]=v.v[i];
|
||||
}
|
||||
gl_V3_Norm(&l->norm_spot_direction);
|
||||
break;
|
||||
case GL_SPOT_EXPONENT:
|
||||
l->spot_exponent=v.v[0];
|
||||
break;
|
||||
case GL_SPOT_CUTOFF:
|
||||
{
|
||||
float a=v.v[0];
|
||||
assert(a == 180 || (a>=0 && a<=90));
|
||||
l->spot_cutoff=a;
|
||||
if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0);
|
||||
}
|
||||
break;
|
||||
case GL_CONSTANT_ATTENUATION:
|
||||
l->attenuation[0]=v.v[0];
|
||||
break;
|
||||
case GL_LINEAR_ATTENUATION:
|
||||
l->attenuation[1]=v.v[0];
|
||||
break;
|
||||
case GL_QUADRATIC_ATTENUATION:
|
||||
l->attenuation[2]=v.v[0];
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void glopLightModel(GLContext *c,GLParam *p)
|
||||
{
|
||||
int pname=p[1].i;
|
||||
float *v=&p[2].f;
|
||||
int i;
|
||||
|
||||
switch(pname) {
|
||||
case GL_LIGHT_MODEL_AMBIENT:
|
||||
for(i=0;i<4;i++)
|
||||
c->ambient_light_model.v[i]=v[i];
|
||||
break;
|
||||
case GL_LIGHT_MODEL_LOCAL_VIEWER:
|
||||
c->local_light_model=(int)v[0];
|
||||
break;
|
||||
case GL_LIGHT_MODEL_TWO_SIDE:
|
||||
c->light_model_two_side = (int)v[0];
|
||||
break;
|
||||
default:
|
||||
tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname);
|
||||
//assert(0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static inline float clampf(float a,float min,float max)
|
||||
{
|
||||
if (a<min) return min;
|
||||
|
|
|
|||
|
|
@ -1,255 +0,0 @@
|
|||
#include "zgl.h"
|
||||
|
||||
static char *op_table_str[]=
|
||||
{
|
||||
#define ADD_OP(a,b,c) "gl" #a " " #c,
|
||||
|
||||
#include "opinfo.h"
|
||||
};
|
||||
|
||||
static void (*op_table_func[])(GLContext *,GLParam *)=
|
||||
{
|
||||
#define ADD_OP(a,b,c) glop ## a ,
|
||||
|
||||
#include "opinfo.h"
|
||||
};
|
||||
|
||||
static int op_table_size[]=
|
||||
{
|
||||
#define ADD_OP(a,b,c) b + 1 ,
|
||||
|
||||
#include "opinfo.h"
|
||||
};
|
||||
|
||||
|
||||
GLContext *gl_get_context(void)
|
||||
{
|
||||
return gl_ctx;
|
||||
}
|
||||
|
||||
static GLList *find_list(GLContext *c,unsigned int list)
|
||||
{
|
||||
return c->shared_state.lists[list];
|
||||
}
|
||||
|
||||
static void delete_list(GLContext *c,int list)
|
||||
{
|
||||
GLParamBuffer *pb,*pb1;
|
||||
GLList *l;
|
||||
|
||||
l=find_list(c,list);
|
||||
assert(l != NULL);
|
||||
|
||||
/* free param buffer */
|
||||
pb=l->first_op_buffer;
|
||||
while (pb!=NULL) {
|
||||
pb1=pb->next;
|
||||
gl_free(pb);
|
||||
pb=pb1;
|
||||
}
|
||||
|
||||
gl_free(l);
|
||||
c->shared_state.lists[list]=NULL;
|
||||
}
|
||||
|
||||
static GLList *alloc_list(GLContext *c,int list)
|
||||
{
|
||||
GLList *l;
|
||||
GLParamBuffer *ob;
|
||||
|
||||
l=gl_zalloc(sizeof(GLList));
|
||||
ob=gl_zalloc(sizeof(GLParamBuffer));
|
||||
|
||||
ob->next=NULL;
|
||||
l->first_op_buffer=ob;
|
||||
|
||||
ob->ops[0].op=OP_EndList;
|
||||
|
||||
c->shared_state.lists[list]=l;
|
||||
return l;
|
||||
}
|
||||
|
||||
|
||||
void gl_print_op(FILE *f,GLParam *p)
|
||||
{
|
||||
int op;
|
||||
char *s;
|
||||
|
||||
op=p[0].op;
|
||||
p++;
|
||||
s=op_table_str[op];
|
||||
while (*s != 0) {
|
||||
if (*s == '%') {
|
||||
s++;
|
||||
switch (*s++) {
|
||||
case 'f':
|
||||
fprintf(f,"%g",p[0].f);
|
||||
break;
|
||||
default:
|
||||
fprintf(f,"%d",p[0].i);
|
||||
break;
|
||||
}
|
||||
p++;
|
||||
} else {
|
||||
fputc(*s,f);
|
||||
s++;
|
||||
}
|
||||
}
|
||||
fprintf(f,"\n");
|
||||
}
|
||||
|
||||
|
||||
void gl_compile_op(GLContext *c,GLParam *p)
|
||||
{
|
||||
int op,op_size;
|
||||
GLParamBuffer *ob,*ob1;
|
||||
int index,i;
|
||||
|
||||
op=p[0].op;
|
||||
op_size=op_table_size[op];
|
||||
index=c->current_op_buffer_index;
|
||||
ob=c->current_op_buffer;
|
||||
|
||||
/* we should be able to add a NextBuffer opcode */
|
||||
if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) {
|
||||
|
||||
ob1=gl_zalloc(sizeof(GLParamBuffer));
|
||||
ob1->next=NULL;
|
||||
|
||||
ob->next=ob1;
|
||||
ob->ops[index].op=OP_NextBuffer;
|
||||
ob->ops[index+1].p=(void *)ob1;
|
||||
|
||||
c->current_op_buffer=ob1;
|
||||
ob=ob1;
|
||||
index=0;
|
||||
}
|
||||
|
||||
for(i=0;i<op_size;i++) {
|
||||
ob->ops[index]=p[i];
|
||||
index++;
|
||||
}
|
||||
c->current_op_buffer_index=index;
|
||||
}
|
||||
|
||||
void gl_add_op(GLParam *p)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
int op;
|
||||
|
||||
op=p[0].op;
|
||||
if (c->exec_flag) {
|
||||
op_table_func[op](c,p);
|
||||
}
|
||||
if (c->compile_flag) {
|
||||
gl_compile_op(c,p);
|
||||
}
|
||||
if (c->print_flag) {
|
||||
gl_print_op(stderr,p);
|
||||
}
|
||||
}
|
||||
|
||||
/* this opcode is never called directly */
|
||||
void glopEndList(GLContext *c,GLParam *p)
|
||||
{
|
||||
assert(0);
|
||||
}
|
||||
|
||||
/* this opcode is never called directly */
|
||||
void glopNextBuffer(GLContext *c,GLParam *p)
|
||||
{
|
||||
assert(0);
|
||||
}
|
||||
|
||||
|
||||
void glopCallList(GLContext *c,GLParam *p)
|
||||
{
|
||||
GLList *l;
|
||||
int list,op;
|
||||
|
||||
list=p[1].ui;
|
||||
l=find_list(c,list);
|
||||
if (l == NULL) gl_fatal_error("list %d not defined",list);
|
||||
p=l->first_op_buffer->ops;
|
||||
|
||||
while (1) {
|
||||
op=p[0].op;
|
||||
if (op == OP_EndList) break;
|
||||
if (op == OP_NextBuffer) {
|
||||
p=(GLParam *)p[1].p;
|
||||
} else {
|
||||
op_table_func[op](c,p);
|
||||
p+=op_table_size[op];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void glNewList(unsigned int list,int mode)
|
||||
{
|
||||
GLList *l;
|
||||
GLContext *c=gl_get_context();
|
||||
|
||||
assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE);
|
||||
assert(c->compile_flag == 0);
|
||||
|
||||
l=find_list(c,list);
|
||||
if (l!=NULL) delete_list(c,list);
|
||||
l=alloc_list(c,list);
|
||||
|
||||
c->current_op_buffer=l->first_op_buffer;
|
||||
c->current_op_buffer_index=0;
|
||||
|
||||
c->compile_flag=1;
|
||||
c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE);
|
||||
}
|
||||
|
||||
void glEndList(void)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
GLParam p[1];
|
||||
|
||||
assert(c->compile_flag == 1);
|
||||
|
||||
/* end of list */
|
||||
p[0].op=OP_EndList;
|
||||
gl_compile_op(c,p);
|
||||
|
||||
c->compile_flag=0;
|
||||
c->exec_flag=1;
|
||||
}
|
||||
|
||||
int glIsList(unsigned int list)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
GLList *l;
|
||||
l=find_list(c,list);
|
||||
return (l != NULL);
|
||||
}
|
||||
|
||||
unsigned int glGenLists(int range)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
int count,i,list;
|
||||
GLList **lists;
|
||||
|
||||
lists=c->shared_state.lists;
|
||||
count=0;
|
||||
for(i=0;i<MAX_DISPLAY_LISTS;i++) {
|
||||
if (lists[i]==NULL) {
|
||||
count++;
|
||||
if (count == range) {
|
||||
list=i-range+1;
|
||||
for(i=0;i<range;i++) {
|
||||
alloc_list(c,list+i);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
} else {
|
||||
count=0;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,241 +0,0 @@
|
|||
#include "zgl.h"
|
||||
|
||||
void gl_print_matrix( const float *m)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0;i<4;i++) {
|
||||
fprintf(stderr,"%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
|
||||
}
|
||||
}
|
||||
|
||||
static inline void gl_matrix_update(GLContext *c)
|
||||
{
|
||||
c->matrix_model_projection_updated=(c->matrix_mode<=1);
|
||||
}
|
||||
|
||||
|
||||
void glopMatrixMode(GLContext *c,GLParam *p)
|
||||
{
|
||||
int mode=p[1].i;
|
||||
switch(mode) {
|
||||
case GL_MODELVIEW:
|
||||
c->matrix_mode=0;
|
||||
break;
|
||||
case GL_PROJECTION:
|
||||
c->matrix_mode=1;
|
||||
break;
|
||||
case GL_TEXTURE:
|
||||
c->matrix_mode=2;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
void glopLoadMatrix(GLContext *c,GLParam *p)
|
||||
{
|
||||
M4 *m;
|
||||
int i;
|
||||
|
||||
GLParam *q;
|
||||
|
||||
m=c->matrix_stack_ptr[c->matrix_mode];
|
||||
q=p+1;
|
||||
|
||||
for(i=0;i<4;i++) {
|
||||
m->m[0][i]=q[0].f;
|
||||
m->m[1][i]=q[1].f;
|
||||
m->m[2][i]=q[2].f;
|
||||
m->m[3][i]=q[3].f;
|
||||
q+=4;
|
||||
}
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
void glopLoadIdentity(GLContext *c,GLParam *p)
|
||||
{
|
||||
|
||||
gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]);
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
void glopMultMatrix(GLContext *c,GLParam *p)
|
||||
{
|
||||
M4 m;
|
||||
int i;
|
||||
|
||||
GLParam *q;
|
||||
q=p+1;
|
||||
|
||||
for(i=0;i<4;i++) {
|
||||
m.m[0][i]=q[0].f;
|
||||
m.m[1][i]=q[1].f;
|
||||
m.m[2][i]=q[2].f;
|
||||
m.m[3][i]=q[3].f;
|
||||
q+=4;
|
||||
}
|
||||
|
||||
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
|
||||
void glopPushMatrix(GLContext *c,GLParam *p)
|
||||
{
|
||||
int n=c->matrix_mode;
|
||||
M4 *m;
|
||||
|
||||
assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 )
|
||||
< c->matrix_stack_depth_max[n] );
|
||||
|
||||
m=++c->matrix_stack_ptr[n];
|
||||
|
||||
gl_M4_Move(&m[0],&m[-1]);
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
void glopPopMatrix(GLContext *c,GLParam *p)
|
||||
{
|
||||
int n=c->matrix_mode;
|
||||
|
||||
assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] );
|
||||
c->matrix_stack_ptr[n]--;
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
|
||||
void glopRotate(GLContext *c,GLParam *p)
|
||||
{
|
||||
M4 m;
|
||||
float u[3];
|
||||
float angle;
|
||||
int dir_code;
|
||||
|
||||
angle = p[1].f * M_PI / 180.0;
|
||||
u[0]=p[2].f;
|
||||
u[1]=p[3].f;
|
||||
u[2]=p[4].f;
|
||||
|
||||
/* simple case detection */
|
||||
dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0);
|
||||
|
||||
switch(dir_code) {
|
||||
case 0:
|
||||
gl_M4_Id(&m);
|
||||
break;
|
||||
case 4:
|
||||
if (u[0] < 0) angle=-angle;
|
||||
gl_M4_Rotate(&m,angle,0);
|
||||
break;
|
||||
case 2:
|
||||
if (u[1] < 0) angle=-angle;
|
||||
gl_M4_Rotate(&m,angle,1);
|
||||
break;
|
||||
case 1:
|
||||
if (u[2] < 0) angle=-angle;
|
||||
gl_M4_Rotate(&m,angle,2);
|
||||
break;
|
||||
default:
|
||||
{
|
||||
float cost, sint;
|
||||
|
||||
/* normalize vector */
|
||||
float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2];
|
||||
if (len == 0.0f) return;
|
||||
len = 1.0f / sqrt(len);
|
||||
u[0] *= len;
|
||||
u[1] *= len;
|
||||
u[2] *= len;
|
||||
|
||||
/* store cos and sin values */
|
||||
cost=cos(angle);
|
||||
sint=sin(angle);
|
||||
|
||||
/* fill in the values */
|
||||
m.m[3][0]=m.m[3][1]=m.m[3][2]=
|
||||
m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f;
|
||||
m.m[3][3]=1.0f;
|
||||
|
||||
/* do the math */
|
||||
m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]);
|
||||
m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint;
|
||||
m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint;
|
||||
m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint;
|
||||
m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]);
|
||||
m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint;
|
||||
m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint;
|
||||
m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint;
|
||||
m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]);
|
||||
}
|
||||
}
|
||||
|
||||
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
void glopScale(GLContext *c,GLParam *p)
|
||||
{
|
||||
float *m;
|
||||
float x=p[1].f,y=p[2].f,z=p[3].f;
|
||||
|
||||
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
|
||||
|
||||
m[0] *= x; m[1] *= y; m[2] *= z;
|
||||
m[4] *= x; m[5] *= y; m[6] *= z;
|
||||
m[8] *= x; m[9] *= y; m[10] *= z;
|
||||
m[12] *= x; m[13] *= y; m[14] *= z;
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
void glopTranslate(GLContext *c,GLParam *p)
|
||||
{
|
||||
float *m;
|
||||
float x=p[1].f,y=p[2].f,z=p[3].f;
|
||||
|
||||
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
|
||||
|
||||
m[3] = m[0] * x + m[1] * y + m[2] * z + m[3];
|
||||
m[7] = m[4] * x + m[5] * y + m[6] * z + m[7];
|
||||
m[11] = m[8] * x + m[9] * y + m[10] * z + m[11];
|
||||
m[15] = m[12] * x + m[13] * y + m[14] * z + m[15];
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
|
||||
void glopFrustum(GLContext *c,GLParam *p)
|
||||
{
|
||||
float *r;
|
||||
M4 m;
|
||||
float left=p[1].f;
|
||||
float right=p[2].f;
|
||||
float bottom=p[3].f;
|
||||
float top=p[4].f;
|
||||
float near=p[5].f;
|
||||
float farp=p[6].f;
|
||||
float x,y,A,B,C,D;
|
||||
|
||||
x = (2.0*near) / (right-left);
|
||||
y = (2.0*near) / (top-bottom);
|
||||
A = (right+left) / (right-left);
|
||||
B = (top+bottom) / (top-bottom);
|
||||
C = -(farp+near) / ( farp-near);
|
||||
D = -(2.0*farp*near) / (farp-near);
|
||||
|
||||
r=&m.m[0][0];
|
||||
r[0]= x; r[1]=0; r[2]=A; r[3]=0;
|
||||
r[4]= 0; r[5]=y; r[6]=B; r[7]=0;
|
||||
r[8]= 0; r[9]=0; r[10]=C; r[11]=D;
|
||||
r[12]= 0; r[13]=0; r[14]=-1; r[15]=0;
|
||||
|
||||
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
||||
|
||||
gl_matrix_update(c);
|
||||
}
|
||||
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
#include "zgl.h"
|
||||
#include "msghandling.h"
|
||||
|
||||
void glopViewport(GLContext *c,GLParam *p)
|
||||
{
|
||||
int xsize,ysize,xmin,ymin,xsize_req,ysize_req;
|
||||
|
||||
xmin=p[1].i;
|
||||
ymin=p[2].i;
|
||||
xsize=p[3].i;
|
||||
ysize=p[4].i;
|
||||
|
||||
/* we may need to resize the zbuffer */
|
||||
|
||||
if (c->viewport.xmin != xmin ||
|
||||
c->viewport.ymin != ymin ||
|
||||
c->viewport.xsize != xsize ||
|
||||
c->viewport.ysize != ysize) {
|
||||
|
||||
xsize_req=xmin+xsize;
|
||||
ysize_req=ymin+ysize;
|
||||
|
||||
if (c->gl_resize_viewport &&
|
||||
c->gl_resize_viewport(c,&xsize_req,&ysize_req) != 0) {
|
||||
gl_fatal_error("glViewport: error while resizing display");
|
||||
}
|
||||
|
||||
xsize=xsize_req-xmin;
|
||||
ysize=ysize_req-ymin;
|
||||
if (xsize <= 0 || ysize <= 0) {
|
||||
gl_fatal_error("glViewport: size too small");
|
||||
}
|
||||
|
||||
tgl_trace("glViewport: %d %d %d %d\n",
|
||||
xmin, ymin, xsize, ysize);
|
||||
c->viewport.xmin=xmin;
|
||||
c->viewport.ymin=ymin;
|
||||
c->viewport.xsize=xsize;
|
||||
c->viewport.ysize=ysize;
|
||||
|
||||
c->viewport.updated=1;
|
||||
}
|
||||
}
|
||||
|
||||
void glopEnableDisable(GLContext *c,GLParam *p)
|
||||
{
|
||||
int code=p[1].i;
|
||||
int v=p[2].i;
|
||||
|
||||
switch(code) {
|
||||
case GL_CULL_FACE:
|
||||
c->cull_face_enabled=v;
|
||||
break;
|
||||
case GL_LIGHTING:
|
||||
c->lighting_enabled=v;
|
||||
break;
|
||||
case GL_COLOR_MATERIAL:
|
||||
c->color_material_enabled=v;
|
||||
break;
|
||||
case GL_TEXTURE_2D:
|
||||
c->texture_2d_enabled=v;
|
||||
break;
|
||||
case GL_NORMALIZE:
|
||||
c->normalize_enabled=v;
|
||||
break;
|
||||
case GL_DEPTH_TEST:
|
||||
c->depth_test = v;
|
||||
break;
|
||||
case GL_POLYGON_OFFSET_FILL:
|
||||
if (v) c->offset_states |= TGL_OFFSET_FILL;
|
||||
else c->offset_states &= ~TGL_OFFSET_FILL;
|
||||
break;
|
||||
case GL_POLYGON_OFFSET_POINT:
|
||||
if (v) c->offset_states |= TGL_OFFSET_POINT;
|
||||
else c->offset_states &= ~TGL_OFFSET_POINT;
|
||||
break;
|
||||
case GL_POLYGON_OFFSET_LINE:
|
||||
if (v) c->offset_states |= TGL_OFFSET_LINE;
|
||||
else c->offset_states &= ~TGL_OFFSET_LINE;
|
||||
break;
|
||||
default:
|
||||
if (code>=GL_LIGHT0 && code<GL_LIGHT0+MAX_LIGHTS) {
|
||||
gl_enable_disable_light(c,code - GL_LIGHT0, v);
|
||||
} else {
|
||||
/*
|
||||
fprintf(stderr,"glEnableDisable: 0x%X not supported.\n",code);
|
||||
*/
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void glopShadeModel(GLContext *c,GLParam *p)
|
||||
{
|
||||
int code=p[1].i;
|
||||
c->current_shade_model=code;
|
||||
}
|
||||
|
||||
void glopCullFace(GLContext *c,GLParam *p)
|
||||
{
|
||||
int code=p[1].i;
|
||||
c->current_cull_face=code;
|
||||
}
|
||||
|
||||
void glopFrontFace(GLContext *c,GLParam *p)
|
||||
{
|
||||
int code=p[1].i;
|
||||
c->current_front_face=code;
|
||||
}
|
||||
|
||||
void glopPolygonMode(GLContext *c,GLParam *p)
|
||||
{
|
||||
int face=p[1].i;
|
||||
int mode=p[2].i;
|
||||
|
||||
switch(face) {
|
||||
case GL_BACK:
|
||||
c->polygon_mode_back=mode;
|
||||
break;
|
||||
case GL_FRONT:
|
||||
c->polygon_mode_front=mode;
|
||||
break;
|
||||
case GL_FRONT_AND_BACK:
|
||||
c->polygon_mode_front=mode;
|
||||
c->polygon_mode_back=mode;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
void glopHint(GLContext *c,GLParam *p)
|
||||
{
|
||||
#if 0
|
||||
int target=p[1].i;
|
||||
int mode=p[2].i;
|
||||
|
||||
/* do nothing */
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
glopPolygonOffset(GLContext *c, GLParam *p)
|
||||
{
|
||||
c->offset_factor = p[1].f;
|
||||
c->offset_units = p[2].f;
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
|
||||
|
||||
ADD_OP(Color,7,"%f %f %f %f %d %d %d")
|
||||
ADD_OP(TexCoord,4,"%f %f %f %f")
|
||||
ADD_OP(EdgeFlag,1,"%d")
|
||||
ADD_OP(Normal,3,"%f %f %f")
|
||||
|
||||
ADD_OP(Begin,1,"%C")
|
||||
ADD_OP(Vertex,4,"%f %f %f %f")
|
||||
ADD_OP(End,0,"")
|
||||
|
||||
ADD_OP(EnableDisable,2,"%C %d")
|
||||
|
||||
ADD_OP(MatrixMode,1,"%C")
|
||||
ADD_OP(LoadMatrix,16,"")
|
||||
ADD_OP(LoadIdentity,0,"")
|
||||
ADD_OP(MultMatrix,16,"")
|
||||
ADD_OP(PushMatrix,0,"")
|
||||
ADD_OP(PopMatrix,0,"")
|
||||
ADD_OP(Rotate,4,"%f %f %f %f")
|
||||
ADD_OP(Translate,3,"%f %f %f")
|
||||
ADD_OP(Scale,3,"%f %f %f")
|
||||
|
||||
ADD_OP(Viewport,4,"%d %d %d %d")
|
||||
ADD_OP(Frustum,6,"%f %f %f %f %f %f")
|
||||
|
||||
ADD_OP(Material,6,"%C %C %f %f %f %f")
|
||||
ADD_OP(ColorMaterial,2,"%C %C")
|
||||
ADD_OP(Light,6,"%C %C %f %f %f %f")
|
||||
ADD_OP(LightModel,5,"%C %f %f %f %f")
|
||||
|
||||
ADD_OP(Clear,1,"%d")
|
||||
ADD_OP(ClearColor,4,"%f %f %f %f")
|
||||
ADD_OP(ClearDepth,1,"%f")
|
||||
|
||||
ADD_OP(InitNames,0,"")
|
||||
ADD_OP(PushName,1,"%d")
|
||||
ADD_OP(PopName,0,"")
|
||||
ADD_OP(LoadName,1,"%d")
|
||||
|
||||
ADD_OP(ShadeModel,1,"%C")
|
||||
ADD_OP(CullFace,1,"%C")
|
||||
ADD_OP(FrontFace,1,"%C")
|
||||
ADD_OP(PolygonMode,2,"%C %C")
|
||||
|
||||
ADD_OP(CallList,1,"%d")
|
||||
ADD_OP(Hint,2,"%C %C")
|
||||
|
||||
/* special opcodes */
|
||||
ADD_OP(EndList,0,"")
|
||||
ADD_OP(NextBuffer,1,"%p")
|
||||
|
||||
/* opengl 1.1 arrays */
|
||||
ADD_OP(ArrayElement, 1, "%d")
|
||||
ADD_OP(EnableClientState, 1, "%C")
|
||||
ADD_OP(DisableClientState, 1, "%C")
|
||||
ADD_OP(VertexPointer, 4, "%d %C %d %p")
|
||||
ADD_OP(ColorPointer, 4, "%d %C %d %p")
|
||||
ADD_OP(NormalPointer, 3, "%C %d %p")
|
||||
ADD_OP(TexCoordPointer, 4, "%d %C %d %p")
|
||||
|
||||
/* opengl 1.1 polygon offset */
|
||||
ADD_OP(PolygonOffset, 2, "%f %f")
|
||||
|
||||
#undef ADD_OP
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#include "oscontext.h"
|
||||
#include "zbuffer.h"
|
||||
#include "zgl.h"
|
||||
#include "tinygl.h"
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
static int buffercnt = 0;
|
||||
|
||||
ostgl_context *
|
||||
ostgl_create_context(const int xsize,
|
||||
const int ysize,
|
||||
const int depth,
|
||||
void **framebuffers,
|
||||
const int numbuffers)
|
||||
{
|
||||
ostgl_context *context;
|
||||
int i;
|
||||
ZBuffer *zb;
|
||||
|
||||
assert(depth == 16); /* support for other depths must include bpp
|
||||
convertion */
|
||||
assert(numbuffers >= 1);
|
||||
|
||||
context = gl_malloc(sizeof(ostgl_context));
|
||||
assert(context);
|
||||
context->zbs = gl_malloc(sizeof(void*)*numbuffers);
|
||||
context->framebuffers = gl_malloc(sizeof(void*)*numbuffers);
|
||||
|
||||
assert(context->zbs != NULL && context->framebuffers != NULL);
|
||||
|
||||
for (i = 0; i < numbuffers; i++) {
|
||||
context->framebuffers[i] = framebuffers[i];
|
||||
zb = ZB_open(xsize, ysize, ZB_MODE_5R6G5B, 0, NULL, NULL, framebuffers[i]);
|
||||
if (zb == NULL) {
|
||||
fprintf(stderr, "Error while initializing Z buffer\n");
|
||||
exit(1);
|
||||
}
|
||||
context->zbs[i] = zb;
|
||||
}
|
||||
if (++buffercnt == 1) {
|
||||
glInit(context->zbs[0]);
|
||||
}
|
||||
context->xsize = xsize;
|
||||
context->ysize = ysize;
|
||||
context->numbuffers = numbuffers;
|
||||
return context;
|
||||
}
|
||||
|
||||
void
|
||||
ostgl_delete_context(ostgl_context *context)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < context->numbuffers; i++) {
|
||||
ZB_close(context->zbs[i]);
|
||||
}
|
||||
gl_free(context->zbs);
|
||||
gl_free(context->framebuffers);
|
||||
gl_free(context);
|
||||
|
||||
if (--buffercnt == 0) {
|
||||
glClose();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ostgl_make_current(ostgl_context *oscontext, const int idx)
|
||||
{
|
||||
GLContext *context = gl_get_context();
|
||||
assert(idx < oscontext->numbuffers);
|
||||
context->zb = oscontext->zbs[idx];
|
||||
}
|
||||
|
||||
void
|
||||
ostgl_resize(ostgl_context *context,
|
||||
const int xsize,
|
||||
const int ysize,
|
||||
void **framebuffers)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < context->numbuffers; i++) {
|
||||
ZB_resize(context->zbs[i], framebuffers[i], xsize, ysize);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#ifndef _tgl_osbuffer_h_
|
||||
#define _tgl_osbuffer_h_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
void **zbs;
|
||||
void **framebuffers;
|
||||
int numbuffers;
|
||||
int xsize, ysize;
|
||||
} ostgl_context;
|
||||
|
||||
ostgl_context *
|
||||
ostgl_create_context(const int xsize,
|
||||
const int ysize,
|
||||
const int depth,
|
||||
void **framebuffers,
|
||||
const int numbuffers);
|
||||
void
|
||||
ostgl_delete_context(ostgl_context *context);
|
||||
|
||||
void
|
||||
ostgl_make_current(ostgl_context *context, const int index);
|
||||
|
||||
void
|
||||
ostgl_resize(ostgl_context * context,
|
||||
const int xsize,
|
||||
const int ysize,
|
||||
void **framebuffers);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _tgl_osbuffer_h_ */
|
||||
|
|
@ -1,114 +0,0 @@
|
|||
#include "zgl.h"
|
||||
|
||||
int glRenderMode(int mode)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
int result=0;
|
||||
|
||||
switch(c->render_mode) {
|
||||
case GL_RENDER:
|
||||
break;
|
||||
case GL_SELECT:
|
||||
if (c->select_overflow) {
|
||||
result=-c->select_hits;
|
||||
} else {
|
||||
result=c->select_hits;
|
||||
}
|
||||
c->select_overflow=0;
|
||||
c->select_ptr=c->select_buffer;
|
||||
c->name_stack_size=0;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
switch(mode) {
|
||||
case GL_RENDER:
|
||||
c->render_mode=GL_RENDER;
|
||||
break;
|
||||
case GL_SELECT:
|
||||
c->render_mode=GL_SELECT;
|
||||
assert( c->select_buffer != NULL);
|
||||
c->select_ptr=c->select_buffer;
|
||||
c->select_hits=0;
|
||||
c->select_overflow=0;
|
||||
c->select_hit=NULL;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void glSelectBuffer(int size,unsigned int *buf)
|
||||
{
|
||||
GLContext *c=gl_get_context();
|
||||
|
||||
assert(c->render_mode != GL_SELECT);
|
||||
|
||||
c->select_buffer=buf;
|
||||
c->select_size=size;
|
||||
}
|
||||
|
||||
|
||||
void glopInitNames(GLContext *c,GLParam *p)
|
||||
{
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
c->name_stack_size=0;
|
||||
c->select_hit=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void glopPushName(GLContext *c,GLParam *p)
|
||||
{
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
assert(c->name_stack_size<MAX_NAME_STACK_DEPTH);
|
||||
c->name_stack[c->name_stack_size++]=p[1].i;
|
||||
c->select_hit=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void glopPopName(GLContext *c,GLParam *p)
|
||||
{
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
assert(c->name_stack_size>0);
|
||||
c->name_stack_size--;
|
||||
c->select_hit=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void glopLoadName(GLContext *c,GLParam *p)
|
||||
{
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
assert(c->name_stack_size>0);
|
||||
c->name_stack[c->name_stack_size-1]=p[1].i;
|
||||
c->select_hit=NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax)
|
||||
{
|
||||
unsigned int *ptr;
|
||||
int n,i;
|
||||
|
||||
if (!c->select_overflow) {
|
||||
if (c->select_hit==NULL) {
|
||||
n=c->name_stack_size;
|
||||
if ((c->select_ptr-c->select_buffer+3+n) >
|
||||
c->select_size) {
|
||||
c->select_overflow=1;
|
||||
} else {
|
||||
ptr=c->select_ptr;
|
||||
c->select_hit=ptr;
|
||||
*ptr++=c->name_stack_size;
|
||||
*ptr++=zmin;
|
||||
*ptr++=zmax;
|
||||
for(i=0;i<n;i++) *ptr++=c->name_stack[i];
|
||||
c->select_ptr=ptr;
|
||||
c->select_hits++;
|
||||
}
|
||||
} else {
|
||||
if (zmin<c->select_hit[1]) c->select_hit[1]=zmin;
|
||||
if (zmax>c->select_hit[2]) c->select_hit[2]=zmax;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
#ifndef _tgl_specbuf_h_
|
||||
#define _tgl_specbuf_h_
|
||||
|
||||
/* Max # of specular light pow buffers */
|
||||
#define MAX_SPECULAR_BUFFERS 8
|
||||
/* # of entries in specular buffer */
|
||||
#define SPECULAR_BUFFER_SIZE 1024
|
||||
/* specular buffer granularity */
|
||||
#define SPECULAR_BUFFER_RESOLUTION 1024
|
||||
|
||||
typedef struct GLSpecBuf {
|
||||
int shininess_i;
|
||||
int last_used;
|
||||
float buf[SPECULAR_BUFFER_SIZE+1];
|
||||
struct GLSpecBuf *next;
|
||||
} GLSpecBuf;
|
||||
|
||||
GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i,
|
||||
const float shininess);
|
||||
void specbuf_cleanup(GLContext *c); /* free all memory used */
|
||||
|
||||
#endif /* _tgl_specbuf_h_ */
|
||||
|
|
@ -16,13 +16,3 @@
|
|||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: TinyGraphicsStateGuardian::get_light_id
|
||||
// Access: Private, Static
|
||||
// Description: Convert index to gl light id
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE GLenum TinyGraphicsStateGuardian::
|
||||
get_light_id(int index) {
|
||||
return GL_LIGHT0 + index;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -496,67 +496,6 @@ static const ZB_fillTriangleFunc fill_tri_funcs
|
|||
},
|
||||
};
|
||||
|
||||
static inline void tgl_vertex_transform(GLContext * c, GLVertex * v)
|
||||
{
|
||||
float *m;
|
||||
V4 *n;
|
||||
|
||||
if (c->lighting_enabled) {
|
||||
/* eye coordinates needed for lighting */
|
||||
|
||||
m = &c->matrix_stack_ptr[0]->m[0][0];
|
||||
v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
|
||||
v->coord.Z * m[2] + m[3]);
|
||||
v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
|
||||
v->coord.Z * m[6] + m[7]);
|
||||
v->ec.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
|
||||
v->coord.Z * m[10] + m[11]);
|
||||
v->ec.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
|
||||
v->coord.Z * m[14] + m[15]);
|
||||
|
||||
/* projection coordinates */
|
||||
m = &c->matrix_stack_ptr[1]->m[0][0];
|
||||
v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] +
|
||||
v->ec.Z * m[2] + v->ec.W * m[3]);
|
||||
v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] +
|
||||
v->ec.Z * m[6] + v->ec.W * m[7]);
|
||||
v->pc.Z = (v->ec.X * m[8] + v->ec.Y * m[9] +
|
||||
v->ec.Z * m[10] + v->ec.W * m[11]);
|
||||
v->pc.W = (v->ec.X * m[12] + v->ec.Y * m[13] +
|
||||
v->ec.Z * m[14] + v->ec.W * m[15]);
|
||||
|
||||
m = &c->matrix_model_view_inv.m[0][0];
|
||||
n = &c->current_normal;
|
||||
|
||||
v->normal.X = (n->X * m[0] + n->Y * m[1] + n->Z * m[2]);
|
||||
v->normal.Y = (n->X * m[4] + n->Y * m[5] + n->Z * m[6]);
|
||||
v->normal.Z = (n->X * m[8] + n->Y * m[9] + n->Z * m[10]);
|
||||
|
||||
if (c->normalize_enabled) {
|
||||
gl_V3_Norm(&v->normal);
|
||||
}
|
||||
} else {
|
||||
/* no eye coordinates needed, no normal */
|
||||
/* NOTE: W = 1 is assumed */
|
||||
m = &c->matrix_model_projection.m[0][0];
|
||||
|
||||
v->pc.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
|
||||
v->coord.Z * m[2] + m[3]);
|
||||
v->pc.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
|
||||
v->coord.Z * m[6] + m[7]);
|
||||
v->pc.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
|
||||
v->coord.Z * m[10] + m[11]);
|
||||
if (c->matrix_model_projection_no_w_transform) {
|
||||
v->pc.W = m[15];
|
||||
} else {
|
||||
v->pc.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
|
||||
v->coord.Z * m[14] + m[15]);
|
||||
}
|
||||
}
|
||||
|
||||
v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: TinyGraphicsStateGuardian::Constructor
|
||||
// Access: Public
|
||||
|
|
@ -592,9 +531,13 @@ reset() {
|
|||
free_pointers();
|
||||
GraphicsStateGuardian::reset();
|
||||
|
||||
glInit(_current_frame_buffer);
|
||||
if (_c != (GLContext *)NULL) {
|
||||
glClose(_c);
|
||||
_c = NULL;
|
||||
}
|
||||
|
||||
_c = gl_get_context();
|
||||
_c = (GLContext *)gl_zalloc(sizeof(GLContext));
|
||||
glInit(_c, _current_frame_buffer);
|
||||
|
||||
_c->draw_triangle_front = gl_draw_triangle_fill;
|
||||
_c->draw_triangle_back = gl_draw_triangle_fill;
|
||||
|
|
@ -631,6 +574,24 @@ free_pointers() {
|
|||
_vertices_size = 0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: TinyGraphicsStateGuardian::close_gsg
|
||||
// Access: Protected, Virtual
|
||||
// Description: This is called by the associated GraphicsWindow when
|
||||
// close_window() is called. It should null out the
|
||||
// _win pointer and possibly free any open resources
|
||||
// associated with the GSG.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
void TinyGraphicsStateGuardian::
|
||||
close_gsg() {
|
||||
GraphicsStateGuardian::close_gsg();
|
||||
|
||||
if (_c != (GLContext *)NULL) {
|
||||
glClose(_c);
|
||||
_c = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: TinyGraphicsStateGuardian::depth_offset_decals
|
||||
// Access: Public, Virtual
|
||||
|
|
@ -899,8 +860,8 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
|
|||
// coordinates, wipe out the current projection and modelview
|
||||
// matrix (so we don't attempt to transform it again).
|
||||
const TransformState *ident = TransformState::make_identity();
|
||||
load_matrix(_c->matrix_stack_ptr[0], ident);
|
||||
load_matrix(_c->matrix_stack_ptr[1], ident);
|
||||
load_matrix(&_c->matrix_model_view, ident);
|
||||
load_matrix(&_c->matrix_projection, ident);
|
||||
load_matrix(&_c->matrix_model_view_inv, ident);
|
||||
load_matrix(&_c->matrix_model_projection, ident);
|
||||
_c->matrix_model_projection_no_w_transform = 1;
|
||||
|
|
@ -913,12 +874,12 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
|
|||
// With the lighting equation, we need to keep the modelview and
|
||||
// projection matrices separate.
|
||||
|
||||
load_matrix(_c->matrix_stack_ptr[0], _internal_transform);
|
||||
load_matrix(_c->matrix_stack_ptr[1], _projection_mat);
|
||||
load_matrix(&_c->matrix_model_view, _internal_transform);
|
||||
load_matrix(&_c->matrix_projection, _projection_mat);
|
||||
|
||||
/* precompute inverse modelview */
|
||||
M4 tmp;
|
||||
gl_M4_Inv(&tmp, _c->matrix_stack_ptr[0]);
|
||||
gl_M4_Inv(&tmp, &_c->matrix_model_view);
|
||||
gl_M4_Transpose(&_c->matrix_model_view_inv, &tmp);
|
||||
|
||||
}
|
||||
|
|
@ -935,9 +896,6 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
|
|||
}
|
||||
_transform_stale = false;
|
||||
}
|
||||
|
||||
/* test if the texture matrix is not Identity */
|
||||
// _c->apply_texture_matrix = !gl_M4_IsId(_c->matrix_stack_ptr[2]);
|
||||
|
||||
// Figure out the subset of vertices we will be using in this
|
||||
// operation.
|
||||
|
|
@ -1089,7 +1047,7 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
|
|||
_c->current_normal.W = 0.0f;
|
||||
}
|
||||
|
||||
tgl_vertex_transform(_c, v);
|
||||
gl_vertex_transform(_c, v);
|
||||
|
||||
if (_c->lighting_enabled) {
|
||||
gl_shade_vertex(_c, v);
|
||||
|
|
@ -1164,7 +1122,10 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
|
|||
shade_model = ShadeModelAttrib::M_flat;
|
||||
}
|
||||
int shading_state = 2; // smooth
|
||||
_c->smooth_shade_model = true;
|
||||
|
||||
if (shade_model == ShadeModelAttrib::M_flat) {
|
||||
_c->smooth_shade_model = false;
|
||||
shading_state = 1; // flat
|
||||
if (_c->current_color.X == 1.0f &&
|
||||
_c->current_color.Y == 1.0f &&
|
||||
|
|
@ -1953,11 +1914,11 @@ do_issue_cull_face() {
|
|||
break;
|
||||
case CullFaceAttrib::M_cull_clockwise:
|
||||
_c->cull_face_enabled = true;
|
||||
_c->current_cull_face = GL_BACK;
|
||||
_c->cull_clockwise = true;
|
||||
break;
|
||||
case CullFaceAttrib::M_cull_counter_clockwise:
|
||||
_c->cull_face_enabled = true;
|
||||
_c->current_cull_face = GL_FRONT;
|
||||
_c->cull_clockwise = false;
|
||||
break;
|
||||
default:
|
||||
tinydisplay_cat.error()
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@
|
|||
|
||||
#include "graphicsStateGuardian.h"
|
||||
#include "tinySDLGraphicsPipe.h"
|
||||
#include "tinygl.h"
|
||||
|
||||
extern "C" {
|
||||
#include "zmath.h"
|
||||
|
|
@ -50,6 +49,7 @@ public:
|
|||
|
||||
virtual void reset();
|
||||
virtual void free_pointers();
|
||||
virtual void close_gsg();
|
||||
|
||||
virtual bool depth_offset_decals();
|
||||
|
||||
|
|
@ -121,8 +121,6 @@ private:
|
|||
void setup_material(GLMaterial *gl_material, const Material *material);
|
||||
static void load_matrix(M4 *matrix, const TransformState *transform);
|
||||
|
||||
INLINE static GLenum get_light_id(int index);
|
||||
|
||||
public:
|
||||
// Filled in by the Tiny*GraphicsWindow at begin_frame().
|
||||
ZBuffer *_current_frame_buffer;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@
|
|||
#include "mouseButton.h"
|
||||
#include "keyboardButton.h"
|
||||
#include "graphicsPipe.h"
|
||||
#include "tinygl.h"
|
||||
|
||||
TypeHandle TinySDLGraphicsWindow::_type_handle;
|
||||
|
||||
|
|
@ -253,7 +252,6 @@ set_properties_now(WindowProperties &properties) {
|
|||
////////////////////////////////////////////////////////////////////
|
||||
void TinySDLGraphicsWindow::
|
||||
close_window() {
|
||||
glClose();
|
||||
GraphicsWindow::close_window();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@
|
|||
#include "pandabase.h"
|
||||
#include "textureContext.h"
|
||||
#include "deletedChain.h"
|
||||
#include "tinygl.h"
|
||||
|
||||
struct GLTexture;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,838 +0,0 @@
|
|||
/*
|
||||
* The following constants come from Mesa
|
||||
*/
|
||||
#ifndef GL_H
|
||||
#define GL_H
|
||||
|
||||
#define GL_VERSION_1_1 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum {
|
||||
/* Boolean values */
|
||||
GL_FALSE = 0,
|
||||
GL_TRUE = 1,
|
||||
|
||||
/* Data types */
|
||||
GL_BYTE = 0x1400,
|
||||
GL_UNSIGNED_BYTE = 0x1401,
|
||||
GL_SHORT = 0x1402,
|
||||
GL_UNSIGNED_SHORT = 0x1403,
|
||||
GL_INT = 0x1404,
|
||||
GL_UNSIGNED_INT = 0x1405,
|
||||
GL_FLOAT = 0x1406,
|
||||
GL_DOUBLE = 0x140A,
|
||||
GL_2_BYTES = 0x1407,
|
||||
GL_3_BYTES = 0x1408,
|
||||
GL_4_BYTES = 0x1409,
|
||||
|
||||
/* Primitives */
|
||||
GL_LINES = 0x0001,
|
||||
GL_POINTS = 0x0000,
|
||||
GL_LINE_STRIP = 0x0003,
|
||||
GL_LINE_LOOP = 0x0002,
|
||||
GL_TRIANGLES = 0x0004,
|
||||
GL_TRIANGLE_STRIP = 0x0005,
|
||||
GL_TRIANGLE_FAN = 0x0006,
|
||||
GL_QUADS = 0x0007,
|
||||
GL_QUAD_STRIP = 0x0008,
|
||||
GL_POLYGON = 0x0009,
|
||||
GL_EDGE_FLAG = 0x0B43,
|
||||
|
||||
/* Vertex Arrays */
|
||||
GL_VERTEX_ARRAY = 0x8074,
|
||||
GL_NORMAL_ARRAY = 0x8075,
|
||||
GL_COLOR_ARRAY = 0x8076,
|
||||
GL_INDEX_ARRAY = 0x8077,
|
||||
GL_TEXTURE_COORD_ARRAY = 0x8078,
|
||||
GL_EDGE_FLAG_ARRAY = 0x8079,
|
||||
GL_VERTEX_ARRAY_SIZE = 0x807A,
|
||||
GL_VERTEX_ARRAY_TYPE = 0x807B,
|
||||
GL_VERTEX_ARRAY_STRIDE = 0x807C,
|
||||
GL_VERTEX_ARRAY_COUNT = 0x807D,
|
||||
GL_NORMAL_ARRAY_TYPE = 0x807E,
|
||||
GL_NORMAL_ARRAY_STRIDE = 0x807F,
|
||||
GL_NORMAL_ARRAY_COUNT = 0x8080,
|
||||
GL_COLOR_ARRAY_SIZE = 0x8081,
|
||||
GL_COLOR_ARRAY_TYPE = 0x8082,
|
||||
GL_COLOR_ARRAY_STRIDE = 0x8083,
|
||||
GL_COLOR_ARRAY_COUNT = 0x8084,
|
||||
GL_INDEX_ARRAY_TYPE = 0x8085,
|
||||
GL_INDEX_ARRAY_STRIDE = 0x8086,
|
||||
GL_INDEX_ARRAY_COUNT = 0x8087,
|
||||
GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
|
||||
GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
|
||||
GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
|
||||
GL_TEXTURE_COORD_ARRAY_COUNT = 0x808B,
|
||||
GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
|
||||
GL_EDGE_FLAG_ARRAY_COUNT = 0x808D,
|
||||
GL_VERTEX_ARRAY_POINTER = 0x808E,
|
||||
GL_NORMAL_ARRAY_POINTER = 0x808F,
|
||||
GL_COLOR_ARRAY_POINTER = 0x8090,
|
||||
GL_INDEX_ARRAY_POINTER = 0x8091,
|
||||
GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
|
||||
GL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
|
||||
GL_V2F = 0x2A20,
|
||||
GL_V3F = 0x2A21,
|
||||
GL_C4UB_V2F = 0x2A22,
|
||||
GL_C4UB_V3F = 0x2A23,
|
||||
GL_C3F_V3F = 0x2A24,
|
||||
GL_N3F_V3F = 0x2A25,
|
||||
GL_C4F_N3F_V3F = 0x2A26,
|
||||
GL_T2F_V3F = 0x2A27,
|
||||
GL_T4F_V4F = 0x2A28,
|
||||
GL_T2F_C4UB_V3F = 0x2A29,
|
||||
GL_T2F_C3F_V3F = 0x2A2A,
|
||||
GL_T2F_N3F_V3F = 0x2A2B,
|
||||
GL_T2F_C4F_N3F_V3F = 0x2A2C,
|
||||
GL_T4F_C4F_N3F_V4F = 0x2A2D,
|
||||
|
||||
/* Matrix Mode */
|
||||
GL_MATRIX_MODE = 0x0BA0,
|
||||
GL_MODELVIEW = 0x1700,
|
||||
GL_PROJECTION = 0x1701,
|
||||
GL_TEXTURE = 0x1702,
|
||||
|
||||
/* Points */
|
||||
GL_POINT_SMOOTH = 0x0B10,
|
||||
GL_POINT_SIZE = 0x0B11,
|
||||
GL_POINT_SIZE_GRANULARITY = 0x0B13,
|
||||
GL_POINT_SIZE_RANGE = 0x0B12,
|
||||
|
||||
/* Lines */
|
||||
GL_LINE_SMOOTH = 0x0B20,
|
||||
GL_LINE_STIPPLE = 0x0B24,
|
||||
GL_LINE_STIPPLE_PATTERN = 0x0B25,
|
||||
GL_LINE_STIPPLE_REPEAT = 0x0B26,
|
||||
GL_LINE_WIDTH = 0x0B21,
|
||||
GL_LINE_WIDTH_GRANULARITY = 0x0B23,
|
||||
GL_LINE_WIDTH_RANGE = 0x0B22,
|
||||
|
||||
/* Polygons */
|
||||
GL_POINT = 0x1B00,
|
||||
GL_LINE = 0x1B01,
|
||||
GL_FILL = 0x1B02,
|
||||
GL_CCW = 0x0901,
|
||||
GL_CW = 0x0900,
|
||||
GL_FRONT = 0x0404,
|
||||
GL_BACK = 0x0405,
|
||||
GL_CULL_FACE = 0x0B44,
|
||||
GL_CULL_FACE_MODE = 0x0B45,
|
||||
GL_POLYGON_SMOOTH = 0x0B41,
|
||||
GL_POLYGON_STIPPLE = 0x0B42,
|
||||
GL_FRONT_FACE = 0x0B46,
|
||||
GL_POLYGON_MODE = 0x0B40,
|
||||
GL_POLYGON_OFFSET_FACTOR = 0x3038,
|
||||
GL_POLYGON_OFFSET_UNITS = 0x2A00,
|
||||
GL_POLYGON_OFFSET_POINT = 0x2A01,
|
||||
GL_POLYGON_OFFSET_LINE = 0x2A02,
|
||||
GL_POLYGON_OFFSET_FILL = 0x8037,
|
||||
|
||||
/* Display Lists */
|
||||
GL_COMPILE = 0x1300,
|
||||
GL_COMPILE_AND_EXECUTE = 0x1301,
|
||||
GL_LIST_BASE = 0x0B32,
|
||||
GL_LIST_INDEX = 0x0B33,
|
||||
GL_LIST_MODE = 0x0B30,
|
||||
|
||||
/* Depth buffer */
|
||||
GL_NEVER = 0x0200,
|
||||
GL_LESS = 0x0201,
|
||||
GL_GEQUAL = 0x0206,
|
||||
GL_LEQUAL = 0x0203,
|
||||
GL_GREATER = 0x0204,
|
||||
GL_NOTEQUAL = 0x0205,
|
||||
GL_EQUAL = 0x0202,
|
||||
GL_ALWAYS = 0x0207,
|
||||
GL_DEPTH_TEST = 0x0B71,
|
||||
GL_DEPTH_BITS = 0x0D56,
|
||||
GL_DEPTH_CLEAR_VALUE = 0x0B73,
|
||||
GL_DEPTH_FUNC = 0x0B74,
|
||||
GL_DEPTH_RANGE = 0x0B70,
|
||||
GL_DEPTH_WRITEMASK = 0x0B72,
|
||||
GL_DEPTH_COMPONENT = 0x1902,
|
||||
|
||||
/* Lighting */
|
||||
GL_LIGHTING = 0x0B50,
|
||||
GL_LIGHT0 = 0x4000,
|
||||
GL_LIGHT1 = 0x4001,
|
||||
GL_LIGHT2 = 0x4002,
|
||||
GL_LIGHT3 = 0x4003,
|
||||
GL_LIGHT4 = 0x4004,
|
||||
GL_LIGHT5 = 0x4005,
|
||||
GL_LIGHT6 = 0x4006,
|
||||
GL_LIGHT7 = 0x4007,
|
||||
GL_SPOT_EXPONENT = 0x1205,
|
||||
GL_SPOT_CUTOFF = 0x1206,
|
||||
GL_CONSTANT_ATTENUATION = 0x1207,
|
||||
GL_LINEAR_ATTENUATION = 0x1208,
|
||||
GL_QUADRATIC_ATTENUATION = 0x1209,
|
||||
GL_AMBIENT = 0x1200,
|
||||
GL_DIFFUSE = 0x1201,
|
||||
GL_SPECULAR = 0x1202,
|
||||
GL_SHININESS = 0x1601,
|
||||
GL_EMISSION = 0x1600,
|
||||
GL_POSITION = 0x1203,
|
||||
GL_SPOT_DIRECTION = 0x1204,
|
||||
GL_AMBIENT_AND_DIFFUSE = 0x1602,
|
||||
GL_COLOR_INDEXES = 0x1603,
|
||||
GL_LIGHT_MODEL_TWO_SIDE = 0x0B52,
|
||||
GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
|
||||
GL_LIGHT_MODEL_AMBIENT = 0x0B53,
|
||||
GL_FRONT_AND_BACK = 0x0408,
|
||||
GL_SHADE_MODEL = 0x0B54,
|
||||
GL_FLAT = 0x1D00,
|
||||
GL_SMOOTH = 0x1D01,
|
||||
GL_COLOR_MATERIAL = 0x0B57,
|
||||
GL_COLOR_MATERIAL_FACE = 0x0B55,
|
||||
GL_COLOR_MATERIAL_PARAMETER = 0x0B56,
|
||||
GL_NORMALIZE = 0x0BA1,
|
||||
|
||||
/* User clipping planes */
|
||||
GL_CLIP_PLANE0 = 0x3000,
|
||||
GL_CLIP_PLANE1 = 0x3001,
|
||||
GL_CLIP_PLANE2 = 0x3002,
|
||||
GL_CLIP_PLANE3 = 0x3003,
|
||||
GL_CLIP_PLANE4 = 0x3004,
|
||||
GL_CLIP_PLANE5 = 0x3005,
|
||||
|
||||
/* Accumulation buffer */
|
||||
GL_ACCUM_RED_BITS = 0x0D58,
|
||||
GL_ACCUM_GREEN_BITS = 0x0D59,
|
||||
GL_ACCUM_BLUE_BITS = 0x0D5A,
|
||||
GL_ACCUM_ALPHA_BITS = 0x0D5B,
|
||||
GL_ACCUM_CLEAR_VALUE = 0x0B80,
|
||||
GL_ACCUM = 0x0100,
|
||||
GL_ADD = 0x0104,
|
||||
GL_LOAD = 0x0101,
|
||||
GL_MULT = 0x0103,
|
||||
GL_RETURN = 0x0102,
|
||||
|
||||
/* Alpha testing */
|
||||
GL_ALPHA_TEST = 0x0BC0,
|
||||
GL_ALPHA_TEST_REF = 0x0BC2,
|
||||
GL_ALPHA_TEST_FUNC = 0x0BC1,
|
||||
|
||||
/* Blending */
|
||||
GL_BLEND = 0x0BE2,
|
||||
GL_BLEND_SRC = 0x0BE1,
|
||||
GL_BLEND_DST = 0x0BE0,
|
||||
GL_ZERO = 0,
|
||||
GL_ONE = 1,
|
||||
GL_SRC_COLOR = 0x0300,
|
||||
GL_ONE_MINUS_SRC_COLOR = 0x0301,
|
||||
GL_DST_COLOR = 0x0306,
|
||||
GL_ONE_MINUS_DST_COLOR = 0x0307,
|
||||
GL_SRC_ALPHA = 0x0302,
|
||||
GL_ONE_MINUS_SRC_ALPHA = 0x0303,
|
||||
GL_DST_ALPHA = 0x0304,
|
||||
GL_ONE_MINUS_DST_ALPHA = 0x0305,
|
||||
GL_SRC_ALPHA_SATURATE = 0x0308,
|
||||
GL_CONSTANT_COLOR = 0x8001,
|
||||
GL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
|
||||
GL_CONSTANT_ALPHA = 0x8003,
|
||||
GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
|
||||
|
||||
/* Render Mode */
|
||||
GL_FEEDBACK = 0x1C01,
|
||||
GL_RENDER = 0x1C00,
|
||||
GL_SELECT = 0x1C02,
|
||||
|
||||
/* Feedback */
|
||||
GL_2D = 0x0600,
|
||||
GL_3D = 0x0601,
|
||||
GL_3D_COLOR = 0x0602,
|
||||
GL_3D_COLOR_TEXTURE = 0x0603,
|
||||
GL_4D_COLOR_TEXTURE = 0x0604,
|
||||
GL_POINT_TOKEN = 0x0701,
|
||||
GL_LINE_TOKEN = 0x0702,
|
||||
GL_LINE_RESET_TOKEN = 0x0707,
|
||||
GL_POLYGON_TOKEN = 0x0703,
|
||||
GL_BITMAP_TOKEN = 0x0704,
|
||||
GL_DRAW_PIXEL_TOKEN = 0x0705,
|
||||
GL_COPY_PIXEL_TOKEN = 0x0706,
|
||||
GL_PASS_THROUGH_TOKEN = 0x0700,
|
||||
|
||||
/* Fog */
|
||||
GL_FOG = 0x0B60,
|
||||
GL_FOG_MODE = 0x0B65,
|
||||
GL_FOG_DENSITY = 0x0B62,
|
||||
GL_FOG_COLOR = 0x0B66,
|
||||
GL_FOG_INDEX = 0x0B61,
|
||||
GL_FOG_START = 0x0B63,
|
||||
GL_FOG_END = 0x0B64,
|
||||
GL_LINEAR = 0x2601,
|
||||
GL_EXP = 0x0800,
|
||||
GL_EXP2 = 0x0801,
|
||||
|
||||
/* Logic Ops */
|
||||
GL_LOGIC_OP = 0x0BF1,
|
||||
GL_LOGIC_OP_MODE = 0x0BF0,
|
||||
GL_CLEAR = 0x1500,
|
||||
GL_SET = 0x150F,
|
||||
GL_COPY = 0x1503,
|
||||
GL_COPY_INVERTED = 0x150C,
|
||||
GL_NOOP = 0x1505,
|
||||
GL_INVERT = 0x150A,
|
||||
GL_AND = 0x1501,
|
||||
GL_NAND = 0x150E,
|
||||
GL_OR = 0x1507,
|
||||
GL_NOR = 0x1508,
|
||||
GL_XOR = 0x1506,
|
||||
GL_EQUIV = 0x1509,
|
||||
GL_AND_REVERSE = 0x1502,
|
||||
GL_AND_INVERTED = 0x1504,
|
||||
GL_OR_REVERSE = 0x150B,
|
||||
GL_OR_INVERTED = 0x150D,
|
||||
|
||||
/* Stencil */
|
||||
GL_STENCIL_TEST = 0x0B90,
|
||||
GL_STENCIL_WRITEMASK = 0x0B98,
|
||||
GL_STENCIL_BITS = 0x0D57,
|
||||
GL_STENCIL_FUNC = 0x0B92,
|
||||
GL_STENCIL_VALUE_MASK = 0x0B93,
|
||||
GL_STENCIL_REF = 0x0B97,
|
||||
GL_STENCIL_FAIL = 0x0B94,
|
||||
GL_STENCIL_PASS_DEPTH_PASS = 0x0B96,
|
||||
GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,
|
||||
GL_STENCIL_CLEAR_VALUE = 0x0B91,
|
||||
GL_STENCIL_INDEX = 0x1901,
|
||||
GL_KEEP = 0x1E00,
|
||||
GL_REPLACE = 0x1E01,
|
||||
GL_INCR = 0x1E02,
|
||||
GL_DECR = 0x1E03,
|
||||
|
||||
/* Buffers, Pixel Drawing/Reading */
|
||||
GL_NONE = 0,
|
||||
GL_LEFT = 0x0406,
|
||||
GL_RIGHT = 0x0407,
|
||||
/*GL_FRONT = 0x0404, */
|
||||
/*GL_BACK = 0x0405, */
|
||||
/*GL_FRONT_AND_BACK = 0x0408, */
|
||||
GL_FRONT_LEFT = 0x0400,
|
||||
GL_FRONT_RIGHT = 0x0401,
|
||||
GL_BACK_LEFT = 0x0402,
|
||||
GL_BACK_RIGHT = 0x0403,
|
||||
GL_AUX0 = 0x0409,
|
||||
GL_AUX1 = 0x040A,
|
||||
GL_AUX2 = 0x040B,
|
||||
GL_AUX3 = 0x040C,
|
||||
GL_COLOR_INDEX = 0x1900,
|
||||
GL_RED = 0x1903,
|
||||
GL_GREEN = 0x1904,
|
||||
GL_BLUE = 0x1905,
|
||||
GL_ALPHA = 0x1906,
|
||||
GL_LUMINANCE = 0x1909,
|
||||
GL_LUMINANCE_ALPHA = 0x190A,
|
||||
GL_ALPHA_BITS = 0x0D55,
|
||||
GL_RED_BITS = 0x0D52,
|
||||
GL_GREEN_BITS = 0x0D53,
|
||||
GL_BLUE_BITS = 0x0D54,
|
||||
GL_INDEX_BITS = 0x0D51,
|
||||
GL_SUBPIXEL_BITS = 0x0D50,
|
||||
GL_AUX_BUFFERS = 0x0C00,
|
||||
GL_READ_BUFFER = 0x0C02,
|
||||
GL_DRAW_BUFFER = 0x0C01,
|
||||
GL_DOUBLEBUFFER = 0x0C32,
|
||||
GL_STEREO = 0x0C33,
|
||||
GL_BITMAP = 0x1A00,
|
||||
GL_COLOR = 0x1800,
|
||||
GL_DEPTH = 0x1801,
|
||||
GL_STENCIL = 0x1802,
|
||||
GL_DITHER = 0x0BD0,
|
||||
GL_RGB = 0x1907,
|
||||
GL_RGBA = 0x1908,
|
||||
|
||||
/* Implementation limits */
|
||||
GL_MAX_LIST_NESTING = 0x0B31,
|
||||
GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,
|
||||
GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
|
||||
GL_MAX_NAME_STACK_DEPTH = 0x0D37,
|
||||
GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38,
|
||||
GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,
|
||||
GL_MAX_EVAL_ORDER = 0x0D30,
|
||||
GL_MAX_LIGHTS = 0x0D31,
|
||||
GL_MAX_CLIP_PLANES = 0x0D32,
|
||||
GL_MAX_TEXTURE_SIZE = 0x0D33,
|
||||
GL_MAX_PIXEL_MAP_TABLE = 0x0D34,
|
||||
GL_MAX_VIEWPORT_DIMS = 0x0D3A,
|
||||
GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,
|
||||
|
||||
/* Gets */
|
||||
GL_ATTRIB_STACK_DEPTH = 0x0BB0,
|
||||
GL_COLOR_CLEAR_VALUE = 0x0C22,
|
||||
GL_COLOR_WRITEMASK = 0x0C23,
|
||||
GL_CURRENT_INDEX = 0x0B01,
|
||||
GL_CURRENT_COLOR = 0x0B00,
|
||||
GL_CURRENT_NORMAL = 0x0B02,
|
||||
GL_CURRENT_RASTER_COLOR = 0x0B04,
|
||||
GL_CURRENT_RASTER_DISTANCE = 0x0B09,
|
||||
GL_CURRENT_RASTER_INDEX = 0x0B05,
|
||||
GL_CURRENT_RASTER_POSITION = 0x0B07,
|
||||
GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
|
||||
GL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
|
||||
GL_CURRENT_TEXTURE_COORDS = 0x0B03,
|
||||
GL_INDEX_CLEAR_VALUE = 0x0C20,
|
||||
GL_INDEX_MODE = 0x0C30,
|
||||
GL_INDEX_WRITEMASK = 0x0C21,
|
||||
GL_MODELVIEW_MATRIX = 0x0BA6,
|
||||
GL_MODELVIEW_STACK_DEPTH = 0x0BA3,
|
||||
GL_NAME_STACK_DEPTH = 0x0D70,
|
||||
GL_PROJECTION_MATRIX = 0x0BA7,
|
||||
GL_PROJECTION_STACK_DEPTH = 0x0BA4,
|
||||
GL_RENDER_MODE = 0x0C40,
|
||||
GL_RGBA_MODE = 0x0C31,
|
||||
GL_TEXTURE_MATRIX = 0x0BA8,
|
||||
GL_TEXTURE_STACK_DEPTH = 0x0BA5,
|
||||
GL_VIEWPORT = 0x0BA2,
|
||||
|
||||
|
||||
/* Evaluators */
|
||||
GL_AUTO_NORMAL = 0x0D80,
|
||||
GL_MAP1_COLOR_4 = 0x0D90,
|
||||
GL_MAP1_GRID_DOMAIN = 0x0DD0,
|
||||
GL_MAP1_GRID_SEGMENTS = 0x0DD1,
|
||||
GL_MAP1_INDEX = 0x0D91,
|
||||
GL_MAP1_NORMAL = 0x0D92,
|
||||
GL_MAP1_TEXTURE_COORD_1 = 0x0D93,
|
||||
GL_MAP1_TEXTURE_COORD_2 = 0x0D94,
|
||||
GL_MAP1_TEXTURE_COORD_3 = 0x0D95,
|
||||
GL_MAP1_TEXTURE_COORD_4 = 0x0D96,
|
||||
GL_MAP1_VERTEX_3 = 0x0D97,
|
||||
GL_MAP1_VERTEX_4 = 0x0D98,
|
||||
GL_MAP2_COLOR_4 = 0x0DB0,
|
||||
GL_MAP2_GRID_DOMAIN = 0x0DD2,
|
||||
GL_MAP2_GRID_SEGMENTS = 0x0DD3,
|
||||
GL_MAP2_INDEX = 0x0DB1,
|
||||
GL_MAP2_NORMAL = 0x0DB2,
|
||||
GL_MAP2_TEXTURE_COORD_1 = 0x0DB3,
|
||||
GL_MAP2_TEXTURE_COORD_2 = 0x0DB4,
|
||||
GL_MAP2_TEXTURE_COORD_3 = 0x0DB5,
|
||||
GL_MAP2_TEXTURE_COORD_4 = 0x0DB6,
|
||||
GL_MAP2_VERTEX_3 = 0x0DB7,
|
||||
GL_MAP2_VERTEX_4 = 0x0DB8,
|
||||
GL_COEFF = 0x0A00,
|
||||
GL_DOMAIN = 0x0A02,
|
||||
GL_ORDER = 0x0A01,
|
||||
|
||||
/* Hints */
|
||||
GL_FOG_HINT = 0x0C54,
|
||||
GL_LINE_SMOOTH_HINT = 0x0C52,
|
||||
GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50,
|
||||
GL_POINT_SMOOTH_HINT = 0x0C51,
|
||||
GL_POLYGON_SMOOTH_HINT = 0x0C53,
|
||||
GL_DONT_CARE = 0x1100,
|
||||
GL_FASTEST = 0x1101,
|
||||
GL_NICEST = 0x1102,
|
||||
|
||||
/* Scissor box */
|
||||
GL_SCISSOR_TEST = 0x0C11,
|
||||
GL_SCISSOR_BOX = 0x0C10,
|
||||
|
||||
/* Pixel Mode / Transfer */
|
||||
GL_MAP_COLOR = 0x0D10,
|
||||
GL_MAP_STENCIL = 0x0D11,
|
||||
GL_INDEX_SHIFT = 0x0D12,
|
||||
GL_INDEX_OFFSET = 0x0D13,
|
||||
GL_RED_SCALE = 0x0D14,
|
||||
GL_RED_BIAS = 0x0D15,
|
||||
GL_GREEN_SCALE = 0x0D18,
|
||||
GL_GREEN_BIAS = 0x0D19,
|
||||
GL_BLUE_SCALE = 0x0D1A,
|
||||
GL_BLUE_BIAS = 0x0D1B,
|
||||
GL_ALPHA_SCALE = 0x0D1C,
|
||||
GL_ALPHA_BIAS = 0x0D1D,
|
||||
GL_DEPTH_SCALE = 0x0D1E,
|
||||
GL_DEPTH_BIAS = 0x0D1F,
|
||||
GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
|
||||
GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
|
||||
GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
|
||||
GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
|
||||
GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
|
||||
GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
|
||||
GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
|
||||
GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
|
||||
GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
|
||||
GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
|
||||
GL_PIXEL_MAP_S_TO_S = 0x0C71,
|
||||
GL_PIXEL_MAP_I_TO_I = 0x0C70,
|
||||
GL_PIXEL_MAP_I_TO_R = 0x0C72,
|
||||
GL_PIXEL_MAP_I_TO_G = 0x0C73,
|
||||
GL_PIXEL_MAP_I_TO_B = 0x0C74,
|
||||
GL_PIXEL_MAP_I_TO_A = 0x0C75,
|
||||
GL_PIXEL_MAP_R_TO_R = 0x0C76,
|
||||
GL_PIXEL_MAP_G_TO_G = 0x0C77,
|
||||
GL_PIXEL_MAP_B_TO_B = 0x0C78,
|
||||
GL_PIXEL_MAP_A_TO_A = 0x0C79,
|
||||
GL_PACK_ALIGNMENT = 0x0D05,
|
||||
GL_PACK_LSB_FIRST = 0x0D01,
|
||||
GL_PACK_ROW_LENGTH = 0x0D02,
|
||||
GL_PACK_SKIP_PIXELS = 0x0D04,
|
||||
GL_PACK_SKIP_ROWS = 0x0D03,
|
||||
GL_PACK_SWAP_BYTES = 0x0D00,
|
||||
GL_UNPACK_ALIGNMENT = 0x0CF5,
|
||||
GL_UNPACK_LSB_FIRST = 0x0CF1,
|
||||
GL_UNPACK_ROW_LENGTH = 0x0CF2,
|
||||
GL_UNPACK_SKIP_PIXELS = 0x0CF4,
|
||||
GL_UNPACK_SKIP_ROWS = 0x0CF3,
|
||||
GL_UNPACK_SWAP_BYTES = 0x0CF0,
|
||||
GL_ZOOM_X = 0x0D16,
|
||||
GL_ZOOM_Y = 0x0D17,
|
||||
|
||||
/* Texture mapping */
|
||||
GL_TEXTURE_ENV = 0x2300,
|
||||
GL_TEXTURE_ENV_MODE = 0x2200,
|
||||
GL_TEXTURE_1D = 0x0DE0,
|
||||
GL_TEXTURE_2D = 0x0DE1,
|
||||
GL_TEXTURE_WRAP_S = 0x2802,
|
||||
GL_TEXTURE_WRAP_T = 0x2803,
|
||||
GL_TEXTURE_MAG_FILTER = 0x2800,
|
||||
GL_TEXTURE_MIN_FILTER = 0x2801,
|
||||
GL_TEXTURE_ENV_COLOR = 0x2201,
|
||||
GL_TEXTURE_GEN_S = 0x0C60,
|
||||
GL_TEXTURE_GEN_T = 0x0C61,
|
||||
GL_TEXTURE_GEN_MODE = 0x2500,
|
||||
GL_TEXTURE_BORDER_COLOR = 0x1004,
|
||||
GL_TEXTURE_WIDTH = 0x1000,
|
||||
GL_TEXTURE_HEIGHT = 0x1001,
|
||||
GL_TEXTURE_BORDER = 0x1005,
|
||||
GL_TEXTURE_COMPONENTS = 0x1003,
|
||||
GL_NEAREST_MIPMAP_NEAREST = 0x2700,
|
||||
GL_NEAREST_MIPMAP_LINEAR = 0x2702,
|
||||
GL_LINEAR_MIPMAP_NEAREST = 0x2701,
|
||||
GL_LINEAR_MIPMAP_LINEAR = 0x2703,
|
||||
GL_OBJECT_LINEAR = 0x2401,
|
||||
GL_OBJECT_PLANE = 0x2501,
|
||||
GL_EYE_LINEAR = 0x2400,
|
||||
GL_EYE_PLANE = 0x2502,
|
||||
GL_SPHERE_MAP = 0x2402,
|
||||
GL_DECAL = 0x2101,
|
||||
GL_MODULATE = 0x2100,
|
||||
GL_NEAREST = 0x2600,
|
||||
GL_REPEAT = 0x2901,
|
||||
GL_CLAMP = 0x2900,
|
||||
GL_S = 0x2000,
|
||||
GL_T = 0x2001,
|
||||
GL_R = 0x2002,
|
||||
GL_Q = 0x2003,
|
||||
GL_TEXTURE_GEN_R = 0x0C62,
|
||||
GL_TEXTURE_GEN_Q = 0x0C63,
|
||||
|
||||
GL_PROXY_TEXTURE_1D = 0x8063,
|
||||
GL_PROXY_TEXTURE_2D = 0x8064,
|
||||
GL_TEXTURE_PRIORITY = 0x8066,
|
||||
GL_TEXTURE_RESIDENT = 0x8067,
|
||||
GL_TEXTURE_1D_BINDING = 0x8068,
|
||||
GL_TEXTURE_2D_BINDING = 0x8069,
|
||||
|
||||
/* Internal texture formats */
|
||||
GL_ALPHA4 = 0x803B,
|
||||
GL_ALPHA8 = 0x803C,
|
||||
GL_ALPHA12 = 0x803D,
|
||||
GL_ALPHA16 = 0x803E,
|
||||
GL_LUMINANCE4 = 0x803F,
|
||||
GL_LUMINANCE8 = 0x8040,
|
||||
GL_LUMINANCE12 = 0x8041,
|
||||
GL_LUMINANCE16 = 0x8042,
|
||||
GL_LUMINANCE4_ALPHA4 = 0x8043,
|
||||
GL_LUMINANCE6_ALPHA2 = 0x8044,
|
||||
GL_LUMINANCE8_ALPHA8 = 0x8045,
|
||||
GL_LUMINANCE12_ALPHA4 = 0x8046,
|
||||
GL_LUMINANCE12_ALPHA12 = 0x8047,
|
||||
GL_LUMINANCE16_ALPHA16 = 0x8048,
|
||||
GL_INTENSITY = 0x8049,
|
||||
GL_INTENSITY4 = 0x804A,
|
||||
GL_INTENSITY8 = 0x804B,
|
||||
GL_INTENSITY12 = 0x804C,
|
||||
GL_INTENSITY16 = 0x804D,
|
||||
GL_R3_G3_B2 = 0x2A10,
|
||||
GL_RGB4 = 0x804F,
|
||||
GL_RGB5 = 0x8050,
|
||||
GL_RGB8 = 0x8051,
|
||||
GL_RGB10 = 0x8052,
|
||||
GL_RGB12 = 0x8053,
|
||||
GL_RGB16 = 0x8054,
|
||||
GL_RGBA2 = 0x8055,
|
||||
GL_RGBA4 = 0x8056,
|
||||
GL_RGB5_A1 = 0x8057,
|
||||
GL_RGBA8 = 0x8058,
|
||||
GL_RGB10_A2 = 0x8059,
|
||||
GL_RGBA12 = 0x805A,
|
||||
GL_RGBA16 = 0x805B,
|
||||
|
||||
/* Utility */
|
||||
GL_VENDOR = 0x1F00,
|
||||
GL_RENDERER = 0x1F01,
|
||||
GL_VERSION = 0x1F02,
|
||||
GL_EXTENSIONS = 0x1F03,
|
||||
|
||||
/* Errors */
|
||||
GL_INVALID_VALUE = 0x0501,
|
||||
GL_INVALID_ENUM = 0x0500,
|
||||
GL_INVALID_OPERATION = 0x0502,
|
||||
GL_STACK_OVERFLOW = 0x0503,
|
||||
GL_STACK_UNDERFLOW = 0x0504,
|
||||
GL_OUT_OF_MEMORY = 0x0505,
|
||||
|
||||
/*
|
||||
* 1.0 Extensions
|
||||
*/
|
||||
/* GL_EXT_blend_minmax and GL_EXT_blend_color */
|
||||
GL_CONSTANT_COLOR_EXT = 0x8001,
|
||||
GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
|
||||
GL_CONSTANT_ALPHA_EXT = 0x8003,
|
||||
GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
|
||||
GL_BLEND_EQUATION_EXT = 0x8009,
|
||||
GL_MIN_EXT = 0x8007,
|
||||
GL_MAX_EXT = 0x8008,
|
||||
GL_FUNC_ADD_EXT = 0x8006,
|
||||
GL_FUNC_SUBTRACT_EXT = 0x800A,
|
||||
GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
|
||||
GL_BLEND_COLOR_EXT = 0x8005,
|
||||
|
||||
/* GL_EXT_polygon_offset */
|
||||
GL_POLYGON_OFFSET_EXT = 0x8037,
|
||||
GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038,
|
||||
GL_POLYGON_OFFSET_BIAS_EXT = 0x8039,
|
||||
|
||||
/* GL_EXT_vertex_array */
|
||||
GL_VERTEX_ARRAY_EXT = 0x8074,
|
||||
GL_NORMAL_ARRAY_EXT = 0x8075,
|
||||
GL_COLOR_ARRAY_EXT = 0x8076,
|
||||
GL_INDEX_ARRAY_EXT = 0x8077,
|
||||
GL_TEXTURE_COORD_ARRAY_EXT = 0x8078,
|
||||
GL_EDGE_FLAG_ARRAY_EXT = 0x8079,
|
||||
GL_VERTEX_ARRAY_SIZE_EXT = 0x807A,
|
||||
GL_VERTEX_ARRAY_TYPE_EXT = 0x807B,
|
||||
GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C,
|
||||
GL_VERTEX_ARRAY_COUNT_EXT = 0x807D,
|
||||
GL_NORMAL_ARRAY_TYPE_EXT = 0x807E,
|
||||
GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F,
|
||||
GL_NORMAL_ARRAY_COUNT_EXT = 0x8080,
|
||||
GL_COLOR_ARRAY_SIZE_EXT = 0x8081,
|
||||
GL_COLOR_ARRAY_TYPE_EXT = 0x8082,
|
||||
GL_COLOR_ARRAY_STRIDE_EXT = 0x8083,
|
||||
GL_COLOR_ARRAY_COUNT_EXT = 0x8084,
|
||||
GL_INDEX_ARRAY_TYPE_EXT = 0x8085,
|
||||
GL_INDEX_ARRAY_STRIDE_EXT = 0x8086,
|
||||
GL_INDEX_ARRAY_COUNT_EXT = 0x8087,
|
||||
GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
|
||||
GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
|
||||
GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A,
|
||||
GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B,
|
||||
GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
|
||||
GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
|
||||
GL_VERTEX_ARRAY_POINTER_EXT = 0x808E,
|
||||
GL_NORMAL_ARRAY_POINTER_EXT = 0x808F,
|
||||
GL_COLOR_ARRAY_POINTER_EXT = 0x8090,
|
||||
GL_INDEX_ARRAY_POINTER_EXT = 0x8091,
|
||||
GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092,
|
||||
GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093
|
||||
|
||||
};
|
||||
|
||||
enum {
|
||||
GL_CURRENT_BIT = 0x00000001,
|
||||
GL_POINT_BIT = 0x00000002,
|
||||
GL_LINE_BIT = 0x00000004,
|
||||
GL_POLYGON_BIT = 0x00000008,
|
||||
GL_POLYGON_STIPPLE_BIT = 0x00000010,
|
||||
GL_PIXEL_MODE_BIT = 0x00000020,
|
||||
GL_LIGHTING_BIT = 0x00000040,
|
||||
GL_FOG_BIT = 0x00000080,
|
||||
GL_DEPTH_BUFFER_BIT = 0x00000100,
|
||||
GL_ACCUM_BUFFER_BIT = 0x00000200,
|
||||
GL_STENCIL_BUFFER_BIT = 0x00000400,
|
||||
GL_VIEWPORT_BIT = 0x00000800,
|
||||
GL_TRANSFORM_BIT = 0x00001000,
|
||||
GL_ENABLE_BIT = 0x00002000,
|
||||
GL_COLOR_BUFFER_BIT = 0x00004000,
|
||||
GL_HINT_BIT = 0x00008000,
|
||||
GL_EVAL_BIT = 0x00010000,
|
||||
GL_LIST_BIT = 0x00020000,
|
||||
GL_TEXTURE_BIT = 0x00040000,
|
||||
GL_SCISSOR_BIT = 0x00080000,
|
||||
GL_ALL_ATTRIB_BITS = 0x000fffff
|
||||
};
|
||||
|
||||
/* some types */
|
||||
|
||||
typedef int GLenum;
|
||||
typedef void GLvoid;
|
||||
typedef unsigned char GLboolean;
|
||||
typedef signed char GLbyte; /* 1-byte signed */
|
||||
typedef short GLshort; /* 2-byte signed */
|
||||
typedef int GLint; /* 4-byte signed */
|
||||
typedef unsigned char GLubyte; /* 1-byte unsigned */
|
||||
typedef unsigned short GLushort; /* 2-byte unsigned */
|
||||
typedef unsigned int GLuint; /* 4-byte unsigned */
|
||||
typedef float GLfloat; /* single precision float */
|
||||
typedef double GLdouble; /* double precision float */
|
||||
typedef int GLsizei;
|
||||
|
||||
/* functions */
|
||||
|
||||
void glEnable(int code);
|
||||
void glDisable(int code);
|
||||
|
||||
void glShadeModel(int mode);
|
||||
void glCullFace(int mode);
|
||||
void glPolygonMode(int face,int mode);
|
||||
|
||||
void glBegin(int type);
|
||||
void glEnd(void);
|
||||
|
||||
#define PROTO_GL1(name) \
|
||||
void gl ## name ## 1f(float); \
|
||||
void gl ## name ## 1d(double); \
|
||||
void gl ## name ## 1fv(float *); \
|
||||
void gl ## name ## 1dv(double *);
|
||||
|
||||
#define PROTO_GL2(name) \
|
||||
void gl ## name ## 2f(float ,float); \
|
||||
void gl ## name ## 2d(double ,double); \
|
||||
void gl ## name ## 2fv(float *); \
|
||||
void gl ## name ## 2dv(double *);
|
||||
|
||||
#define PROTO_GL3(name) \
|
||||
void gl ## name ## 3f(float ,float ,float); \
|
||||
void gl ## name ## 3d(double ,double ,double); \
|
||||
void gl ## name ## 3fv(float *); \
|
||||
void gl ## name ## 3dv(double *);
|
||||
|
||||
#define PROTO_GL4(name) \
|
||||
void gl ## name ## 4f(float ,float ,float, float ); \
|
||||
void gl ## name ## 4d(double ,double ,double, double ); \
|
||||
void gl ## name ## 4fv(float *); \
|
||||
void gl ## name ## 4dv(double *);
|
||||
|
||||
PROTO_GL2(Vertex)
|
||||
PROTO_GL3(Vertex)
|
||||
PROTO_GL4(Vertex)
|
||||
|
||||
PROTO_GL3(Color)
|
||||
PROTO_GL4(Color)
|
||||
|
||||
PROTO_GL3(Normal)
|
||||
|
||||
PROTO_GL1(TexCoord)
|
||||
PROTO_GL2(TexCoord)
|
||||
PROTO_GL3(TexCoord)
|
||||
PROTO_GL4(TexCoord)
|
||||
|
||||
void glEdgeFlag(int flag);
|
||||
|
||||
/* matrix */
|
||||
void glMatrixMode(int mode);
|
||||
void glLoadMatrixf(const float *m);
|
||||
void glLoadIdentity(void);
|
||||
void glMultMatrixf(const float *m);
|
||||
void glPushMatrix(void);
|
||||
void glPopMatrix(void);
|
||||
void glRotatef(float angle,float x,float y,float z);
|
||||
void glTranslatef(float x,float y,float z);
|
||||
void glScalef(float x,float y,float z);
|
||||
|
||||
void glViewport(int x,int y,int width,int height);
|
||||
void glFrustum(double left,double right,double bottom,double top,
|
||||
double near,double far);
|
||||
|
||||
/* lists */
|
||||
unsigned int glGenLists(int range);
|
||||
int glIsList(unsigned int list);
|
||||
void glNewList(unsigned int list,int mode);
|
||||
void glEndList(void);
|
||||
void glCallList(unsigned int list);
|
||||
|
||||
/* clear */
|
||||
void glClear(int mask);
|
||||
void glClearColor(float r,float g,float b,float a);
|
||||
void glClearDepth(double depth);
|
||||
|
||||
/* selection */
|
||||
int glRenderMode(int mode);
|
||||
void glSelectBuffer(int size,unsigned int *buf);
|
||||
|
||||
void glInitNames(void);
|
||||
void glPushName(unsigned int name);
|
||||
void glPopName(void);
|
||||
void glLoadName(unsigned int name);
|
||||
|
||||
/* textures */
|
||||
void glGenTextures(int n, unsigned int *textures);
|
||||
void glDeleteTextures(int n, const unsigned int *textures);
|
||||
void glBindTexture(int target,int texture);
|
||||
void glTexImage2D( int target, int level, int components,
|
||||
int width, int height, int border,
|
||||
int format, int type, void *pixels);
|
||||
void glTexEnvi(int target,int pname,int param);
|
||||
void glTexParameteri(int target,int pname,int param);
|
||||
void glPixelStorei(int pname,int param);
|
||||
|
||||
/* lighting */
|
||||
|
||||
void glMaterialfv(int mode,int type,float *v);
|
||||
void glMaterialf(int mode,int type,float v);
|
||||
void glColorMaterial(int mode,int type);
|
||||
|
||||
void glLightfv(int light,int type,float *v);
|
||||
void glLightf(int light,int type,float v);
|
||||
void glLightModeli(int pname,int param);
|
||||
void glLightModelfv(int pname,float *param);
|
||||
|
||||
/* misc */
|
||||
|
||||
void glFlush(void);
|
||||
void glHint(int target,int mode);
|
||||
void glGetIntegerv(int pname,int *params);
|
||||
void glGetFloatv(int pname, float *v);
|
||||
void glFrontFace(int mode);
|
||||
|
||||
/* opengl 1.2 arrays */
|
||||
void glEnableClientState(GLenum array);
|
||||
void glDisableClientState(GLenum array);
|
||||
void glArrayElement(GLint i);
|
||||
void glVertexPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer);
|
||||
void glColorPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer);
|
||||
void glNormalPointer(GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer);
|
||||
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid *pointer);
|
||||
|
||||
/* opengl 1.2 polygon offset */
|
||||
void glPolygonOffset(GLfloat factor, GLfloat units);
|
||||
|
||||
/* not implemented, just added to compile */
|
||||
/*
|
||||
inline void glPointSize(float) {}
|
||||
inline void glLineWidth(float) {}
|
||||
inline void glDeleteLists(int, int) {}
|
||||
inline void glDepthFunc(int) {}
|
||||
inline void glBlendFunc(int, int) {}
|
||||
inline void glTexEnvf(int, int, int) {}
|
||||
inline void glOrtho(float,float,float,float,float,float){}
|
||||
inline void glVertex2i(int,int) {}
|
||||
inline void glDepthMask(int) {}
|
||||
inline void glFogi(int, int) {}
|
||||
inline void glFogfv(int, const float*) {}
|
||||
inline void glFogf(int, float) {}
|
||||
inline void glRasterPos2f(float, float) {}
|
||||
inline void glPolygonStipple(void*) {}
|
||||
inline void glTexParameterf(int, int, int) {};
|
||||
*/
|
||||
/* non compatible functions */
|
||||
|
||||
void glDebug(int mode);
|
||||
|
||||
void glInit(void *zbuffer);
|
||||
void glClose(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
|
||||
void gluPerspective( GLdouble fovy, GLdouble aspect,
|
||||
GLdouble zNear, GLdouble zFar );
|
||||
|
||||
typedef struct {
|
||||
int draw_style;
|
||||
} GLUquadricObj;
|
||||
|
||||
#define GLU_LINE 0
|
||||
|
||||
GLUquadricObj *gluNewQuadric(void);
|
||||
void gluQuadricDrawStyle(GLUquadricObj *obj, int style);
|
||||
|
||||
void gluSphere(GLUquadricObj *qobj,
|
||||
float radius,int slices,int stacks);
|
||||
void gluCylinder( GLUquadricObj *qobj,
|
||||
GLdouble baseRadius, GLdouble topRadius, GLdouble height,
|
||||
GLint slices, GLint stacks );
|
||||
void gluDisk( GLUquadricObj *qobj,
|
||||
GLdouble innerRadius, GLdouble outerRadius,
|
||||
GLint slices, GLint loops );
|
||||
|
||||
void drawTorus(float rc, int numc, float rt, int numt);
|
||||
|
|
@ -1,58 +1,6 @@
|
|||
#include "zgl.h"
|
||||
#include "string.h"
|
||||
|
||||
void glopNormal(GLContext * c, GLParam * p)
|
||||
{
|
||||
V3 v;
|
||||
|
||||
v.X = p[1].f;
|
||||
v.Y = p[2].f;
|
||||
v.Z = p[3].f;
|
||||
|
||||
c->current_normal.X = v.X;
|
||||
c->current_normal.Y = v.Y;
|
||||
c->current_normal.Z = v.Z;
|
||||
c->current_normal.W = 0;
|
||||
}
|
||||
|
||||
void glopTexCoord(GLContext * c, GLParam * p)
|
||||
{
|
||||
c->current_tex_coord.X = p[1].f;
|
||||
c->current_tex_coord.Y = p[2].f;
|
||||
c->current_tex_coord.Z = p[3].f;
|
||||
c->current_tex_coord.W = p[4].f;
|
||||
}
|
||||
|
||||
void glopEdgeFlag(GLContext * c, GLParam * p)
|
||||
{
|
||||
c->current_edge_flag = p[1].i;
|
||||
}
|
||||
|
||||
void glopColor(GLContext * c, GLParam * p)
|
||||
{
|
||||
|
||||
c->current_color.X = p[1].f;
|
||||
c->current_color.Y = p[2].f;
|
||||
c->current_color.Z = p[3].f;
|
||||
c->current_color.W = p[4].f;
|
||||
c->longcurrent_color[0] = p[5].ui;
|
||||
c->longcurrent_color[1] = p[6].ui;
|
||||
c->longcurrent_color[2] = p[7].ui;
|
||||
|
||||
if (c->color_material_enabled) {
|
||||
GLParam q[7];
|
||||
q[0].op = OP_Material;
|
||||
q[1].i = c->current_color_material_mode;
|
||||
q[2].i = c->current_color_material_type;
|
||||
q[3].f = p[1].f;
|
||||
q[4].f = p[2].f;
|
||||
q[5].f = p[3].f;
|
||||
q[6].f = p[4].f;
|
||||
glopMaterial(c, q);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void gl_eval_viewport(GLContext * c)
|
||||
{
|
||||
GLViewport *v;
|
||||
|
|
@ -69,81 +17,9 @@ void gl_eval_viewport(GLContext * c)
|
|||
v->scale.Z = -((zsize - 0.5) / 2.0);
|
||||
}
|
||||
|
||||
void glopBegin(GLContext * c, GLParam * p)
|
||||
{
|
||||
int type;
|
||||
M4 tmp;
|
||||
|
||||
assert(c->in_begin == 0);
|
||||
|
||||
type = p[1].i;
|
||||
c->begin_type = type;
|
||||
c->in_begin = 1;
|
||||
c->vertex_n = 0;
|
||||
c->vertex_cnt = 0;
|
||||
|
||||
if (c->matrix_model_projection_updated) {
|
||||
|
||||
if (c->lighting_enabled) {
|
||||
/* precompute inverse modelview */
|
||||
gl_M4_Inv(&tmp, c->matrix_stack_ptr[0]);
|
||||
gl_M4_Transpose(&c->matrix_model_view_inv, &tmp);
|
||||
} else {
|
||||
float *m = &c->matrix_model_projection.m[0][0];
|
||||
/* precompute projection matrix */
|
||||
gl_M4_Mul(&c->matrix_model_projection,
|
||||
c->matrix_stack_ptr[1],
|
||||
c->matrix_stack_ptr[0]);
|
||||
/* test to accelerate computation */
|
||||
c->matrix_model_projection_no_w_transform = 0;
|
||||
if (m[12] == 0.0 && m[13] == 0.0 && m[14] == 0.0)
|
||||
c->matrix_model_projection_no_w_transform = 1;
|
||||
}
|
||||
|
||||
/* test if the texture matrix is not Identity */
|
||||
c->apply_texture_matrix = !gl_M4_IsId(c->matrix_stack_ptr[2]);
|
||||
|
||||
c->matrix_model_projection_updated = 0;
|
||||
}
|
||||
/* viewport */
|
||||
if (c->viewport.updated) {
|
||||
gl_eval_viewport(c);
|
||||
c->viewport.updated = 0;
|
||||
}
|
||||
/* triangle drawing functions */
|
||||
if (c->render_mode == GL_SELECT) {
|
||||
c->draw_triangle_front = gl_draw_triangle_select;
|
||||
c->draw_triangle_back = gl_draw_triangle_select;
|
||||
} else {
|
||||
switch (c->polygon_mode_front) {
|
||||
case GL_POINT:
|
||||
c->draw_triangle_front = gl_draw_triangle_point;
|
||||
break;
|
||||
case GL_LINE:
|
||||
c->draw_triangle_front = gl_draw_triangle_line;
|
||||
break;
|
||||
default:
|
||||
c->draw_triangle_front = gl_draw_triangle_fill;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (c->polygon_mode_back) {
|
||||
case GL_POINT:
|
||||
c->draw_triangle_back = gl_draw_triangle_point;
|
||||
break;
|
||||
case GL_LINE:
|
||||
c->draw_triangle_back = gl_draw_triangle_line;
|
||||
break;
|
||||
default:
|
||||
c->draw_triangle_back = gl_draw_triangle_fill;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* coords, tranformation , clip code and projection */
|
||||
/* TODO : handle all cases */
|
||||
static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
|
||||
void gl_vertex_transform(GLContext * c, GLVertex * v)
|
||||
{
|
||||
float *m;
|
||||
V4 *n;
|
||||
|
|
@ -151,7 +27,7 @@ static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
|
|||
if (c->lighting_enabled) {
|
||||
/* eye coordinates needed for lighting */
|
||||
|
||||
m = &c->matrix_stack_ptr[0]->m[0][0];
|
||||
m = &c->matrix_model_view.m[0][0];
|
||||
v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
|
||||
v->coord.Z * m[2] + m[3]);
|
||||
v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
|
||||
|
|
@ -162,7 +38,7 @@ static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
|
|||
v->coord.Z * m[14] + m[15]);
|
||||
|
||||
/* projection coordinates */
|
||||
m = &c->matrix_stack_ptr[1]->m[0][0];
|
||||
m = &c->matrix_projection.m[0][0];
|
||||
v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] +
|
||||
v->ec.Z * m[2] + v->ec.W * m[3]);
|
||||
v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] +
|
||||
|
|
@ -203,163 +79,3 @@ static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
|
|||
|
||||
v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W);
|
||||
}
|
||||
|
||||
void glopVertex(GLContext * c, GLParam * p)
|
||||
{
|
||||
GLVertex *v;
|
||||
int n, i, cnt;
|
||||
|
||||
assert(c->in_begin != 0);
|
||||
|
||||
n = c->vertex_n;
|
||||
cnt = c->vertex_cnt;
|
||||
cnt++;
|
||||
c->vertex_cnt = cnt;
|
||||
|
||||
/* quick fix to avoid crashes on large polygons */
|
||||
if (n >= c->vertex_max) {
|
||||
GLVertex *newarray;
|
||||
c->vertex_max <<= 1; /* just double size */
|
||||
newarray = gl_malloc(sizeof(GLVertex) * c->vertex_max);
|
||||
if (!newarray) {
|
||||
gl_fatal_error("unable to allocate GLVertex array.\n");
|
||||
}
|
||||
memcpy(newarray, c->vertex, n * sizeof(GLVertex));
|
||||
gl_free(c->vertex);
|
||||
c->vertex = newarray;
|
||||
}
|
||||
/* new vertex entry */
|
||||
v = &c->vertex[n];
|
||||
n++;
|
||||
|
||||
v->coord.X = p[1].f;
|
||||
v->coord.Y = p[2].f;
|
||||
v->coord.Z = p[3].f;
|
||||
v->coord.W = p[4].f;
|
||||
|
||||
gl_vertex_transform(c, v);
|
||||
|
||||
/* color */
|
||||
|
||||
if (c->lighting_enabled) {
|
||||
gl_shade_vertex(c, v);
|
||||
} else {
|
||||
v->color = c->current_color;
|
||||
}
|
||||
|
||||
/* tex coords */
|
||||
|
||||
if (c->texture_2d_enabled) {
|
||||
if (c->apply_texture_matrix) {
|
||||
gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);
|
||||
} else {
|
||||
v->tex_coord = c->current_tex_coord;
|
||||
}
|
||||
}
|
||||
/* precompute the mapping to the viewport */
|
||||
if (v->clip_code == 0)
|
||||
gl_transform_to_viewport(c, v);
|
||||
|
||||
/* edge flag */
|
||||
|
||||
v->edge_flag = c->current_edge_flag;
|
||||
|
||||
switch (c->begin_type) {
|
||||
case GL_POINTS:
|
||||
gl_draw_point(c, &c->vertex[0]);
|
||||
n = 0;
|
||||
break;
|
||||
|
||||
case GL_LINES:
|
||||
if (n == 2) {
|
||||
gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
|
||||
n = 0;
|
||||
}
|
||||
break;
|
||||
case GL_LINE_STRIP:
|
||||
case GL_LINE_LOOP:
|
||||
if (n == 1) {
|
||||
c->vertex[2] = c->vertex[0];
|
||||
} else if (n == 2) {
|
||||
gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
|
||||
c->vertex[0] = c->vertex[1];
|
||||
n = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case GL_TRIANGLES:
|
||||
if (n == 3) {
|
||||
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
|
||||
n = 0;
|
||||
}
|
||||
break;
|
||||
case GL_TRIANGLE_STRIP:
|
||||
if (cnt >= 3) {
|
||||
if (n == 3)
|
||||
n = 0;
|
||||
/* needed to respect triangle orientation */
|
||||
switch(cnt & 1) {
|
||||
case 0:
|
||||
gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]);
|
||||
break;
|
||||
default:
|
||||
case 1:
|
||||
gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case GL_TRIANGLE_FAN:
|
||||
if (n == 3) {
|
||||
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
|
||||
c->vertex[1] = c->vertex[2];
|
||||
n = 2;
|
||||
}
|
||||
break;
|
||||
|
||||
case GL_QUADS:
|
||||
if (n == 4) {
|
||||
c->vertex[2].edge_flag = 0;
|
||||
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
|
||||
c->vertex[2].edge_flag = 1;
|
||||
c->vertex[0].edge_flag = 0;
|
||||
gl_draw_triangle(c, &c->vertex[0], &c->vertex[2], &c->vertex[3]);
|
||||
n = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case GL_QUAD_STRIP:
|
||||
if (n == 4) {
|
||||
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
|
||||
gl_draw_triangle(c, &c->vertex[1], &c->vertex[3], &c->vertex[2]);
|
||||
for (i = 0; i < 2; i++)
|
||||
c->vertex[i] = c->vertex[i + 2];
|
||||
n = 2;
|
||||
}
|
||||
break;
|
||||
case GL_POLYGON:
|
||||
break;
|
||||
default:
|
||||
gl_fatal_error("glBegin: type %x not handled\n", c->begin_type);
|
||||
}
|
||||
|
||||
c->vertex_n = n;
|
||||
}
|
||||
|
||||
void glopEnd(GLContext * c, GLParam * param)
|
||||
{
|
||||
assert(c->in_begin == 1);
|
||||
|
||||
if (c->begin_type == GL_LINE_LOOP) {
|
||||
if (c->vertex_cnt >= 3) {
|
||||
gl_draw_line(c, &c->vertex[0], &c->vertex[2]);
|
||||
}
|
||||
} else if (c->begin_type == GL_POLYGON) {
|
||||
int i = c->vertex_cnt;
|
||||
while (i >= 3) {
|
||||
i--;
|
||||
gl_draw_triangle(c, &c->vertex[i], &c->vertex[0], &c->vertex[i - 1]);
|
||||
}
|
||||
}
|
||||
c->in_begin = 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@
|
|||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
#include "tinygl.h"
|
||||
#include "zbuffer.h"
|
||||
#include "zmath.h"
|
||||
#include "zfeatures.h"
|
||||
|
|
@ -13,14 +12,6 @@
|
|||
#define DEBUG
|
||||
/* #define NDEBUG */
|
||||
|
||||
enum {
|
||||
|
||||
#define ADD_OP(a,b,c) OP_ ## a ,
|
||||
|
||||
#include "opinfo.h"
|
||||
|
||||
};
|
||||
|
||||
/* initially # of allocated GLVertexes (will grow when necessary) */
|
||||
#define POLYGON_MAX_VERTEX 16
|
||||
|
||||
|
|
@ -162,29 +153,14 @@ typedef struct GLContext {
|
|||
|
||||
/* materials */
|
||||
GLMaterial materials[2];
|
||||
int color_material_enabled;
|
||||
int current_color_material_mode;
|
||||
int current_color_material_type;
|
||||
|
||||
/* textures */
|
||||
GLTexture *current_texture;
|
||||
int texture_2d_enabled;
|
||||
|
||||
/* shared state */
|
||||
GLSharedState shared_state;
|
||||
|
||||
/* current list */
|
||||
GLParamBuffer *current_op_buffer;
|
||||
int current_op_buffer_index;
|
||||
int exec_flag,compile_flag,print_flag;
|
||||
|
||||
/* matrix */
|
||||
|
||||
int matrix_mode;
|
||||
M4 *matrix_stack[3];
|
||||
M4 *matrix_stack_ptr[3];
|
||||
int matrix_stack_depth_max[3];
|
||||
|
||||
M4 matrix_projection;
|
||||
M4 matrix_model_view;
|
||||
M4 matrix_model_view_inv;
|
||||
M4 matrix_model_projection;
|
||||
int matrix_model_projection_updated;
|
||||
|
|
@ -195,29 +171,14 @@ typedef struct GLContext {
|
|||
GLViewport viewport;
|
||||
|
||||
/* current state */
|
||||
int polygon_mode_back;
|
||||
int polygon_mode_front;
|
||||
|
||||
int current_front_face;
|
||||
int current_shade_model;
|
||||
int current_cull_face;
|
||||
int smooth_shade_model;
|
||||
int cull_face_enabled;
|
||||
int cull_clockwise;
|
||||
int normalize_enabled;
|
||||
gl_draw_triangle_func draw_triangle_front,draw_triangle_back;
|
||||
ZB_fillTriangleFunc zb_fill_tri;
|
||||
|
||||
/* selection */
|
||||
int render_mode;
|
||||
unsigned int *select_buffer;
|
||||
int select_size;
|
||||
unsigned int *select_ptr,*select_hit;
|
||||
int select_overflow;
|
||||
int select_hits;
|
||||
|
||||
/* names */
|
||||
unsigned int name_stack[MAX_NAME_STACK_DEPTH];
|
||||
int name_stack_size;
|
||||
|
||||
/* clear */
|
||||
float clear_depth;
|
||||
V4 clear_color;
|
||||
|
|
@ -228,51 +189,25 @@ typedef struct GLContext {
|
|||
V4 current_normal;
|
||||
V4 current_tex_coord;
|
||||
int current_edge_flag;
|
||||
|
||||
/* glBegin / glEnd */
|
||||
int in_begin;
|
||||
int begin_type;
|
||||
int vertex_n,vertex_cnt;
|
||||
int vertex_max;
|
||||
GLVertex *vertex;
|
||||
|
||||
/* opengl 1.1 arrays */
|
||||
float *vertex_array;
|
||||
int vertex_array_size;
|
||||
int vertex_array_stride;
|
||||
float *normal_array;
|
||||
int normal_array_stride;
|
||||
float *color_array;
|
||||
int color_array_size;
|
||||
int color_array_stride;
|
||||
float *texcoord_array;
|
||||
int texcoord_array_size;
|
||||
int texcoord_array_stride;
|
||||
int client_states;
|
||||
|
||||
/* opengl 1.1 polygon offset */
|
||||
float offset_factor;
|
||||
float offset_units;
|
||||
int offset_states;
|
||||
|
||||
/* depth test */
|
||||
int depth_test;
|
||||
|
||||
/* specular buffer. could probably be shared between contexts,
|
||||
but that wouldn't be 100% thread safe */
|
||||
GLSpecBuf *specbuf_first;
|
||||
int specbuf_used_counter;
|
||||
int specbuf_num_buffers;
|
||||
|
||||
/* opaque structure for user's use */
|
||||
void *opaque;
|
||||
/* resize viewport function */
|
||||
int (*gl_resize_viewport)(struct GLContext *c,int *xsize,int *ysize);
|
||||
|
||||
/* depth test */
|
||||
int depth_test;
|
||||
} GLContext;
|
||||
|
||||
extern GLContext *gl_ctx;
|
||||
|
||||
void gl_add_op(GLParam *p);
|
||||
/* init.c */
|
||||
void glInit(GLContext *c, ZBuffer *zbuffer);
|
||||
void glClose(GLContext *c);
|
||||
|
||||
/* clip.c */
|
||||
void gl_transform_to_viewport(GLContext *c,GLVertex *v);
|
||||
|
|
@ -286,22 +221,14 @@ void gl_draw_triangle_line(GLContext *c,
|
|||
GLVertex *p0,GLVertex *p1,GLVertex *p2);
|
||||
void gl_draw_triangle_fill(GLContext *c,
|
||||
GLVertex *p0,GLVertex *p1,GLVertex *p2);
|
||||
void gl_draw_triangle_select(GLContext *c,
|
||||
GLVertex *p0,GLVertex *p1,GLVertex *p2);
|
||||
|
||||
/* matrix.c */
|
||||
void gl_print_matrix(const float *m);
|
||||
/*
|
||||
void glopLoadIdentity(GLContext *c,GLParam *p);
|
||||
void glopTranslate(GLContext *c,GLParam *p);*/
|
||||
|
||||
/* light.c */
|
||||
void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax);
|
||||
void gl_enable_disable_light(GLContext *c,int light,int v);
|
||||
void gl_shade_vertex(GLContext *c,GLVertex *v);
|
||||
|
||||
/* vertex.c */
|
||||
void gl_eval_viewport(GLContext *c);
|
||||
void gl_vertex_transform(GLContext * c, GLVertex * v);
|
||||
|
||||
/* image_util.c */
|
||||
void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb,
|
||||
|
|
@ -339,11 +266,6 @@ void dprintf(const char *, ...);
|
|||
#endif
|
||||
#endif /* !BEOS */
|
||||
|
||||
/* glopXXX functions */
|
||||
|
||||
#define ADD_OP(a,b,c) void glop ## a (GLContext *,GLParam *);
|
||||
#include "opinfo.h"
|
||||
|
||||
/* this clip epsilon is needed to avoid some rounding errors after
|
||||
several clipping stages */
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue