[Scummvm-cvs-logs] SF.net SVN: scummvm: [22489] residual/trunk/tinygl
aquadran at users.sourceforge.net
aquadran at users.sourceforge.net
Tue May 16 07:53:23 CEST 2006
Revision: 22489
Author: aquadran
Date: 2006-05-16 07:52:36 -0700 (Tue, 16 May 2006)
ViewCVS: http://svn.sourceforge.net/scummvm/?rev=22489&view=rev
Log Message:
-----------
formating
Modified Paths:
--------------
residual/trunk/tinygl/api.cpp
residual/trunk/tinygl/arrays.cpp
residual/trunk/tinygl/clear.cpp
residual/trunk/tinygl/clip.cpp
residual/trunk/tinygl/error.cpp
residual/trunk/tinygl/get.cpp
residual/trunk/tinygl/gl.h
residual/trunk/tinygl/image_util.cpp
residual/trunk/tinygl/init.cpp
residual/trunk/tinygl/light.cpp
residual/trunk/tinygl/list.cpp
residual/trunk/tinygl/matrix.cpp
residual/trunk/tinygl/memory.cpp
residual/trunk/tinygl/misc.cpp
residual/trunk/tinygl/msghandling.cpp
residual/trunk/tinygl/msghandling.h
residual/trunk/tinygl/opinfo.h
residual/trunk/tinygl/select.cpp
residual/trunk/tinygl/specbuf.cpp
residual/trunk/tinygl/specbuf.h
residual/trunk/tinygl/texture.cpp
residual/trunk/tinygl/vertex.cpp
residual/trunk/tinygl/zgl.h
residual/trunk/tinygl/zline.cpp
residual/trunk/tinygl/zline.h
residual/trunk/tinygl/zmath.cpp
residual/trunk/tinygl/zmath.h
residual/trunk/tinygl/ztriangle.cpp
residual/trunk/tinygl/ztriangle.h
Modified: residual/trunk/tinygl/api.cpp
===================================================================
--- residual/trunk/tinygl/api.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/api.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,666 +1,605 @@
+
#include "tinygl/zgl.h"
#include <stdio.h>
-/* glVertex */
-void tglVertex4f(float x,float y,float z,float w)
-{
- TGLParam p[5];
+// glVertex
- p[0].op=OP_Vertex;
- p[1].f=x;
- p[2].f=y;
- p[3].f=z;
- p[4].f=w;
+void tglVertex4f(float x, float y, float z, float w) {
+ TGLParam p[5];
- gl_add_op(p);
+ 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 tglVertex2f(float x,float y)
-{
- tglVertex4f(x,y,0,1);
+void tglVertex2f(float x, float y) {
+ tglVertex4f(x, y, 0, 1);
}
-void tglVertex3f(float x,float y,float z)
-{
- tglVertex4f(x,y,z,1);
+void tglVertex3f(float x, float y, float z) {
+ tglVertex4f(x, y, z, 1);
}
-void tglVertex3fv(float *v)
-{
- tglVertex4f(v[0],v[1],v[2],1);
+void tglVertex3fv(float *v) {
+ tglVertex4f(v[0], v[1], v[2], 1);
}
-/* glNormal */
+// glNormal
-void tglNormal3f(float x,float y,float z)
-{
- TGLParam p[4];
+void tglNormal3f(float x, float y, float z) {
+ TGLParam p[4];
- p[0].op=OP_Normal;
- p[1].f=x;
- p[2].f=y;
- p[3].f=z;
+ p[0].op = OP_Normal;
+ p[1].f = x;
+ p[2].f = y;
+ p[3].f = z;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglNormal3fv(float *v)
-{
- tglNormal3f(v[0],v[1],v[2]);
+void tglNormal3fv(float *v) {
+ tglNormal3f(v[0], v[1], v[2]);
}
-/* glColor */
+// glColor
-void tglColor4f(float r,float g,float b,float a)
-{
- TGLParam p[8];
+void tglColor4f(float r, float g, float b, float a) {
+ TGLParam 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);
+ 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 tglColor4fv(float *v)
-{
- TGLParam p[8];
+void tglColor4fv(float *v) {
+ TGLParam 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);
+ 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 tglColor3f(float x,float y,float z)
-{
- tglColor4f(x,y,z,1);
+void tglColor3f(float x, float y, float z) {
+ tglColor4f(x, y, z, 1);
}
-void glColor3fv(float *v)
-{
- tglColor4f(v[0],v[1],v[2],1);
+void glColor3fv(float *v) {
+ tglColor4f(v[0], v[1], v[2], 1);
}
+// TexCoord
-/* TexCoord */
+void tglTexCoord4f(float s, float t, float r, float q) {
+ TGLParam p[5];
-void tglTexCoord4f(float s,float t,float r,float q)
-{
- TGLParam p[5];
+ p[0].op = OP_TexCoord;
+ p[1].f = s;
+ p[2].f = t;
+ p[3].f = r;
+ p[4].f = q;
- 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);
+ gl_add_op(p);
}
-void tglTexCoord2f(float s,float t)
-{
- tglTexCoord4f(s,t,0,1);
+void tglTexCoord2f(float s, float t) {
+ tglTexCoord4f(s, t, 0, 1);
}
-void tglTexCoord2fv(float *v)
-{
- tglTexCoord4f(v[0],v[1],0,1);
+void tglTexCoord2fv(float *v) {
+ tglTexCoord4f(v[0], v[1], 0, 1);
}
-void tglEdgeFlag(int flag)
-{
- TGLParam p[2];
+void tglEdgeFlag(int flag) {
+ TGLParam p[2];
- p[0].op=OP_EdgeFlag;
- p[1].i=flag;
+ p[0].op = OP_EdgeFlag;
+ p[1].i = flag;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* misc */
+// misc
-void tglShadeModel(int mode)
-{
- TGLParam p[2];
+void tglShadeModel(int mode) {
+ TGLParam p[2];
- assert(mode == TGL_FLAT || mode == TGL_SMOOTH);
+ assert(mode == TGL_FLAT || mode == TGL_SMOOTH);
- p[0].op=OP_ShadeModel;
- p[1].i=mode;
+ p[0].op = OP_ShadeModel;
+ p[1].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglCullFace(int mode)
-{
- TGLParam p[2];
+void tglCullFace(int mode) {
+ TGLParam p[2];
- assert(mode == TGL_BACK ||
- mode == TGL_FRONT ||
- mode == TGL_FRONT_AND_BACK);
+ assert(mode == TGL_BACK || mode == TGL_FRONT || mode == TGL_FRONT_AND_BACK);
- p[0].op=OP_CullFace;
- p[1].i=mode;
+ p[0].op = OP_CullFace;
+ p[1].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglFrontFace(int mode)
-{
- TGLParam p[2];
+void tglFrontFace(int mode) {
+ TGLParam p[2];
- assert(mode == TGL_CCW || mode == TGL_CW);
+ assert(mode == TGL_CCW || mode == TGL_CW);
- mode = (mode != TGL_CCW);
+ mode = (mode != TGL_CCW);
- p[0].op=OP_FrontFace;
- p[1].i=mode;
+ p[0].op = OP_FrontFace;
+ p[1].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPolygonMode(int face,int mode)
-{
- TGLParam p[3];
+void tglPolygonMode(int face, int mode) {
+ TGLParam p[3];
- assert(face == TGL_BACK ||
- face == TGL_FRONT ||
- face == TGL_FRONT_AND_BACK);
- assert(mode == TGL_POINT || mode == TGL_LINE || mode==TGL_FILL);
+ assert(face == TGL_BACK || face == TGL_FRONT || face == TGL_FRONT_AND_BACK);
+ assert(mode == TGL_POINT || mode == TGL_LINE || mode == TGL_FILL);
- p[0].op=OP_PolygonMode;
- p[1].i=face;
- p[2].i=mode;
+ p[0].op = OP_PolygonMode;
+ p[1].i = face;
+ p[2].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* glEnable / glDisable */
+// glEnable, glDisable
-void tglEnable(int cap)
-{
- TGLParam p[3];
+void tglEnable(int cap) {
+ TGLParam p[3];
- p[0].op=OP_EnableDisable;
- p[1].i=cap;
- p[2].i=1;
+ p[0].op = OP_EnableDisable;
+ p[1].i = cap;
+ p[2].i = 1;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglDisable(int cap)
-{
- TGLParam p[3];
+void tglDisable(int cap) {
+ TGLParam p[3];
- p[0].op=OP_EnableDisable;
- p[1].i=cap;
- p[2].i=0;
+ p[0].op = OP_EnableDisable;
+ p[1].i = cap;
+ p[2].i = 0;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* glBegin / glEnd */
+// glBegin, glEnd
-void tglBegin(int mode)
-{
- TGLParam p[2];
+void tglBegin(int mode) {
+ TGLParam p[2];
- p[0].op=OP_Begin;
- p[1].i=mode;
+ p[0].op = OP_Begin;
+ p[1].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglEnd(void)
-{
- TGLParam p[1];
+void tglEnd() {
+ TGLParam p[1];
- p[0].op=OP_End;
+ p[0].op = OP_End;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* matrix */
+// matrix
-void tglMatrixMode(int mode)
-{
- TGLParam p[2];
+void tglMatrixMode(int mode) {
+ TGLParam p[2];
- p[0].op=OP_MatrixMode;
- p[1].i=mode;
+ p[0].op = OP_MatrixMode;
+ p[1].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglLoadMatrixf(const float *m)
-{
- TGLParam p[17];
- int i;
+void tglLoadMatrixf(const float *m) {
+ TGLParam p[17];
+ int i;
- p[0].op=OP_LoadMatrix;
- for(i=0;i<16;i++) p[i+1].f=m[i];
+ p[0].op = OP_LoadMatrix;
+ for (i = 0; i < 16; i++)
+ p[i + 1].f = m[i];
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglLoadIdentity(void)
-{
- TGLParam p[1];
+void tglLoadIdentity() {
+ TGLParam p[1];
- p[0].op=OP_LoadIdentity;
+ p[0].op = OP_LoadIdentity;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglMultMatrixf(const float *m)
-{
- TGLParam p[17];
- int i;
+void tglMultMatrixf(const float *m) {
+ TGLParam p[17];
+ int i;
- p[0].op=OP_MultMatrix;
- for(i=0;i<16;i++) p[i+1].f=m[i];
+ p[0].op = OP_MultMatrix;
+ for (i = 0; i < 16; i++)
+ p[i + 1].f = m[i];
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPushMatrix(void)
-{
- TGLParam p[1];
+void tglPushMatrix() {
+ TGLParam p[1];
- p[0].op=OP_PushMatrix;
+ p[0].op = OP_PushMatrix;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPopMatrix(void)
-{
- TGLParam p[1];
+void tglPopMatrix() {
+ TGLParam p[1];
- p[0].op=OP_PopMatrix;
+ p[0].op = OP_PopMatrix;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglRotatef(float angle,float x,float y,float z)
-{
- TGLParam p[5];
+void tglRotatef(float angle, float x, float y, float z) {
+ TGLParam p[5];
- p[0].op=OP_Rotate;
- p[1].f=angle;
- p[2].f=x;
- p[3].f=y;
- p[4].f=z;
+ 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);
+ gl_add_op(p);
}
-void tglTranslatef(float x,float y,float z)
-{
- TGLParam p[4];
+void tglTranslatef(float x, float y, float z) {
+ TGLParam p[4];
- p[0].op=OP_Translate;
- p[1].f=x;
- p[2].f=y;
- p[3].f=z;
+ p[0].op = OP_Translate;
+ p[1].f = x;
+ p[2].f = y;
+ p[3].f = z;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglScalef(float x,float y,float z)
-{
- TGLParam p[4];
+void tglScalef(float x, float y, float z) {
+ TGLParam p[4];
- p[0].op=OP_Scale;
- p[1].f=x;
- p[2].f=y;
- p[3].f=z;
+ p[0].op = OP_Scale;
+ p[1].f = x;
+ p[2].f = y;
+ p[3].f = z;
- gl_add_op(p);
+ gl_add_op(p);
}
+void tglViewport(int x, int y, int width, int height) {
+ TGLParam p[5];
-void tglViewport(int x,int y,int width,int height)
-{
- TGLParam p[5];
+ p[0].op = OP_Viewport;
+ p[1].i = x;
+ p[2].i = y;
+ p[3].i = width;
+ p[4].i = height;
- 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);
+ gl_add_op(p);
}
-void tglFrustum(double left,double right,double bottom,double top,
- double nearv,double farv)
-{
- TGLParam p[7];
+void tglFrustum(double left, double right, double bottom, double top,
+ double nearv, double farv) {
+ TGLParam p[7];
- p[0].op=OP_Frustum;
- p[1].f=(float)left;
- p[2].f=(float)right;
- p[3].f=(float)bottom;
- p[4].f=(float)top;
- p[5].f=(float)nearv;
- p[6].f=(float)farv;
+ p[0].op = OP_Frustum;
+ p[1].f = (float)left;
+ p[2].f = (float)right;
+ p[3].f = (float)bottom;
+ p[4].f = (float)top;
+ p[5].f = (float)nearv;
+ p[6].f = (float)farv;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* lightening */
+// lightening
-void tglMaterialfv(int mode,int type,float *v)
-{
- TGLParam p[7];
- int i,n;
+void tglMaterialfv(int mode, int type, float *v) {
+ TGLParam p[7];
+ int i, n;
- assert(mode == TGL_FRONT || mode == TGL_BACK || mode==TGL_FRONT_AND_BACK);
+ assert(mode == TGL_FRONT || mode == TGL_BACK || mode==TGL_FRONT_AND_BACK);
- p[0].op=OP_Material;
- p[1].i=mode;
- p[2].i=type;
- n=4;
- if (type == TGL_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;
+ p[0].op = OP_Material;
+ p[1].i = mode;
+ p[2].i = type;
+ n = 4;
+ if (type == TGL_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);
+ gl_add_op(p);
}
-void tglMaterialf(int mode,int type,float v)
-{
- TGLParam p[7];
- int i;
+void tglMaterialf(int mode, int type, float v) {
+ TGLParam 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;
+ 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);
+ gl_add_op(p);
}
-void tglColorMaterial(int mode,int type)
-{
- TGLParam p[3];
+void tglColorMaterial(int mode, int type) {
+ TGLParam p[3];
- p[0].op=OP_ColorMaterial;
- p[1].i=mode;
- p[2].i=type;
+ p[0].op = OP_ColorMaterial;
+ p[1].i = mode;
+ p[2].i = type;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglLightfv(int light,int type,float *v)
-{
- TGLParam p[7];
- int i;
+void tglLightfv(int light, int type, float *v) {
+ TGLParam 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];
+ 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);
+ gl_add_op(p);
}
-void tglLightf(int light,int type,float v)
-{
- TGLParam p[7];
- int i;
+void tglLightf(int light, int type, float v) {
+ TGLParam 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;
+ 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);
+ gl_add_op(p);
}
-void tglLightModeli(int pname,int param)
-{
- TGLParam p[6];
- int i;
+void tglLightModeli(int pname, int param) {
+ TGLParam 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;
+ 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);
+ gl_add_op(p);
}
-void tglLightModelfv(int pname,float *param)
-{
- TGLParam p[6];
- int i;
+void tglLightModelfv(int pname, float *param) {
+ TGLParam 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];
+ 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);
+ gl_add_op(p);
}
-/* clear */
+// clear
-void tglClear(int mask)
-{
- TGLParam p[2];
+void tglClear(int mask) {
+ TGLParam p[2];
- p[0].op=OP_Clear;
- p[1].i=mask;
+ p[0].op = OP_Clear;
+ p[1].i = mask;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglClearColor(float r,float g,float b,float a)
-{
- TGLParam p[5];
+void tglClearColor(float r, float g, float b, float a) {
+ TGLParam p[5];
- p[0].op=OP_ClearColor;
- p[1].f=r;
- p[2].f=g;
- p[3].f=b;
- p[4].f=a;
+ 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);
+ gl_add_op(p);
}
-void tglClearDepth(double depth)
-{
- TGLParam p[2];
+void tglClearDepth(double depth) {
+ TGLParam p[2];
- p[0].op=OP_ClearDepth;
- p[1].f=(float)depth;
+ p[0].op = OP_ClearDepth;
+ p[1].f = (float)depth;
- gl_add_op(p);
+ gl_add_op(p);
}
+// textures
-/* textures */
-
void tglTexImage2D( int target, int level, int components,
int width, int height, int border,
- int format, int type, void *pixels)
-{
- TGLParam p[10];
+ int format, int type, void *pixels) {
+ TGLParam p[10];
- p[0].op=OP_TexImage2D;
- p[1].i=target;
- p[2].i=level;
- p[3].i=components;
- p[4].i=width;
- p[5].i=height;
- p[6].i=border;
- p[7].i=format;
- p[8].i=type;
- p[9].p=pixels;
+ p[0].op = OP_TexImage2D;
+ p[1].i = target;
+ p[2].i = level;
+ p[3].i = components;
+ p[4].i = width;
+ p[5].i = height;
+ p[6].i = border;
+ p[7].i = format;
+ p[8].i = type;
+ p[9].p = pixels;
- gl_add_op(p);
+ gl_add_op(p);
}
+void tglBindTexture(int target, int texture) {
+ TGLParam p[3];
-void tglBindTexture(int target,int texture)
-{
- TGLParam p[3];
+ p[0].op = OP_BindTexture;
+ p[1].i = target;
+ p[2].i = texture;
- p[0].op=OP_BindTexture;
- p[1].i=target;
- p[2].i=texture;
-
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglTexEnvi(int target,int pname,int param)
-{
- TGLParam p[8];
+void tglTexEnvi(int target, int pname, int param) {
+ TGLParam p[8];
- p[0].op=OP_TexEnv;
- p[1].i=target;
- p[2].i=pname;
- p[3].i=param;
- p[4].f=0;
- p[5].f=0;
- p[6].f=0;
- p[7].f=0;
+ p[0].op = OP_TexEnv;
+ p[1].i = target;
+ p[2].i = pname;
+ p[3].i = param;
+ p[4].f = 0;
+ p[5].f = 0;
+ p[6].f = 0;
+ p[7].f = 0;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglTexParameteri(int target,int pname,int param)
-{
- TGLParam p[8];
+void tglTexParameteri(int target, int pname, int param) {
+ TGLParam p[8];
- p[0].op=OP_TexParameter;
- p[1].i=target;
- p[2].i=pname;
- p[3].i=param;
- p[4].f=0;
- p[5].f=0;
- p[6].f=0;
- p[7].f=0;
+ p[0].op = OP_TexParameter;
+ p[1].i = target;
+ p[2].i = pname;
+ p[3].i = param;
+ p[4].f = 0;
+ p[5].f = 0;
+ p[6].f = 0;
+ p[7].f = 0;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPixelStorei(int pname,int param)
-{
- TGLParam p[3];
+void tglPixelStorei(int pname, int param) {
+ TGLParam p[3];
- p[0].op=OP_PixelStore;
- p[1].i=pname;
- p[2].i=param;
+ p[0].op = OP_PixelStore;
+ p[1].i = pname;
+ p[2].i = param;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* selection */
+// selection
-void tglInitNames(void)
-{
- TGLParam p[1];
+void tglInitNames() {
+ TGLParam p[1];
- p[0].op=OP_InitNames;
+ p[0].op = OP_InitNames;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPushName(unsigned int name)
-{
- TGLParam p[2];
+void tglPushName(unsigned int name) {
+ TGLParam p[2];
- p[0].op=OP_PushName;
- p[1].i=name;
+ p[0].op = OP_PushName;
+ p[1].i = name;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglPopName(void)
-{
- TGLParam p[1];
+void tglPopName() {
+ TGLParam p[1];
- p[0].op=OP_PopName;
+ p[0].op = OP_PopName;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglLoadName(unsigned int name)
-{
- TGLParam p[2];
+void tglLoadName(unsigned int name) {
+ TGLParam p[2];
- p[0].op=OP_LoadName;
- p[1].i=name;
+ p[0].op = OP_LoadName;
+ p[1].i = name;
- gl_add_op(p);
+ gl_add_op(p);
}
-void
-tglPolygonOffset(TGLfloat factor, TGLfloat units)
-{
+void tglPolygonOffset(TGLfloat factor, TGLfloat units) {
TGLParam p[3];
p[0].op = OP_PolygonOffset;
p[1].f = factor;
p[2].f = units;
}
-/* Special Functions */
+// Special Functions
-void tglCallList(unsigned int list)
-{
- TGLParam p[2];
+void tglCallList(unsigned int list) {
+ TGLParam p[2];
- p[0].op=OP_CallList;
- p[1].i=list;
+ p[0].op = OP_CallList;
+ p[1].i = list;
- gl_add_op(p);
+ gl_add_op(p);
}
-void tglFlush(void)
-{
- /* nothing to do */
+void tglFlush() {
+ // nothing to do
}
-void tglHint(int target,int mode)
-{
- TGLParam p[3];
+void tglHint(int target, int mode) {
+ TGLParam p[3];
- p[0].op=OP_Hint;
- p[1].i=target;
- p[2].i=mode;
+ p[0].op = OP_Hint;
+ p[1].i = target;
+ p[2].i = mode;
- gl_add_op(p);
+ gl_add_op(p);
}
-/* Non standard functions */
+// Non standard functions
-void tglDebug(int mode)
-{
- GLContext *c=gl_get_context();
- c->print_flag=mode;
+void tglDebug(int mode) {
+ GLContext *c = gl_get_context();
+ c->print_flag = mode;
}
-
Modified: residual/trunk/tinygl/arrays.cpp
===================================================================
--- residual/trunk/tinygl/arrays.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/arrays.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,3 +1,4 @@
+
#include "tinygl/zgl.h"
#include <assert.h>
#include <stdio.h>
@@ -2,203 +3,173 @@
-#define VERTEX_ARRAY 0x0001
-#define COLOR_ARRAY 0x0002
-#define NORMAL_ARRAY 0x0004
-#define TEXCOORD_ARRAY 0x0008
+#define VERTEX_ARRAY 0x0001
+#define COLOR_ARRAY 0x0002
+#define NORMAL_ARRAY 0x0004
+#define TEXCOORD_ARRAY 0x0008
-void
-glopArrayElement(GLContext *c, TGLParam *param)
-{
- int i;
- int states = c->client_states;
- int idx = param[1].i;
-
- if (states & COLOR_ARRAY) {
- TGLParam 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) {
- TGLParam 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 glopArrayElement(GLContext *c, TGLParam *param) {
+ int i;
+ int states = c->client_states;
+ int idx = param[1].i;
+
+ if (states & COLOR_ARRAY) {
+ TGLParam 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) {
+ TGLParam 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(TGLint i)
-{
- TGLParam p[2];
- p[0].op = OP_ArrayElement;
- p[1].i = i;
- gl_add_op(p);
+void glArrayElement(TGLint i) {
+ TGLParam p[2];
+ p[0].op = OP_ArrayElement;
+ p[1].i = i;
+ gl_add_op(p);
}
-
-void
-glopEnableClientState(GLContext *c, TGLParam *p)
-{
- c->client_states |= p[1].i;
+void glopEnableClientState(GLContext *c, TGLParam *p) {
+ c->client_states |= p[1].i;
}
-void
-glEnableClientState(TGLenum array)
-{
- TGLParam p[2];
- p[0].op = OP_EnableClientState;
-
- switch(array) {
- case TGL_VERTEX_ARRAY:
- p[1].i = VERTEX_ARRAY;
- break;
- case TGL_NORMAL_ARRAY:
- p[1].i = NORMAL_ARRAY;
- break;
- case TGL_COLOR_ARRAY:
- p[1].i = COLOR_ARRAY;
- break;
- case TGL_TEXTURE_COORD_ARRAY:
- p[1].i = TEXCOORD_ARRAY;
- break;
- default:
- assert(0);
- break;
- }
- gl_add_op(p);
+void glEnableClientState(TGLenum array) {
+ TGLParam p[2];
+ p[0].op = OP_EnableClientState;
+
+ switch(array) {
+ case TGL_VERTEX_ARRAY:
+ p[1].i = VERTEX_ARRAY;
+ break;
+ case TGL_NORMAL_ARRAY:
+ p[1].i = NORMAL_ARRAY;
+ break;
+ case TGL_COLOR_ARRAY:
+ p[1].i = COLOR_ARRAY;
+ break;
+ case TGL_TEXTURE_COORD_ARRAY:
+ p[1].i = TEXCOORD_ARRAY;
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ gl_add_op(p);
}
-void
-glopDisableClientState(GLContext *c, TGLParam *p)
-{
- c->client_states &= p[1].i;
+void glopDisableClientState(GLContext *c, TGLParam *p) {
+ c->client_states &= p[1].i;
}
-void
-glDisableClientState(TGLenum array)
-{
- TGLParam p[2];
- p[0].op = OP_DisableClientState;
+void glDisableClientState(TGLenum array) {
+ TGLParam p[2];
+ p[0].op = OP_DisableClientState;
- switch(array) {
- case TGL_VERTEX_ARRAY:
- p[1].i = ~VERTEX_ARRAY;
- break;
- case TGL_NORMAL_ARRAY:
- p[1].i = ~NORMAL_ARRAY;
- break;
- case TGL_COLOR_ARRAY:
- p[1].i = ~COLOR_ARRAY;
- break;
- case TGL_TEXTURE_COORD_ARRAY:
- p[1].i = ~TEXCOORD_ARRAY;
- break;
- default:
- assert(0);
- break;
- }
- gl_add_op(p);
+ switch(array) {
+ case TGL_VERTEX_ARRAY:
+ p[1].i = ~VERTEX_ARRAY;
+ break;
+ case TGL_NORMAL_ARRAY:
+ p[1].i = ~NORMAL_ARRAY;
+ break;
+ case TGL_COLOR_ARRAY:
+ p[1].i = ~COLOR_ARRAY;
+ break;
+ case TGL_TEXTURE_COORD_ARRAY:
+ p[1].i = ~TEXCOORD_ARRAY;
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ gl_add_op(p);
}
-void
-glopVertexPointer(GLContext *c, TGLParam *p)
-{
- c->vertex_array_size = p[1].i;
- c->vertex_array_stride = p[2].i;
- c->vertex_array = (float *)p[3].p;
+void glopVertexPointer(GLContext *c, TGLParam *p) {
+ c->vertex_array_size = p[1].i;
+ c->vertex_array_stride = p[2].i;
+ c->vertex_array = (float *)p[3].p;
}
-void
-glVertexPointer(TGLint size, TGLenum type, TGLsizei stride,
- const TGLvoid *pointer)
-{
- TGLParam p[4];
- assert(type == TGL_FLOAT);
- p[0].op = OP_VertexPointer;
- p[1].i = size;
- p[2].i = stride;
- p[3].p = (void*)pointer;
- gl_add_op(p);
+void glVertexPointer(TGLint size, TGLenum type, TGLsizei stride,
+ const TGLvoid *pointer) {
+ TGLParam p[4];
+ assert(type == TGL_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, TGLParam *p)
-{
- c->color_array_size = p[1].i;
- c->color_array_stride = p[2].i;
- c->color_array = (float *)p[3].p;
+void glopColorPointer(GLContext *c, TGLParam *p) {
+ c->color_array_size = p[1].i;
+ c->color_array_stride = p[2].i;
+ c->color_array = (float *)p[3].p;
}
-void
-glColorPointer(TGLint size, TGLenum type, TGLsizei stride,
- const TGLvoid *pointer)
-{
- TGLParam p[4];
- assert(type == TGL_FLOAT);
- p[0].op = OP_ColorPointer;
- p[1].i = size;
- p[2].i = stride;
- p[3].p = (void*)pointer;
- gl_add_op(p);
+void glColorPointer(TGLint size, TGLenum type, TGLsizei stride,
+ const TGLvoid *pointer) {
+ TGLParam p[4];
+ assert(type == TGL_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, TGLParam *p)
-{
- c->normal_array_stride = p[1].i;
- c->normal_array = (float *)p[2].p;
+void glopNormalPointer(GLContext *c, TGLParam *p) {
+ c->normal_array_stride = p[1].i;
+ c->normal_array = (float *)p[2].p;
}
-void
-glNormalPointer(TGLenum type, TGLsizei stride,
- const TGLvoid *pointer)
-{
- TGLParam p[3];
- assert(type == TGL_FLOAT);
- p[0].op = OP_NormalPointer;
- p[1].i = stride;
- p[2].p = (void*)pointer;
+void glNormalPointer(TGLenum type, TGLsizei stride, const TGLvoid *pointer) {
+ TGLParam p[3];
+ assert(type == TGL_FLOAT);
+ p[0].op = OP_NormalPointer;
+ p[1].i = stride;
+ p[2].p = (void *)pointer;
}
-void
-glopTexCoordPointer(GLContext *c, TGLParam *p)
-{
- c->texcoord_array_size = p[1].i;
- c->texcoord_array_stride = p[2].i;
- c->texcoord_array = (float *)p[3].p;
+void glopTexCoordPointer(GLContext *c, TGLParam *p) {
+ c->texcoord_array_size = p[1].i;
+ c->texcoord_array_stride = p[2].i;
+ c->texcoord_array = (float *)p[3].p;
}
-void
-glTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride,
- const TGLvoid *pointer)
-{
- TGLParam p[4];
- assert(type == TGL_FLOAT);
- p[0].op = OP_TexCoordPointer;
- p[1].i = size;
- p[2].i = stride;
- p[3].p = (void*)pointer;
+void glTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride,
+ const TGLvoid *pointer) {
+ TGLParam p[4];
+ assert(type == TGL_FLOAT);
+ p[0].op = OP_TexCoordPointer;
+ p[1].i = size;
+ p[2].i = stride;
+ p[3].p = (void *)pointer;
}
Modified: residual/trunk/tinygl/clear.cpp
===================================================================
--- residual/trunk/tinygl/clear.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/clear.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,30 +1,25 @@
+
#include "tinygl/zgl.h"
+void glopClearColor(GLContext *c, TGLParam *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 glopClearColor(GLContext *c,TGLParam *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, TGLParam *p) {
+ c->clear_depth = p[1].f;
}
-void glopClearDepth(GLContext *c,TGLParam *p)
-{
- c->clear_depth=p[1].f;
-}
+void glopClear(GLContext *c,TGLParam *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);
-void glopClear(GLContext *c,TGLParam *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 & TGL_DEPTH_BUFFER_BIT,z,
- mask & TGL_COLOR_BUFFER_BIT,r,g,b);
+ // TODO : correct value of Z
+ ZB_clear(c->zb,mask & TGL_DEPTH_BUFFER_BIT, z,
+ mask & TGL_COLOR_BUFFER_BIT, r, g, b);
}
-
Modified: residual/trunk/tinygl/clip.cpp
===================================================================
--- residual/trunk/tinygl/clip.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/clip.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,445 +1,432 @@
+
#include "tinygl/zgl.h"
-/* fill triangle profile */
-/* #define PROFILE */
+// fill triangle profile
+// #define PROFILE
-#define CLIP_XMIN (1<<0)
-#define CLIP_XMAX (1<<1)
-#define CLIP_YMIN (1<<2)
-#define CLIP_YMAX (1<<3)
-#define CLIP_ZMIN (1<<4)
-#define CLIP_ZMAX (1<<5)
+#define CLIP_XMIN (1 << 0)
+#define CLIP_XMAX (1 << 1)
+#define CLIP_YMIN (1 << 2)
+#define CLIP_YMAX (1 << 3)
+#define CLIP_ZMIN (1 << 4)
+#define CLIP_ZMAX (1 << 5)
-void gl_transform_to_viewport(GLContext *c,GLVertex *v)
-{
- float winv;
+void gl_transform_to_viewport(GLContext *c, GLVertex *v) {
+ float winv;
- /* coordinates */
- winv=(float)(1.0/v->pc.W);
- v->zp.x= (int) ( v->pc.X * winv * c->viewport.scale.X
- + c->viewport.trans.X );
- v->zp.y= (int) ( v->pc.Y * winv * c->viewport.scale.Y
- + c->viewport.trans.Y );
- v->zp.z= (int) ( v->pc.Z * winv * c->viewport.scale.Z
- + c->viewport.trans.Z );
- /* color */
- if (c->lighting_enabled) {
- v->zp.r=(int)(v->color.v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN)
- + ZB_POINT_RED_MIN);
- v->zp.g=(int)(v->color.v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN)
- + ZB_POINT_GREEN_MIN);
- v->zp.b=(int)(v->color.v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN)
- + ZB_POINT_BLUE_MIN);
- } else {
- /* no need to convert to integer if no lighting : take current color */
- v->zp.r = c->longcurrent_color[0];
- v->zp.g = c->longcurrent_color[1];
- v->zp.b = c->longcurrent_color[2];
- }
+ // coordinates
+ winv = (float)(1.0 / v->pc.W);
+ v->zp.x = (int)(v->pc.X * winv * c->viewport.scale.X + c->viewport.trans.X);
+ v->zp.y = (int)(v->pc.Y * winv * c->viewport.scale.Y + c->viewport.trans.Y);
+ v->zp.z = (int)(v->pc.Z * winv * c->viewport.scale.Z + c->viewport.trans.Z);
+ // color
+ if (c->lighting_enabled) {
+ v->zp.r = (int)(v->color.v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN)
+ + ZB_POINT_RED_MIN);
+ v->zp.g = (int)(v->color.v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN)
+ + ZB_POINT_GREEN_MIN);
+ v->zp.b = (int)(v->color.v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN)
+ + ZB_POINT_BLUE_MIN);
+ } else {
+ // no need to convert to integer if no lighting : take current color
+ v->zp.r = c->longcurrent_color[0];
+ v->zp.g = c->longcurrent_color[1];
+ v->zp.b = c->longcurrent_color[2];
+ }
- /* texture */
+ // texture
- if (c->texture_2d_enabled) {
- v->zp.s=(int)(v->tex_coord.X * (ZB_POINT_S_MAX - ZB_POINT_S_MIN)
+ if (c->texture_2d_enabled) {
+ v->zp.s = (int)(v->tex_coord.X * (ZB_POINT_S_MAX - ZB_POINT_S_MIN)
+ ZB_POINT_S_MIN);
- v->zp.t=(int)(v->tex_coord.Y * (ZB_POINT_T_MAX - ZB_POINT_T_MIN)
+ v->zp.t = (int)(v->tex_coord.Y * (ZB_POINT_T_MAX - ZB_POINT_T_MIN)
+ ZB_POINT_T_MIN);
- }
+ }
}
+static void gl_add_select1(GLContext *c, int z1, int z2, int z3) {
+ int min, max;
-static void gl_add_select1(GLContext *c,int z1,int z2,int z3)
-{
- 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;
+ 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);
+ gl_add_select(c, 0xffffffff - min, 0xffffffff - max);
}
-/* point */
+// point
-void gl_draw_point(GLContext *c,GLVertex *p0)
-{
- if (p0->clip_code == 0) {
- if (c->render_mode == TGL_SELECT) {
- gl_add_select(c,p0->zp.z,p0->zp.z);
- } else {
- ZB_plot(c->zb,&p0->zp);
- }
- }
+void gl_draw_point(GLContext *c, GLVertex *p0) {
+ if (p0->clip_code == 0) {
+ if (c->render_mode == TGL_SELECT) {
+ gl_add_select(c,p0->zp.z,p0->zp.z);
+ } else {
+ ZB_plot(c->zb,&p0->zp);
+ }
+ }
}
-/* line */
+// line
-static inline void interpolate(GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
-{
- q->pc.X=p0->pc.X+(p1->pc.X-p0->pc.X)*t;
- q->pc.Y=p0->pc.Y+(p1->pc.Y-p0->pc.Y)*t;
- q->pc.Z=p0->pc.Z+(p1->pc.Z-p0->pc.Z)*t;
- q->pc.W=p0->pc.W+(p1->pc.W-p0->pc.W)*t;
+static inline void interpolate(GLVertex *q, GLVertex *p0, GLVertex *p1, float t) {
+ q->pc.X = p0->pc.X + (p1->pc.X - p0->pc.X) * t;
+ q->pc.Y = p0->pc.Y + (p1->pc.Y - p0->pc.Y) * t;
+ q->pc.Z = p0->pc.Z + (p1->pc.Z - p0->pc.Z) * t;
+ q->pc.W = p0->pc.W + (p1->pc.W - p0->pc.W) * t;
- 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;
+ 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;
}
-/*
- * Line Clipping
- */
+// Line Clipping
-/* Line Clipping algorithm from 'Computer Graphics', Principles and
- Practice */
-static inline int ClipLine1(float denom,float num,float *tmin,float *tmax)
-{
- float t;
-
- if (denom>0) {
- t=num/denom;
- if (t>*tmax) return 0;
- if (t>*tmin) *tmin=t;
- } else if (denom<0) {
- t=num/denom;
- if (t<*tmin) return 0;
- if (t<*tmax) *tmax=t;
- } else if (num>0) return 0;
- return 1;
+// Line Clipping algorithm from 'Computer Graphics', Principles and
+// Practice
+static inline int ClipLine1(float denom,float num,float *tmin,float *tmax) {
+ float t;
+
+ if (denom > 0) {
+ t = num / denom;
+ if (t > *tmax)
+ return 0;
+ if (t > *tmin)
+ *tmin = t;
+ } else if (denom < 0) {
+ t = num / denom;
+ if (t < *tmin)
+ return 0;
+ if (t < *tmax)
+ *tmax = t;
+ } else if (num > 0)
+ return 0;
+
+ return 1;
}
-void gl_draw_line(GLContext *c,GLVertex *p1,GLVertex *p2)
-{
- float dx,dy,dz,dw,x1,y1,z1,w1;
- float tmin,tmax;
- GLVertex q1,q2;
- int cc1,cc2;
+void gl_draw_line(GLContext *c, GLVertex *p1, GLVertex *p2) {
+ float dx, dy, dz, dw, x1, y1, z1, w1;
+ float tmin, tmax;
+ GLVertex q1, q2;
+ int cc1, cc2;
- cc1=p1->clip_code;
- cc2=p2->clip_code;
+ cc1 = p1->clip_code;
+ cc2 = p2->clip_code;
- if ( (cc1 | cc2) == 0) {
- if (c->render_mode == TGL_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);
- }
- } else if ( (cc1&cc2) != 0 ) {
- return;
- } else {
- dx=p2->pc.X-p1->pc.X;
- dy=p2->pc.Y-p1->pc.Y;
- dz=p2->pc.Z-p1->pc.Z;
- dw=p2->pc.W-p1->pc.W;
- x1=p1->pc.X;
- y1=p1->pc.Y;
- z1=p1->pc.Z;
- w1=p1->pc.W;
-
- tmin=0;
- tmax=1;
- if (ClipLine1(dx+dw,-x1-w1,&tmin,&tmax) &&
- ClipLine1(-dx+dw,x1-w1,&tmin,&tmax) &&
- ClipLine1(dy+dw,-y1-w1,&tmin,&tmax) &&
- ClipLine1(-dy+dw,y1-w1,&tmin,&tmax) &&
- ClipLine1(dz+dw,-z1-w1,&tmin,&tmax) &&
- ClipLine1(-dz+dw,z1-w1,&tmin,&tmax)) {
+ if ((cc1 | cc2) == 0) {
+ if (c->render_mode == TGL_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);
+ }
+ } else if ( (cc1&cc2) != 0 ) {
+ return;
+ } else {
+ dx=p2->pc.X-p1->pc.X;
+ dy=p2->pc.Y-p1->pc.Y;
+ dz=p2->pc.Z-p1->pc.Z;
+ dw=p2->pc.W-p1->pc.W;
+ x1=p1->pc.X;
+ y1=p1->pc.Y;
+ z1=p1->pc.Z;
+ w1=p1->pc.W;
- interpolate(&q1,p1,p2,tmin);
- interpolate(&q2,p1,p2,tmax);
- gl_transform_to_viewport(c,&q1);
- gl_transform_to_viewport(c,&q2);
+ tmin=0;
+ tmax=1;
+ if (ClipLine1(dx + dw, -x1 - w1, &tmin, &tmax) &&
+ ClipLine1(-dx + dw, x1 - w1, &tmin, &tmax) &&
+ ClipLine1(dy + dw, -y1 - w1, &tmin, &tmax) &&
+ ClipLine1(-dy + dw, y1 - w1, &tmin, &tmax) &&
+ ClipLine1(dz + dw, -z1 - w1, &tmin, &tmax) &&
+ ClipLine1(-dz + dw, z1 - w1, &tmin, &tmax)) {
+ interpolate(&q1,p1,p2,tmin);
+ interpolate(&q2,p1,p2,tmax);
+ gl_transform_to_viewport(c,&q1);
+ gl_transform_to_viewport(c,&q2);
- if (c->depth_test)
- ZB_line_z(c->zb,&q1.zp,&q2.zp);
- else
- ZB_line(c->zb,&q1.zp,&q2.zp);
- }
- }
+ if (c->depth_test)
+ ZB_line_z(c->zb,&q1.zp,&q2.zp);
+ else
+ ZB_line(c->zb,&q1.zp,&q2.zp);
+ }
+ }
}
-
-/* triangle */
+// triangle
-/*
- * Clipping
- */
+// Clipping
-/* We clip the segment [a,b] against the 6 planes of the normal volume.
- * We compute the point 'c' of intersection and the value of the parameter 't'
- * of the intersection if x=a+t(b-a).
- */
+// We clip the segment [a,b] against the 6 planes of the normal volume.
+// We compute the point 'c' of intersection and the value of the parameter 't'
+// of the intersection if x=a+t(b-a).
-#define clip_func(name,sign,dir,dir1,dir2) \
-static float name(V4 *c,V4 *a,V4 *b) \
-{\
- float t,dX,dY,dZ,dW,den;\
- dX = (b->X - a->X);\
- dY = (b->Y - a->Y);\
- dZ = (b->Z - a->Z);\
- dW = (b->W - a->W);\
- den = -(sign d ## dir) + dW;\
- if (den == 0) t=0;\
- else t = ( sign a->dir - a->W) / den;\
- c->dir1 = a->dir1 + t * d ## dir1;\
- c->dir2 = a->dir2 + t * d ## dir2;\
- c->W = a->W + t * dW;\
- c->dir = sign c->W;\
- return t;\
+#define clip_func(name, sign, dir, dir1, dir2) \
+static float name(V4 *c, V4 *a, V4 *b) { \
+ float t, dX, dY, dZ, dW, den;\
+ dX = (b->X - a->X); \
+ dY = (b->Y - a->Y); \
+ dZ = (b->Z - a->Z); \
+ dW = (b->W - a->W); \
+ den = -(sign d ## dir) + dW; \
+ if (den == 0) \
+ t = 0; \
+ else \
+ t = (sign a->dir - a->W) / den; \
+ c->dir1 = a->dir1 + t * d ## dir1; \
+ c->dir2 = a->dir2 + t * d ## dir2; \
+ c->W = a->W + t * dW; \
+ c->dir = sign c->W; \
+ return t; \
}
+clip_func(clip_xmin, -, X, Y, Z)
+clip_func(clip_xmax, +, X, Y, Z)
+clip_func(clip_ymin, -, Y, X, Z)
+clip_func(clip_ymax, +, Y, X, Z)
+clip_func(clip_zmin, -, Z, X, Y)
+clip_func(clip_zmax, +, Z, X, Y)
-clip_func(clip_xmin,-,X,Y,Z)
+float (*clip_proc[6])(V4 *, V4 *, V4 *)= {
+ clip_xmin, clip_xmax,
+ clip_ymin, clip_ymax,
+ clip_zmin, clip_zmax
+};
-clip_func(clip_xmax,+,X,Y,Z)
+static inline void updateTmp(GLContext *c, GLVertex *q,
+ GLVertex *p0, GLVertex *p1, float t) {
+ if (c->current_shade_model == TGL_SMOOTH) {
+ 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;
+ } else {
+ q->color.v[0] = p0->color.v[0];
+ q->color.v[1] = p0->color.v[1];
+ q->color.v[2] = p0->color.v[2];
+ }
-clip_func(clip_ymin,-,Y,X,Z)
+ if (c->texture_2d_enabled) {
+ q->tex_coord.X = p0->tex_coord.X + (p1->tex_coord.X - p0->tex_coord.X) * t;
+ q->tex_coord.Y = p0->tex_coord.Y + (p1->tex_coord.Y - p0->tex_coord.Y) * t;
+ }
-clip_func(clip_ymax,+,Y,X,Z)
+ q->clip_code=gl_clipcode(q->pc.X, q->pc.Y, q->pc.Z, q->pc.W);
+ if (q->clip_code == 0)
+ gl_transform_to_viewport(c, q);
+}
-clip_func(clip_zmin,-,Z,X,Y)
+static void gl_draw_triangle_clip(GLContext *c, GLVertex *p0,
+ GLVertex *p1, GLVertex *p2, int clip_bit);
-clip_func(clip_zmax,+,Z,X,Y)
+void gl_draw_triangle(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2) {
+ int co,c_and,cc[3],front;
+ float norm;
+ cc[0]=p0->clip_code;
+ cc[1]=p1->clip_code;
+ cc[2]=p2->clip_code;
-float (*clip_proc[6])(V4 *,V4 *,V4 *)= {
- clip_xmin,clip_xmax,
- clip_ymin,clip_ymax,
- clip_zmin,clip_zmax
-};
+ co=cc[0] | cc[1] | cc[2];
-static inline void updateTmp(GLContext *c,
- GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
-{
- if (c->current_shade_model == TGL_SMOOTH) {
- 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;
- } else {
- q->color.v[0]=p0->color.v[0];
- q->color.v[1]=p0->color.v[1];
- q->color.v[2]=p0->color.v[2];
- }
+ // we handle the non clipped case here to go faster
+ if (co == 0) {
+ norm = (float)(p1->zp.x - p0->zp.x) * (float)(p2->zp.y - p0->zp.y) -
+ (float)(p2->zp.x - p0->zp.x) * (float)(p1->zp.y - p0->zp.y);
+ if (norm == 0)
+ return;
- if (c->texture_2d_enabled) {
- q->tex_coord.X=p0->tex_coord.X + (p1->tex_coord.X-p0->tex_coord.X)*t;
- q->tex_coord.Y=p0->tex_coord.Y + (p1->tex_coord.Y-p0->tex_coord.Y)*t;
- }
+ front = norm < 0.0;
+ front = front ^ c->current_front_face;
- q->clip_code=gl_clipcode(q->pc.X,q->pc.Y,q->pc.Z,q->pc.W);
- if (q->clip_code==0)
- gl_transform_to_viewport(c,q);
+ // back face culling
+ if (c->cull_face_enabled) {
+ // most used case first */
+ if (c->current_cull_face == TGL_BACK) {
+ if (front == 0)
+ return;
+ c->draw_triangle_front(c, p0, p1, p2);
+ } else if (c->current_cull_face == TGL_FRONT) {
+ if (front != 0)
+ return;
+ c->draw_triangle_back(c,p0,p1,p2);
+ } else {
+ return;
+ }
+ } else {
+ // no culling
+ if (front) {
+ c->draw_triangle_front(c, p0, p1, p2);
+ } else {
+ c->draw_triangle_back(c, p0, p1, p2);
+ }
+ }
+ } else {
+ c_and = cc[0] & cc[1] & cc[2];
+ if (c_and == 0) {
+ gl_draw_triangle_clip(c, p0, p1, p2, 0);
+ }
+ }
}
-static void gl_draw_triangle_clip(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit);
+static void gl_draw_triangle_clip(GLContext *c, GLVertex *p0,
+ GLVertex *p1, GLVertex *p2, int clip_bit) {
+ int co, c_and, co1, cc[3], edge_flag_tmp, clip_mask;
+ GLVertex tmp1, tmp2, *q[3];
+ float tt;
-void gl_draw_triangle(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2)
-{
- int co,c_and,cc[3],front;
- float norm;
+ cc[0] = p0->clip_code;
+ cc[1] = p1->clip_code;
+ cc[2] = p2->clip_code;
- cc[0]=p0->clip_code;
- cc[1]=p1->clip_code;
- cc[2]=p2->clip_code;
-
- co=cc[0] | cc[1] | cc[2];
+ co = cc[0] | cc[1] | cc[2];
+ if (co == 0) {
+ gl_draw_triangle(c, p0, p1, p2);
+ } else {
+ c_and = cc[0] & cc[1] & cc[2];
+ // the triangle is completely outside
+ if (c_and != 0)
+ return;
- /* we handle the non clipped case here to go faster */
- if (co==0) {
-
- norm=(float)(p1->zp.x-p0->zp.x)*(float)(p2->zp.y-p0->zp.y)-
- (float)(p2->zp.x-p0->zp.x)*(float)(p1->zp.y-p0->zp.y);
-
- if (norm == 0) return;
+ // find the next direction to clip
+ while (clip_bit < 6 && (co & (1 << clip_bit)) == 0) {
+ clip_bit++;
+ }
- front = norm < 0.0;
- front = front ^ c->current_front_face;
-
- /* back face culling */
- if (c->cull_face_enabled) {
- /* most used case first */
- if (c->current_cull_face == TGL_BACK) {
- if (front == 0) return;
- c->draw_triangle_front(c,p0,p1,p2);
- } else if (c->current_cull_face == TGL_FRONT) {
- if (front != 0) return;
- c->draw_triangle_back(c,p0,p1,p2);
- } else {
- return;
- }
- } else {
- /* no culling */
- if (front) {
- c->draw_triangle_front(c,p0,p1,p2);
- } else {
- c->draw_triangle_back(c,p0,p1,p2);
- }
- }
- } else {
- c_and=cc[0] & cc[1] & cc[2];
- if (c_and==0) {
- gl_draw_triangle_clip(c,p0,p1,p2,0);
- }
- }
-}
+ // this test can be true only in case of rounding errors
+ if (clip_bit == 6) {
+#if 0
+ printf("Error:\n");
+ printf("%f %f %f %f\n", p0->pc.X, p0->pc.Y, p0->pc.Z, p0->pc.W);
+ printf("%f %f %f %f\n", p1->pc.X, p1->pc.Y, p1->pc.Z, p1->pc.W);
+ printf("%f %f %f %f\n", p2->pc.X, p2->pc.Y, p2->pc.Z, p2->pc.W);
+#endif
+ return;
+ }
-static void gl_draw_triangle_clip(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit)
-{
- int co,c_and,co1,cc[3],edge_flag_tmp,clip_mask;
- GLVertex tmp1,tmp2,*q[3];
- float tt;
-
- cc[0]=p0->clip_code;
- cc[1]=p1->clip_code;
- cc[2]=p2->clip_code;
-
- co=cc[0] | cc[1] | cc[2];
- if (co == 0) {
- gl_draw_triangle(c,p0,p1,p2);
- } else {
- c_and=cc[0] & cc[1] & cc[2];
- /* the triangle is completely outside */
- if (c_and!=0) return;
+ clip_mask = 1 << clip_bit;
+ co1 = (cc[0] ^ cc[1] ^ cc[2]) & clip_mask;
- /* find the next direction to clip */
- while (clip_bit < 6 && (co & (1 << clip_bit)) == 0) {
- clip_bit++;
- }
+ if (co1) {
+ // one point outside
+ if (cc[0] & clip_mask) {
+ q[0] = p0; q[1] = p1; q[2] = p2;
+ } else if (cc[1] & clip_mask) {
+ q[0] = p1; q[1] = p2; q[2] = p0;
+ } else {
+ q[0] = p2; q[1] = p0; q[2] = p1;
+ }
- /* this test can be true only in case of rounding errors */
- if (clip_bit == 6) {
-#if 0
- printf("Error:\n");
- printf("%f %f %f %f\n",p0->pc.X,p0->pc.Y,p0->pc.Z,p0->pc.W);
- printf("%f %f %f %f\n",p1->pc.X,p1->pc.Y,p1->pc.Z,p1->pc.W);
- printf("%f %f %f %f\n",p2->pc.X,p2->pc.Y,p2->pc.Z,p2->pc.W);
-#endif
- return;
- }
-
- clip_mask = 1 << clip_bit;
- co1=(cc[0] ^ cc[1] ^ cc[2]) & clip_mask;
-
- if (co1) {
- /* one point outside */
+ tt = clip_proc[clip_bit](&tmp1.pc, &q[0]->pc, &q[1]->pc);
+ updateTmp(c, &tmp1, q[0], q[1], tt);
- if (cc[0] & clip_mask) { q[0]=p0; q[1]=p1; q[2]=p2; }
- else if (cc[1] & clip_mask) { q[0]=p1; q[1]=p2; q[2]=p0; }
- else { q[0]=p2; q[1]=p0; q[2]=p1; }
-
- tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc);
- updateTmp(c,&tmp1,q[0],q[1],tt);
+ tt = clip_proc[clip_bit](&tmp2.pc, &q[0]->pc, &q[2]->pc);
+ updateTmp(c, &tmp2, q[0], q[2],tt);
- tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc);
- updateTmp(c,&tmp2,q[0],q[2],tt);
+ tmp1.edge_flag = q[0]->edge_flag;
+ edge_flag_tmp = q[2]->edge_flag;
+ q[2]->edge_flag = 0;
+ gl_draw_triangle_clip(c, &tmp1, q[1], q[2], clip_bit + 1);
- tmp1.edge_flag=q[0]->edge_flag;
- edge_flag_tmp=q[2]->edge_flag;
- q[2]->edge_flag=0;
- gl_draw_triangle_clip(c,&tmp1,q[1],q[2],clip_bit+1);
+ tmp2.edge_flag = 1;
+ tmp1.edge_flag = 0;
+ q[2]->edge_flag = edge_flag_tmp;
+ gl_draw_triangle_clip(c, &tmp2, &tmp1, q[2], clip_bit + 1);
+ } else {
+ // two points outside
+ if ((cc[0] & clip_mask) == 0) {
+ q[0] = p0; q[1] = p1; q[2] = p2;
+ } else if ((cc[1] & clip_mask) == 0) {
+ q[0] = p1; q[1] = p2; q[2] = p0;
+ } else {
+ q[0] = p2; q[1] = p0; q[2] = p1;
+ }
- tmp2.edge_flag=1;
- tmp1.edge_flag=0;
- q[2]->edge_flag=edge_flag_tmp;
- gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1);
- } else {
- /* two points outside */
+ tt = clip_proc[clip_bit](&tmp1.pc, &q[0]->pc, &q[1]->pc);
+ updateTmp(c, &tmp1, q[0], q[1], tt);
- if ((cc[0] & clip_mask)==0) { q[0]=p0; q[1]=p1; q[2]=p2; }
- else if ((cc[1] & clip_mask)==0) { q[0]=p1; q[1]=p2; q[2]=p0; }
- else { q[0]=p2; q[1]=p0; q[2]=p1; }
-
- tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc);
- updateTmp(c,&tmp1,q[0],q[1],tt);
+ tt = clip_proc[clip_bit](&tmp2.pc, &q[0]->pc, &q[2]->pc);
+ updateTmp(c, &tmp2, q[0], q[2], tt);
- tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc);
- updateTmp(c,&tmp2,q[0],q[2],tt);
-
- tmp1.edge_flag=1;
- tmp2.edge_flag=q[2]->edge_flag;
- gl_draw_triangle_clip(c,q[0],&tmp1,&tmp2,clip_bit+1);
- }
- }
+ tmp1.edge_flag = 1;
+ tmp2.edge_flag = q[2]->edge_flag;
+ gl_draw_triangle_clip(c, q[0], &tmp1, &tmp2, clip_bit + 1);
+ }
+ }
}
-
-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);
+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;
+int count_triangles, count_triangles_textured, count_pixels;
#endif
-void gl_draw_triangle_fill(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2)
-{
+void gl_draw_triangle_fill(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2) {
#ifdef PROFILE
- {
- int norm;
- assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize);
- assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize);
- assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize);
- assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize);
- assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize);
- assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize);
-
- norm=(p1->zp.x-p0->zp.x)*(p2->zp.y-p0->zp.y)-
- (p2->zp.x-p0->zp.x)*(p1->zp.y-p0->zp.y);
- count_pixels+=abs(norm)/2;
- count_triangles++;
- }
+ {
+ int norm;
+ assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize);
+ assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize);
+ assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize);
+ assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize);
+ assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize);
+ assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize);
+
+ norm = (p1->zp.x - p0->zp.x) * (p2->zp.y - p0->zp.y) -
+ (p2->zp.x - p0->zp.x) * (p1->zp.y - p0->zp.y);
+ count_pixels += abs(norm) / 2;
+ count_triangles++;
+ }
#endif
- if (c->texture_2d_enabled) {
+ if (c->texture_2d_enabled) {
#ifdef PROFILE
- count_triangles_textured++;
+ count_triangles_textured++;
#endif
- ZB_setTexture(c->zb,(PIXEL *)c->current_texture->images[0].pixmap);
- ZB_fillTriangleMappingPerspective(c->zb,&p0->zp,&p1->zp,&p2->zp);
- } else if (c->current_shade_model == TGL_SMOOTH) {
- ZB_fillTriangleSmooth(c->zb,&p0->zp,&p1->zp,&p2->zp);
- } else {
- ZB_fillTriangleFlat(c->zb,&p0->zp,&p1->zp,&p2->zp);
- }
+ ZB_setTexture(c->zb, (PIXEL *)c->current_texture->images[0].pixmap);
+ ZB_fillTriangleMappingPerspective(c->zb, &p0->zp, &p1->zp, &p2->zp);
+ } else if (c->current_shade_model == TGL_SMOOTH) {
+ ZB_fillTriangleSmooth(c->zb, &p0->zp, &p1->zp, &p2->zp);
+ } else {
+ ZB_fillTriangleFlat(c->zb, &p0->zp, &p1->zp, &p2->zp);
+ }
}
-/* Render a clipped triangle in line mode */
+// Render a clipped triangle in line mode
-void gl_draw_triangle_line(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2)
-{
- if (c->depth_test) {
- if (p0->edge_flag) ZB_line_z(c->zb,&p0->zp,&p1->zp);
- if (p1->edge_flag) ZB_line_z(c->zb,&p1->zp,&p2->zp);
- if (p2->edge_flag) ZB_line_z(c->zb,&p2->zp,&p0->zp);
- } else {
- if (p0->edge_flag) ZB_line(c->zb,&p0->zp,&p1->zp);
- if (p1->edge_flag) ZB_line(c->zb,&p1->zp,&p2->zp);
- if (p2->edge_flag) ZB_line(c->zb,&p2->zp,&p0->zp);
- }
+void gl_draw_triangle_line(GLContext *c, GLVertex *p0, GLVertex *p1,GLVertex *p2) {
+ if (c->depth_test) {
+ if (p0->edge_flag)
+ ZB_line_z(c->zb, &p0->zp, &p1->zp);
+ if (p1->edge_flag)
+ ZB_line_z(c->zb, &p1->zp, &p2->zp);
+ if (p2->edge_flag)
+ ZB_line_z(c->zb, &p2->zp, &p0->zp);
+ } else {
+ if (p0->edge_flag)
+ ZB_line(c->zb, &p0->zp, &p1->zp);
+ if (p1->edge_flag)
+ ZB_line(c->zb, &p1->zp, &p2->zp);
+ if (p2->edge_flag)
+ ZB_line(c->zb, &p2->zp, &p0->zp);
+ }
}
-
-
-/* Render a clipped triangle in point mode */
-void gl_draw_triangle_point(GLContext *c,
- GLVertex *p0,GLVertex *p1,GLVertex *p2)
-{
- if (p0->edge_flag) ZB_plot(c->zb,&p0->zp);
- if (p1->edge_flag) ZB_plot(c->zb,&p1->zp);
- if (p2->edge_flag) ZB_plot(c->zb,&p2->zp);
+// Render a clipped triangle in point mode
+void gl_draw_triangle_point(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2) {
+ if (p0->edge_flag)
+ ZB_plot(c->zb, &p0->zp);
+ if (p1->edge_flag)
+ ZB_plot(c->zb, &p1->zp);
+ if (p2->edge_flag)
+ ZB_plot(c->zb, &p2->zp);
}
-
-
-
-
Modified: residual/trunk/tinygl/error.cpp
===================================================================
--- residual/trunk/tinygl/error.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/error.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,16 +1,16 @@
+
#include <stdarg.h>
#include "tinygl/zgl.h"
-void gl_fatal_error(char *format, ...)
-{
- va_list ap;
+void gl_fatal_error(char *format, ...) {
+ va_list ap;
- va_start(ap,format);
+ va_start(ap, format);
- fprintf(stderr,"TinyGL: fatal error: ");
- vfprintf(stderr,format,ap);
- fprintf(stderr,"\n");
- exit(1);
+ fprintf(stderr, "TinyGL: fatal error: ");
+ vfprintf(stderr, format,ap);
+ fprintf(stderr, "\n");
+ exit(1);
- va_end(ap);
+ va_end(ap);
}
Modified: residual/trunk/tinygl/get.cpp
===================================================================
--- residual/trunk/tinygl/get.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/get.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,16 +1,16 @@
+
#include "tinygl/zgl.h"
-void glGetIntegerv(int pname,int *params)
-{
- GLContext *c=gl_get_context();
+void glGetIntegerv(int pname,int *params) {
+ GLContext *c=gl_get_context();
- switch(pname) {
- case TGL_VIEWPORT:
- params[0]=c->viewport.xmin;
- params[1]=c->viewport.ymin;
- params[2]=c->viewport.xsize;
- params[3]=c->viewport.ysize;
- break;
+ switch(pname) {
+ case TGL_VIEWPORT:
+ params[0]=c->viewport.xmin;
+ params[1]=c->viewport.ymin;
+ params[2]=c->viewport.xsize;
+ params[3]=c->viewport.ysize;
+ break;
case TGL_MAX_MODELVIEW_STACK_DEPTH:
*params = MAX_MODELVIEW_STACK_DEPTH;
break;
Modified: residual/trunk/tinygl/gl.h
===================================================================
--- residual/trunk/tinygl/gl.h 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/gl.h 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,674 +1,671 @@
-/*
- * The following constants come from Mesa
- */
+
+// The following constants come from Mesa
+
#ifndef TGL_H
#define TGL_H
#define TGL_VERSION_1_1 1
enum {
- /* Boolean values */
- TGL_FALSE = 0,
- TGL_TRUE = 1,
+ // Boolean values
+ TGL_FALSE = 0,
+ TGL_TRUE = 1,
- /* Data types */
- TGL_BYTE = 0x1400,
- TGL_UNSIGNED_BYTE = 0x1401,
- TGL_SHORT = 0x1402,
- TGL_UNSIGNED_SHORT = 0x1403,
- TGL_INT = 0x1404,
- TGL_UNSIGNED_INT = 0x1405,
- TGL_FLOAT = 0x1406,
- TGL_DOUBLE = 0x140A,
- TGL_2_BYTES = 0x1407,
- TGL_3_BYTES = 0x1408,
- TGL_4_BYTES = 0x1409,
+ // Data types
+ TGL_BYTE = 0x1400,
+ TGL_UNSIGNED_BYTE = 0x1401,
+ TGL_SHORT = 0x1402,
+ TGL_UNSIGNED_SHORT = 0x1403,
+ TGL_INT = 0x1404,
+ TGL_UNSIGNED_INT = 0x1405,
+ TGL_FLOAT = 0x1406,
+ TGL_DOUBLE = 0x140A,
+ TGL_2_BYTES = 0x1407,
+ TGL_3_BYTES = 0x1408,
+ TGL_4_BYTES = 0x1409,
- /* Primitives */
- TGL_LINES = 0x0001,
- TGL_POINTS = 0x0000,
- TGL_LINE_STRIP = 0x0003,
- TGL_LINE_LOOP = 0x0002,
- TGL_TRIANGLES = 0x0004,
- TGL_TRIANGLE_STRIP = 0x0005,
- TGL_TRIANGLE_FAN = 0x0006,
- TGL_QUADS = 0x0007,
- TGL_QUAD_STRIP = 0x0008,
- TGL_POLYGON = 0x0009,
- TGL_EDGE_FLAG = 0x0B43,
+ // Primitives
+ TGL_LINES = 0x0001,
+ TGL_POINTS = 0x0000,
+ TGL_LINE_STRIP = 0x0003,
+ TGL_LINE_LOOP = 0x0002,
+ TGL_TRIANGLES = 0x0004,
+ TGL_TRIANGLE_STRIP = 0x0005,
+ TGL_TRIANGLE_FAN = 0x0006,
+ TGL_QUADS = 0x0007,
+ TGL_QUAD_STRIP = 0x0008,
+ TGL_POLYGON = 0x0009,
+ TGL_EDGE_FLAG = 0x0B43,
- /* Vertex Arrays */
- TGL_VERTEX_ARRAY = 0x8074,
- TGL_NORMAL_ARRAY = 0x8075,
- TGL_COLOR_ARRAY = 0x8076,
- TGL_INDEX_ARRAY = 0x8077,
- TGL_TEXTURE_COORD_ARRAY = 0x8078,
- TGL_EDGE_FLAG_ARRAY = 0x8079,
- TGL_VERTEX_ARRAY_SIZE = 0x807A,
- TGL_VERTEX_ARRAY_TYPE = 0x807B,
- TGL_VERTEX_ARRAY_STRIDE = 0x807C,
- TGL_VERTEX_ARRAY_COUNT = 0x807D,
- TGL_NORMAL_ARRAY_TYPE = 0x807E,
- TGL_NORMAL_ARRAY_STRIDE = 0x807F,
- TGL_NORMAL_ARRAY_COUNT = 0x8080,
- TGL_COLOR_ARRAY_SIZE = 0x8081,
- TGL_COLOR_ARRAY_TYPE = 0x8082,
- TGL_COLOR_ARRAY_STRIDE = 0x8083,
- TGL_COLOR_ARRAY_COUNT = 0x8084,
- TGL_INDEX_ARRAY_TYPE = 0x8085,
- TGL_INDEX_ARRAY_STRIDE = 0x8086,
- TGL_INDEX_ARRAY_COUNT = 0x8087,
+ // Vertex Arrays
+ TGL_VERTEX_ARRAY = 0x8074,
+ TGL_NORMAL_ARRAY = 0x8075,
+ TGL_COLOR_ARRAY = 0x8076,
+ TGL_INDEX_ARRAY = 0x8077,
+ TGL_TEXTURE_COORD_ARRAY = 0x8078,
+ TGL_EDGE_FLAG_ARRAY = 0x8079,
+ TGL_VERTEX_ARRAY_SIZE = 0x807A,
+ TGL_VERTEX_ARRAY_TYPE = 0x807B,
+ TGL_VERTEX_ARRAY_STRIDE = 0x807C,
+ TGL_VERTEX_ARRAY_COUNT = 0x807D,
+ TGL_NORMAL_ARRAY_TYPE = 0x807E,
+ TGL_NORMAL_ARRAY_STRIDE = 0x807F,
+ TGL_NORMAL_ARRAY_COUNT = 0x8080,
+ TGL_COLOR_ARRAY_SIZE = 0x8081,
+ TGL_COLOR_ARRAY_TYPE = 0x8082,
+ TGL_COLOR_ARRAY_STRIDE = 0x8083,
+ TGL_COLOR_ARRAY_COUNT = 0x8084,
+ TGL_INDEX_ARRAY_TYPE = 0x8085,
+ TGL_INDEX_ARRAY_STRIDE = 0x8086,
+ TGL_INDEX_ARRAY_COUNT = 0x8087,
TGL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
TGL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
TGL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
TGL_TEXTURE_COORD_ARRAY_COUNT = 0x808B,
- TGL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
- TGL_EDGE_FLAG_ARRAY_COUNT = 0x808D,
+ TGL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
+ TGL_EDGE_FLAG_ARRAY_COUNT = 0x808D,
TGL_VERTEX_ARRAY_POINTER = 0x808E,
TGL_NORMAL_ARRAY_POINTER = 0x808F,
- TGL_COLOR_ARRAY_POINTER = 0x8090,
- TGL_INDEX_ARRAY_POINTER = 0x8091,
+ TGL_COLOR_ARRAY_POINTER = 0x8090,
+ TGL_INDEX_ARRAY_POINTER = 0x8091,
TGL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
- TGL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
- TGL_V2F = 0x2A20,
- TGL_V3F = 0x2A21,
- TGL_C4UB_V2F = 0x2A22,
- TGL_C4UB_V3F = 0x2A23,
- TGL_C3F_V3F = 0x2A24,
- TGL_N3F_V3F = 0x2A25,
- TGL_C4F_N3F_V3F = 0x2A26,
- TGL_T2F_V3F = 0x2A27,
- TGL_T4F_V4F = 0x2A28,
- TGL_T2F_C4UB_V3F = 0x2A29,
- TGL_T2F_C3F_V3F = 0x2A2A,
- TGL_T2F_N3F_V3F = 0x2A2B,
- TGL_T2F_C4F_N3F_V3F = 0x2A2C,
- TGL_T4F_C4F_N3F_V4F = 0x2A2D,
+ TGL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
+ TGL_V2F = 0x2A20,
+ TGL_V3F = 0x2A21,
+ TGL_C4UB_V2F = 0x2A22,
+ TGL_C4UB_V3F = 0x2A23,
+ TGL_C3F_V3F = 0x2A24,
+ TGL_N3F_V3F = 0x2A25,
+ TGL_C4F_N3F_V3F = 0x2A26,
+ TGL_T2F_V3F = 0x2A27,
+ TGL_T4F_V4F = 0x2A28,
+ TGL_T2F_C4UB_V3F = 0x2A29,
+ TGL_T2F_C3F_V3F = 0x2A2A,
+ TGL_T2F_N3F_V3F = 0x2A2B,
+ TGL_T2F_C4F_N3F_V3F = 0x2A2C,
+ TGL_T4F_C4F_N3F_V4F = 0x2A2D,
- /* Matrix Mode */
- TGL_MATRIX_MODE = 0x0BA0,
- TGL_MODELVIEW = 0x1700,
- TGL_PROJECTION = 0x1701,
- TGL_TEXTURE = 0x1702,
+ // Matrix Mode
+ TGL_MATRIX_MODE = 0x0BA0,
+ TGL_MODELVIEW = 0x1700,
+ TGL_PROJECTION = 0x1701,
+ TGL_TEXTURE = 0x1702,
- /* Points */
- TGL_POINT_SMOOTH = 0x0B10,
- TGL_POINT_SIZE = 0x0B11,
- TGL_POINT_SIZE_GRANULARITY = 0x0B13,
- TGL_POINT_SIZE_RANGE = 0x0B12,
+ // Points
+ TGL_POINT_SMOOTH = 0x0B10,
+ TGL_POINT_SIZE = 0x0B11,
+ TGL_POINT_SIZE_GRANULARITY = 0x0B13,
+ TGL_POINT_SIZE_RANGE = 0x0B12,
- /* Lines */
- TGL_LINE_SMOOTH = 0x0B20,
- TGL_LINE_STIPPLE = 0x0B24,
+ // Lines
+ TGL_LINE_SMOOTH = 0x0B20,
+ TGL_LINE_STIPPLE = 0x0B24,
TGL_LINE_STIPPLE_PATTERN = 0x0B25,
- TGL_LINE_STIPPLE_REPEAT = 0x0B26,
- TGL_LINE_WIDTH = 0x0B21,
- TGL_LINE_WIDTH_GRANULARITY = 0x0B23,
- TGL_LINE_WIDTH_RANGE = 0x0B22,
+ TGL_LINE_STIPPLE_REPEAT = 0x0B26,
+ TGL_LINE_WIDTH = 0x0B21,
+ TGL_LINE_WIDTH_GRANULARITY = 0x0B23,
+ TGL_LINE_WIDTH_RANGE = 0x0B22,
- /* Polygons */
- TGL_POINT = 0x1B00,
- TGL_LINE = 0x1B01,
- TGL_FILL = 0x1B02,
- TGL_CCW = 0x0901,
- TGL_CW = 0x0900,
- TGL_FRONT = 0x0404,
- TGL_BACK = 0x0405,
- TGL_CULL_FACE = 0x0B44,
- TGL_CULL_FACE_MODE = 0x0B45,
- TGL_POLYGON_SMOOTH = 0x0B41,
- TGL_POLYGON_STIPPLE = 0x0B42,
- TGL_FRONT_FACE = 0x0B46,
- TGL_POLYGON_MODE = 0x0B40,
- TGL_POLYGON_OFFSET_FACTOR = 0x3038,
+ // Polygons
+ TGL_POINT = 0x1B00,
+ TGL_LINE = 0x1B01,
+ TGL_FILL = 0x1B02,
+ TGL_CCW = 0x0901,
+ TGL_CW = 0x0900,
+ TGL_FRONT = 0x0404,
+ TGL_BACK = 0x0405,
+ TGL_CULL_FACE = 0x0B44,
+ TGL_CULL_FACE_MODE = 0x0B45,
+ TGL_POLYGON_SMOOTH = 0x0B41,
+ TGL_POLYGON_STIPPLE = 0x0B42,
+ TGL_FRONT_FACE = 0x0B46,
+ TGL_POLYGON_MODE = 0x0B40,
+ TGL_POLYGON_OFFSET_FACTOR = 0x3038,
TGL_POLYGON_OFFSET_UNITS = 0x2A00,
TGL_POLYGON_OFFSET_POINT = 0x2A01,
- TGL_POLYGON_OFFSET_LINE = 0x2A02,
- TGL_POLYGON_OFFSET_FILL = 0x8037,
+ TGL_POLYGON_OFFSET_LINE = 0x2A02,
+ TGL_POLYGON_OFFSET_FILL = 0x8037,
- /* Display Lists */
- TGL_COMPILE = 0x1300,
- TGL_COMPILE_AND_EXECUTE = 0x1301,
- TGL_LIST_BASE = 0x0B32,
- TGL_LIST_INDEX = 0x0B33,
- TGL_LIST_MODE = 0x0B30,
+ // Display Lists
+ TGL_COMPILE = 0x1300,
+ TGL_COMPILE_AND_EXECUTE = 0x1301,
+ TGL_LIST_BASE = 0x0B32,
+ TGL_LIST_INDEX = 0x0B33,
+ TGL_LIST_MODE = 0x0B30,
- /* Depth buffer */
- TGL_NEVER = 0x0200,
- TGL_LESS = 0x0201,
- TGL_GEQUAL = 0x0206,
- TGL_LEQUAL = 0x0203,
- TGL_GREATER = 0x0204,
- TGL_NOTEQUAL = 0x0205,
- TGL_EQUAL = 0x0202,
- TGL_ALWAYS = 0x0207,
- TGL_DEPTH_TEST = 0x0B71,
- TGL_DEPTH_BITS = 0x0D56,
- TGL_DEPTH_CLEAR_VALUE = 0x0B73,
- TGL_DEPTH_FUNC = 0x0B74,
- TGL_DEPTH_RANGE = 0x0B70,
- TGL_DEPTH_WRITEMASK = 0x0B72,
- TGL_DEPTH_COMPONENT = 0x1902,
+ // Depth buffer
+ TGL_NEVER = 0x0200,
+ TGL_LESS = 0x0201,
+ TGL_GEQUAL = 0x0206,
+ TGL_LEQUAL = 0x0203,
+ TGL_GREATER = 0x0204,
+ TGL_NOTEQUAL = 0x0205,
+ TGL_EQUAL = 0x0202,
+ TGL_ALWAYS = 0x0207,
+ TGL_DEPTH_TEST = 0x0B71,
+ TGL_DEPTH_BITS = 0x0D56,
+ TGL_DEPTH_CLEAR_VALUE = 0x0B73,
+ TGL_DEPTH_FUNC = 0x0B74,
+ TGL_DEPTH_RANGE = 0x0B70,
+ TGL_DEPTH_WRITEMASK = 0x0B72,
+ TGL_DEPTH_COMPONENT = 0x1902,
- /* Lighting */
- TGL_LIGHTING = 0x0B50,
- TGL_LIGHT0 = 0x4000,
- TGL_LIGHT1 = 0x4001,
- TGL_LIGHT2 = 0x4002,
- TGL_LIGHT3 = 0x4003,
- TGL_LIGHT4 = 0x4004,
- TGL_LIGHT5 = 0x4005,
- TGL_LIGHT6 = 0x4006,
- TGL_LIGHT7 = 0x4007,
- TGL_SPOT_EXPONENT = 0x1205,
- TGL_SPOT_CUTOFF = 0x1206,
+ // Lighting
+ TGL_LIGHTING = 0x0B50,
+ TGL_LIGHT0 = 0x4000,
+ TGL_LIGHT1 = 0x4001,
+ TGL_LIGHT2 = 0x4002,
+ TGL_LIGHT3 = 0x4003,
+ TGL_LIGHT4 = 0x4004,
+ TGL_LIGHT5 = 0x4005,
+ TGL_LIGHT6 = 0x4006,
+ TGL_LIGHT7 = 0x4007,
+ TGL_SPOT_EXPONENT = 0x1205,
+ TGL_SPOT_CUTOFF = 0x1206,
TGL_CONSTANT_ATTENUATION = 0x1207,
- TGL_LINEAR_ATTENUATION = 0x1208,
- TGL_QUADRATIC_ATTENUATION = 0x1209,
- TGL_AMBIENT = 0x1200,
- TGL_DIFFUSE = 0x1201,
- TGL_SPECULAR = 0x1202,
- TGL_SHININESS = 0x1601,
- TGL_EMISSION = 0x1600,
- TGL_POSITION = 0x1203,
- TGL_SPOT_DIRECTION = 0x1204,
- TGL_AMBIENT_AND_DIFFUSE = 0x1602,
- TGL_COLOR_INDEXES = 0x1603,
+ TGL_LINEAR_ATTENUATION = 0x1208,
+ TGL_QUADRATIC_ATTENUATION = 0x1209,
+ TGL_AMBIENT = 0x1200,
+ TGL_DIFFUSE = 0x1201,
+ TGL_SPECULAR = 0x1202,
+ TGL_SHININESS = 0x1601,
+ TGL_EMISSION = 0x1600,
+ TGL_POSITION = 0x1203,
+ TGL_SPOT_DIRECTION = 0x1204,
+ TGL_AMBIENT_AND_DIFFUSE = 0x1602,
+ TGL_COLOR_INDEXES = 0x1603,
TGL_LIGHT_MODEL_TWO_SIDE = 0x0B52,
TGL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
- TGL_LIGHT_MODEL_AMBIENT = 0x0B53,
- TGL_FRONT_AND_BACK = 0x0408,
- TGL_SHADE_MODEL = 0x0B54,
- TGL_FLAT = 0x1D00,
- TGL_SMOOTH = 0x1D01,
- TGL_COLOR_MATERIAL = 0x0B57,
- TGL_COLOR_MATERIAL_FACE = 0x0B55,
+ TGL_LIGHT_MODEL_AMBIENT = 0x0B53,
+ TGL_FRONT_AND_BACK = 0x0408,
+ TGL_SHADE_MODEL = 0x0B54,
+ TGL_FLAT = 0x1D00,
+ TGL_SMOOTH = 0x1D01,
+ TGL_COLOR_MATERIAL = 0x0B57,
+ TGL_COLOR_MATERIAL_FACE = 0x0B55,
TGL_COLOR_MATERIAL_PARAMETER = 0x0B56,
- TGL_NORMALIZE = 0x0BA1,
+ TGL_NORMALIZE = 0x0BA1,
- /* User clipping planes */
- TGL_CLIP_PLANE0 = 0x3000,
- TGL_CLIP_PLANE1 = 0x3001,
- TGL_CLIP_PLANE2 = 0x3002,
- TGL_CLIP_PLANE3 = 0x3003,
- TGL_CLIP_PLANE4 = 0x3004,
- TGL_CLIP_PLANE5 = 0x3005,
+ // User clipping planes
+ TGL_CLIP_PLANE0 = 0x3000,
+ TGL_CLIP_PLANE1 = 0x3001,
+ TGL_CLIP_PLANE2 = 0x3002,
+ TGL_CLIP_PLANE3 = 0x3003,
+ TGL_CLIP_PLANE4 = 0x3004,
+ TGL_CLIP_PLANE5 = 0x3005,
- /* Accumulation buffer */
- TGL_ACCUM_RED_BITS = 0x0D58,
- TGL_ACCUM_GREEN_BITS = 0x0D59,
- TGL_ACCUM_BLUE_BITS = 0x0D5A,
- TGL_ACCUM_ALPHA_BITS = 0x0D5B,
- TGL_ACCUM_CLEAR_VALUE = 0x0B80,
- TGL_ACCUM = 0x0100,
- TGL_ADD = 0x0104,
- TGL_LOAD = 0x0101,
- TGL_MULT = 0x0103,
- TGL_RETURN = 0x0102,
+ // Accumulation buffer
+ TGL_ACCUM_RED_BITS = 0x0D58,
+ TGL_ACCUM_GREEN_BITS = 0x0D59,
+ TGL_ACCUM_BLUE_BITS = 0x0D5A,
+ TGL_ACCUM_ALPHA_BITS = 0x0D5B,
+ TGL_ACCUM_CLEAR_VALUE = 0x0B80,
+ TGL_ACCUM = 0x0100,
+ TGL_ADD = 0x0104,
+ TGL_LOAD = 0x0101,
+ TGL_MULT = 0x0103,
+ TGL_RETURN = 0x0102,
- /* Alpha testing */
- TGL_ALPHA_TEST = 0x0BC0,
- TGL_ALPHA_TEST_REF = 0x0BC2,
- TGL_ALPHA_TEST_FUNC = 0x0BC1,
+ // Alpha testing
+ TGL_ALPHA_TEST = 0x0BC0,
+ TGL_ALPHA_TEST_REF = 0x0BC2,
+ TGL_ALPHA_TEST_FUNC = 0x0BC1,
- /* Blending */
- TGL_BLEND = 0x0BE2,
- TGL_BLEND_SRC = 0x0BE1,
- TGL_BLEND_DST = 0x0BE0,
- TGL_ZERO = 0,
- TGL_ONE = 1,
- TGL_SRC_COLOR = 0x0300,
- TGL_ONE_MINUS_SRC_COLOR = 0x0301,
- TGL_DST_COLOR = 0x0306,
- TGL_ONE_MINUS_DST_COLOR = 0x0307,
- TGL_SRC_ALPHA = 0x0302,
- TGL_ONE_MINUS_SRC_ALPHA = 0x0303,
- TGL_DST_ALPHA = 0x0304,
- TGL_ONE_MINUS_DST_ALPHA = 0x0305,
- TGL_SRC_ALPHA_SATURATE = 0x0308,
- TGL_CONSTANT_COLOR = 0x8001,
+ // Blending
+ TGL_BLEND = 0x0BE2,
+ TGL_BLEND_SRC = 0x0BE1,
+ TGL_BLEND_DST = 0x0BE0,
+ TGL_ZERO = 0,
+ TGL_ONE = 1,
+ TGL_SRC_COLOR = 0x0300,
+ TGL_ONE_MINUS_SRC_COLOR = 0x0301,
+ TGL_DST_COLOR = 0x0306,
+ TGL_ONE_MINUS_DST_COLOR = 0x0307,
+ TGL_SRC_ALPHA = 0x0302,
+ TGL_ONE_MINUS_SRC_ALPHA = 0x0303,
+ TGL_DST_ALPHA = 0x0304,
+ TGL_ONE_MINUS_DST_ALPHA = 0x0305,
+ TGL_SRC_ALPHA_SATURATE = 0x0308,
+ TGL_CONSTANT_COLOR = 0x8001,
TGL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
- TGL_CONSTANT_ALPHA = 0x8003,
+ TGL_CONSTANT_ALPHA = 0x8003,
TGL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
- /* Render Mode */
- TGL_FEEDBACK = 0x1C01,
- TGL_RENDER = 0x1C00,
- TGL_SELECT = 0x1C02,
+ // Render Mode
+ TGL_FEEDBACK = 0x1C01,
+ TGL_RENDER = 0x1C00,
+ TGL_SELECT = 0x1C02,
- /* Feedback */
- TGL_2D = 0x0600,
- TGL_3D = 0x0601,
- TGL_3D_COLOR = 0x0602,
- TGL_3D_COLOR_TEXTURE = 0x0603,
- TGL_4D_COLOR_TEXTURE = 0x0604,
- TGL_POINT_TOKEN = 0x0701,
- TGL_LINE_TOKEN = 0x0702,
- TGL_LINE_RESET_TOKEN = 0x0707,
- TGL_POLYGON_TOKEN = 0x0703,
- TGL_BITMAP_TOKEN = 0x0704,
- TGL_DRAW_PIXEL_TOKEN = 0x0705,
- TGL_COPY_PIXEL_TOKEN = 0x0706,
- TGL_PASS_THROUGH_TOKEN = 0x0700,
+ // Feedback
+ TGL_2D = 0x0600,
+ TGL_3D = 0x0601,
+ TGL_3D_COLOR = 0x0602,
+ TGL_3D_COLOR_TEXTURE = 0x0603,
+ TGL_4D_COLOR_TEXTURE = 0x0604,
+ TGL_POINT_TOKEN = 0x0701,
+ TGL_LINE_TOKEN = 0x0702,
+ TGL_LINE_RESET_TOKEN = 0x0707,
+ TGL_POLYGON_TOKEN = 0x0703,
+ TGL_BITMAP_TOKEN = 0x0704,
+ TGL_DRAW_PIXEL_TOKEN = 0x0705,
+ TGL_COPY_PIXEL_TOKEN = 0x0706,
+ TGL_PASS_THROUGH_TOKEN = 0x0700,
- /* Fog */
- TGL_FOG = 0x0B60,
- TGL_FOG_MODE = 0x0B65,
- TGL_FOG_DENSITY = 0x0B62,
- TGL_FOG_COLOR = 0x0B66,
- TGL_FOG_INDEX = 0x0B61,
- TGL_FOG_START = 0x0B63,
- TGL_FOG_END = 0x0B64,
- TGL_LINEAR = 0x2601,
- TGL_EXP = 0x0800,
- TGL_EXP2 = 0x0801,
+ // Fog
+ TGL_FOG = 0x0B60,
+ TGL_FOG_MODE = 0x0B65,
+ TGL_FOG_DENSITY = 0x0B62,
+ TGL_FOG_COLOR = 0x0B66,
+ TGL_FOG_INDEX = 0x0B61,
+ TGL_FOG_START = 0x0B63,
+ TGL_FOG_END = 0x0B64,
+ TGL_LINEAR = 0x2601,
+ TGL_EXP = 0x0800,
+ TGL_EXP2 = 0x0801,
- /* Logic Ops */
- TGL_LOGIC_OP = 0x0BF1,
- TGL_LOGIC_OP_MODE = 0x0BF0,
- TGL_CLEAR = 0x1500,
- TGL_SET = 0x150F,
- TGL_COPY = 0x1503,
- TGL_COPY_INVERTED = 0x150C,
- TGL_NOOP = 0x1505,
- TGL_INVERT = 0x150A,
- TGL_AND = 0x1501,
- TGL_NAND = 0x150E,
- TGL_OR = 0x1507,
- TGL_NOR = 0x1508,
- TGL_XOR = 0x1506,
- TGL_EQUIV = 0x1509,
- TGL_AND_REVERSE = 0x1502,
- TGL_AND_INVERTED = 0x1504,
- TGL_OR_REVERSE = 0x150B,
- TGL_OR_INVERTED = 0x150D,
+ // Logic Ops
+ TGL_LOGIC_OP = 0x0BF1,
+ TGL_LOGIC_OP_MODE = 0x0BF0,
+ TGL_CLEAR = 0x1500,
+ TGL_SET = 0x150F,
+ TGL_COPY = 0x1503,
+ TGL_COPY_INVERTED = 0x150C,
+ TGL_NOOP = 0x1505,
+ TGL_INVERT = 0x150A,
+ TGL_AND = 0x1501,
+ TGL_NAND = 0x150E,
+ TGL_OR = 0x1507,
+ TGL_NOR = 0x1508,
+ TGL_XOR = 0x1506,
+ TGL_EQUIV = 0x1509,
+ TGL_AND_REVERSE = 0x1502,
+ TGL_AND_INVERTED = 0x1504,
+ TGL_OR_REVERSE = 0x150B,
+ TGL_OR_INVERTED = 0x150D,
- /* Stencil */
- TGL_STENCIL_TEST = 0x0B90,
- TGL_STENCIL_WRITEMASK = 0x0B98,
- TGL_STENCIL_BITS = 0x0D57,
- TGL_STENCIL_FUNC = 0x0B92,
- TGL_STENCIL_VALUE_MASK = 0x0B93,
- TGL_STENCIL_REF = 0x0B97,
- TGL_STENCIL_FAIL = 0x0B94,
- TGL_STENCIL_PASS_DEPTH_PASS = 0x0B96,
- TGL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,
- TGL_STENCIL_CLEAR_VALUE = 0x0B91,
- TGL_STENCIL_INDEX = 0x1901,
- TGL_KEEP = 0x1E00,
- TGL_REPLACE = 0x1E01,
- TGL_INCR = 0x1E02,
- TGL_DECR = 0x1E03,
+ // Stencil
+ TGL_STENCIL_TEST = 0x0B90,
+ TGL_STENCIL_WRITEMASK = 0x0B98,
+ TGL_STENCIL_BITS = 0x0D57,
+ TGL_STENCIL_FUNC = 0x0B92,
+ TGL_STENCIL_VALUE_MASK = 0x0B93,
+ TGL_STENCIL_REF = 0x0B97,
+ TGL_STENCIL_FAIL = 0x0B94,
+ TGL_STENCIL_PASS_DEPTH_PASS = 0x0B96,
+ TGL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,
+ TGL_STENCIL_CLEAR_VALUE = 0x0B91,
+ TGL_STENCIL_INDEX = 0x1901,
+ TGL_KEEP = 0x1E00,
+ TGL_REPLACE = 0x1E01,
+ TGL_INCR = 0x1E02,
+ TGL_DECR = 0x1E03,
- /* Buffers, Pixel Drawing/Reading */
- TGL_NONE = 0,
- TGL_LEFT = 0x0406,
- TGL_RIGHT = 0x0407,
- /*TGL_FRONT = 0x0404, */
- /*TGL_BACK = 0x0405, */
- /*TGL_FRONT_AND_BACK = 0x0408, */
- TGL_FRONT_LEFT = 0x0400,
- TGL_FRONT_RIGHT = 0x0401,
- TGL_BACK_LEFT = 0x0402,
- TGL_BACK_RIGHT = 0x0403,
- TGL_AUX0 = 0x0409,
- TGL_AUX1 = 0x040A,
- TGL_AUX2 = 0x040B,
- TGL_AUX3 = 0x040C,
- TGL_COLOR_INDEX = 0x1900,
- TGL_RED = 0x1903,
- TGL_GREEN = 0x1904,
- TGL_BLUE = 0x1905,
- TGL_ALPHA = 0x1906,
- TGL_LUMINANCE = 0x1909,
- TGL_LUMINANCE_ALPHA = 0x190A,
- TGL_ALPHA_BITS = 0x0D55,
- TGL_RED_BITS = 0x0D52,
- TGL_GREEN_BITS = 0x0D53,
- TGL_BLUE_BITS = 0x0D54,
- TGL_INDEX_BITS = 0x0D51,
- TGL_SUBPIXEL_BITS = 0x0D50,
- TGL_AUX_BUFFERS = 0x0C00,
- TGL_READ_BUFFER = 0x0C02,
- TGL_DRAW_BUFFER = 0x0C01,
- TGL_DOUBLEBUFFER = 0x0C32,
- TGL_STEREO = 0x0C33,
- TGL_BITMAP = 0x1A00,
- TGL_COLOR = 0x1800,
- TGL_DEPTH = 0x1801,
- TGL_STENCIL = 0x1802,
- TGL_DITHER = 0x0BD0,
- TGL_RGB = 0x1907,
- TGL_RGBA = 0x1908,
+ // Buffers, Pixel Drawing/Reading
+ TGL_NONE = 0,
+ TGL_LEFT = 0x0406,
+ TGL_RIGHT = 0x0407,
+ //TGL_FRONT = 0x0404,
+ //TGL_BACK = 0x0405,
+ //TGL_FRONT_AND_BACK = 0x0408,
+ TGL_FRONT_LEFT = 0x0400,
+ TGL_FRONT_RIGHT = 0x0401,
+ TGL_BACK_LEFT = 0x0402,
+ TGL_BACK_RIGHT = 0x0403,
+ TGL_AUX0 = 0x0409,
+ TGL_AUX1 = 0x040A,
+ TGL_AUX2 = 0x040B,
+ TGL_AUX3 = 0x040C,
+ TGL_COLOR_INDEX = 0x1900,
+ TGL_RED = 0x1903,
+ TGL_GREEN = 0x1904,
+ TGL_BLUE = 0x1905,
+ TGL_ALPHA = 0x1906,
+ TGL_LUMINANCE = 0x1909,
+ TGL_LUMINANCE_ALPHA = 0x190A,
+ TGL_ALPHA_BITS = 0x0D55,
+ TGL_RED_BITS = 0x0D52,
+ TGL_GREEN_BITS = 0x0D53,
+ TGL_BLUE_BITS = 0x0D54,
+ TGL_INDEX_BITS = 0x0D51,
+ TGL_SUBPIXEL_BITS = 0x0D50,
+ TGL_AUX_BUFFERS = 0x0C00,
+ TGL_READ_BUFFER = 0x0C02,
+ TGL_DRAW_BUFFER = 0x0C01,
+ TGL_DOUBLEBUFFER = 0x0C32,
+ TGL_STEREO = 0x0C33,
+ TGL_BITMAP = 0x1A00,
+ TGL_COLOR = 0x1800,
+ TGL_DEPTH = 0x1801,
+ TGL_STENCIL = 0x1802,
+ TGL_DITHER = 0x0BD0,
+ TGL_RGB = 0x1907,
+ TGL_RGBA = 0x1908,
- /* Implementation limits */
- TGL_MAX_LIST_NESTING = 0x0B31,
- TGL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,
+ // Implementation limits
+ TGL_MAX_LIST_NESTING = 0x0B31,
+ TGL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,
TGL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
TGL_MAX_NAME_STACK_DEPTH = 0x0D37,
TGL_MAX_PROJECTION_STACK_DEPTH = 0x0D38,
- TGL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,
- TGL_MAX_EVAL_ORDER = 0x0D30,
- TGL_MAX_LIGHTS = 0x0D31,
- TGL_MAX_CLIP_PLANES = 0x0D32,
- TGL_MAX_TEXTURE_SIZE = 0x0D33,
- TGL_MAX_PIXEL_MAP_TABLE = 0x0D34,
- TGL_MAX_VIEWPORT_DIMS = 0x0D3A,
- TGL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,
+ TGL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,
+ TGL_MAX_EVAL_ORDER = 0x0D30,
+ TGL_MAX_LIGHTS = 0x0D31,
+ TGL_MAX_CLIP_PLANES = 0x0D32,
+ TGL_MAX_TEXTURE_SIZE = 0x0D33,
+ TGL_MAX_PIXEL_MAP_TABLE = 0x0D34,
+ TGL_MAX_VIEWPORT_DIMS = 0x0D3A,
+ TGL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
- /* Gets */
- TGL_ATTRIB_STACK_DEPTH = 0x0BB0,
- TGL_COLOR_CLEAR_VALUE = 0x0C22,
- TGL_COLOR_WRITEMASK = 0x0C23,
- TGL_CURRENT_INDEX = 0x0B01,
- TGL_CURRENT_COLOR = 0x0B00,
- TGL_CURRENT_NORMAL = 0x0B02,
+ // Gets
+ TGL_ATTRIB_STACK_DEPTH = 0x0BB0,
+ TGL_COLOR_CLEAR_VALUE = 0x0C22,
+ TGL_COLOR_WRITEMASK = 0x0C23,
+ TGL_CURRENT_INDEX = 0x0B01,
+ TGL_CURRENT_COLOR = 0x0B00,
+ TGL_CURRENT_NORMAL = 0x0B02,
TGL_CURRENT_RASTER_COLOR = 0x0B04,
- TGL_CURRENT_RASTER_DISTANCE = 0x0B09,
+ TGL_CURRENT_RASTER_DISTANCE = 0x0B09,
TGL_CURRENT_RASTER_INDEX = 0x0B05,
- TGL_CURRENT_RASTER_POSITION = 0x0B07,
+ TGL_CURRENT_RASTER_POSITION = 0x0B07,
TGL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
TGL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
- TGL_CURRENT_TEXTURE_COORDS = 0x0B03,
- TGL_INDEX_CLEAR_VALUE = 0x0C20,
- TGL_INDEX_MODE = 0x0C30,
- TGL_INDEX_WRITEMASK = 0x0C21,
- TGL_MODELVIEW_MATRIX = 0x0BA6,
- TGL_MODELVIEW_STACK_DEPTH = 0x0BA3,
- TGL_NAME_STACK_DEPTH = 0x0D70,
- TGL_PROJECTION_MATRIX = 0x0BA7,
- TGL_PROJECTION_STACK_DEPTH = 0x0BA4,
- TGL_RENDER_MODE = 0x0C40,
- TGL_RGBA_MODE = 0x0C31,
- TGL_TEXTURE_MATRIX = 0x0BA8,
- TGL_TEXTURE_STACK_DEPTH = 0x0BA5,
- TGL_VIEWPORT = 0x0BA2,
+ TGL_CURRENT_TEXTURE_COORDS = 0x0B03,
+ TGL_INDEX_CLEAR_VALUE = 0x0C20,
+ TGL_INDEX_MODE = 0x0C30,
+ TGL_INDEX_WRITEMASK = 0x0C21,
+ TGL_MODELVIEW_MATRIX = 0x0BA6,
+ TGL_MODELVIEW_STACK_DEPTH = 0x0BA3,
+ TGL_NAME_STACK_DEPTH = 0x0D70,
+ TGL_PROJECTION_MATRIX = 0x0BA7,
+ TGL_PROJECTION_STACK_DEPTH = 0x0BA4,
+ TGL_RENDER_MODE = 0x0C40,
+ TGL_RGBA_MODE = 0x0C31,
+ TGL_TEXTURE_MATRIX = 0x0BA8,
+ TGL_TEXTURE_STACK_DEPTH = 0x0BA5,
+ TGL_VIEWPORT = 0x0BA2,
-
- /* Evaluators */
- TGL_AUTO_NORMAL = 0x0D80,
- TGL_MAP1_COLOR_4 = 0x0D90,
- TGL_MAP1_GRID_DOMAIN = 0x0DD0,
- TGL_MAP1_GRID_SEGMENTS = 0x0DD1,
- TGL_MAP1_INDEX = 0x0D91,
- TGL_MAP1_NORMAL = 0x0D92,
+ // Evaluators
+ TGL_AUTO_NORMAL = 0x0D80,
+ TGL_MAP1_COLOR_4 = 0x0D90,
+ TGL_MAP1_GRID_DOMAIN = 0x0DD0,
+ TGL_MAP1_GRID_SEGMENTS = 0x0DD1,
+ TGL_MAP1_INDEX = 0x0D91,
+ TGL_MAP1_NORMAL = 0x0D92,
TGL_MAP1_TEXTURE_COORD_1 = 0x0D93,
TGL_MAP1_TEXTURE_COORD_2 = 0x0D94,
TGL_MAP1_TEXTURE_COORD_3 = 0x0D95,
TGL_MAP1_TEXTURE_COORD_4 = 0x0D96,
- TGL_MAP1_VERTEX_3 = 0x0D97,
- TGL_MAP1_VERTEX_4 = 0x0D98,
- TGL_MAP2_COLOR_4 = 0x0DB0,
- TGL_MAP2_GRID_DOMAIN = 0x0DD2,
- TGL_MAP2_GRID_SEGMENTS = 0x0DD3,
- TGL_MAP2_INDEX = 0x0DB1,
- TGL_MAP2_NORMAL = 0x0DB2,
+ TGL_MAP1_VERTEX_3 = 0x0D97,
+ TGL_MAP1_VERTEX_4 = 0x0D98,
+ TGL_MAP2_COLOR_4 = 0x0DB0,
+ TGL_MAP2_GRID_DOMAIN = 0x0DD2,
+ TGL_MAP2_GRID_SEGMENTS = 0x0DD3,
+ TGL_MAP2_INDEX = 0x0DB1,
+ TGL_MAP2_NORMAL = 0x0DB2,
TGL_MAP2_TEXTURE_COORD_1 = 0x0DB3,
TGL_MAP2_TEXTURE_COORD_2 = 0x0DB4,
TGL_MAP2_TEXTURE_COORD_3 = 0x0DB5,
TGL_MAP2_TEXTURE_COORD_4 = 0x0DB6,
- TGL_MAP2_VERTEX_3 = 0x0DB7,
- TGL_MAP2_VERTEX_4 = 0x0DB8,
- TGL_COEFF = 0x0A00,
- TGL_DOMAIN = 0x0A02,
- TGL_ORDER = 0x0A01,
+ TGL_MAP2_VERTEX_3 = 0x0DB7,
+ TGL_MAP2_VERTEX_4 = 0x0DB8,
+ TGL_COEFF = 0x0A00,
+ TGL_DOMAIN = 0x0A02,
+ TGL_ORDER = 0x0A01,
- /* Hints */
- TGL_FOG_HINT = 0x0C54,
- TGL_LINE_SMOOTH_HINT = 0x0C52,
+ // Hints
+ TGL_FOG_HINT = 0x0C54,
+ TGL_LINE_SMOOTH_HINT = 0x0C52,
TGL_PERSPECTIVE_CORRECTION_HINT = 0x0C50,
- TGL_POINT_SMOOTH_HINT = 0x0C51,
- TGL_POLYGON_SMOOTH_HINT = 0x0C53,
- TGL_DONT_CARE = 0x1100,
- TGL_FASTEST = 0x1101,
- TGL_NICEST = 0x1102,
+ TGL_POINT_SMOOTH_HINT = 0x0C51,
+ TGL_POLYGON_SMOOTH_HINT = 0x0C53,
+ TGL_DONT_CARE = 0x1100,
+ TGL_FASTEST = 0x1101,
+ TGL_NICEST = 0x1102,
- /* Scissor box */
- TGL_SCISSOR_TEST = 0x0C11,
- TGL_SCISSOR_BOX = 0x0C10,
+ // Scissor box
+ TGL_SCISSOR_TEST = 0x0C11,
+ TGL_SCISSOR_BOX = 0x0C10,
- /* Pixel Mode / Transfer */
- TGL_MAP_COLOR = 0x0D10,
- TGL_MAP_STENCIL = 0x0D11,
- TGL_INDEX_SHIFT = 0x0D12,
- TGL_INDEX_OFFSET = 0x0D13,
- TGL_RED_SCALE = 0x0D14,
- TGL_RED_BIAS = 0x0D15,
- TGL_GREEN_SCALE = 0x0D18,
- TGL_GREEN_BIAS = 0x0D19,
- TGL_BLUE_SCALE = 0x0D1A,
- TGL_BLUE_BIAS = 0x0D1B,
- TGL_ALPHA_SCALE = 0x0D1C,
- TGL_ALPHA_BIAS = 0x0D1D,
- TGL_DEPTH_SCALE = 0x0D1E,
- TGL_DEPTH_BIAS = 0x0D1F,
- TGL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
- TGL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
- TGL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
- TGL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
- TGL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
- TGL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
- TGL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
- TGL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
- TGL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
- TGL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
- TGL_PIXEL_MAP_S_TO_S = 0x0C71,
- TGL_PIXEL_MAP_I_TO_I = 0x0C70,
- TGL_PIXEL_MAP_I_TO_R = 0x0C72,
- TGL_PIXEL_MAP_I_TO_G = 0x0C73,
- TGL_PIXEL_MAP_I_TO_B = 0x0C74,
- TGL_PIXEL_MAP_I_TO_A = 0x0C75,
- TGL_PIXEL_MAP_R_TO_R = 0x0C76,
- TGL_PIXEL_MAP_G_TO_G = 0x0C77,
- TGL_PIXEL_MAP_B_TO_B = 0x0C78,
- TGL_PIXEL_MAP_A_TO_A = 0x0C79,
- TGL_PACK_ALIGNMENT = 0x0D05,
- TGL_PACK_LSB_FIRST = 0x0D01,
- TGL_PACK_ROW_LENGTH = 0x0D02,
- TGL_PACK_SKIP_PIXELS = 0x0D04,
- TGL_PACK_SKIP_ROWS = 0x0D03,
- TGL_PACK_SWAP_BYTES = 0x0D00,
- TGL_UNPACK_ALIGNMENT = 0x0CF5,
- TGL_UNPACK_LSB_FIRST = 0x0CF1,
- TGL_UNPACK_ROW_LENGTH = 0x0CF2,
- TGL_UNPACK_SKIP_PIXELS = 0x0CF4,
- TGL_UNPACK_SKIP_ROWS = 0x0CF3,
- TGL_UNPACK_SWAP_BYTES = 0x0CF0,
- TGL_ZOOM_X = 0x0D16,
- TGL_ZOOM_Y = 0x0D17,
+ // Pixel Mode / Transfer
+ TGL_MAP_COLOR = 0x0D10,
+ TGL_MAP_STENCIL = 0x0D11,
+ TGL_INDEX_SHIFT = 0x0D12,
+ TGL_INDEX_OFFSET = 0x0D13,
+ TGL_RED_SCALE = 0x0D14,
+ TGL_RED_BIAS = 0x0D15,
+ TGL_GREEN_SCALE = 0x0D18,
+ TGL_GREEN_BIAS = 0x0D19,
+ TGL_BLUE_SCALE = 0x0D1A,
+ TGL_BLUE_BIAS = 0x0D1B,
+ TGL_ALPHA_SCALE = 0x0D1C,
+ TGL_ALPHA_BIAS = 0x0D1D,
+ TGL_DEPTH_SCALE = 0x0D1E,
+ TGL_DEPTH_BIAS = 0x0D1F,
+ TGL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
+ TGL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
+ TGL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
+ TGL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
+ TGL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
+ TGL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
+ TGL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
+ TGL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
+ TGL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
+ TGL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
+ TGL_PIXEL_MAP_S_TO_S = 0x0C71,
+ TGL_PIXEL_MAP_I_TO_I = 0x0C70,
+ TGL_PIXEL_MAP_I_TO_R = 0x0C72,
+ TGL_PIXEL_MAP_I_TO_G = 0x0C73,
+ TGL_PIXEL_MAP_I_TO_B = 0x0C74,
+ TGL_PIXEL_MAP_I_TO_A = 0x0C75,
+ TGL_PIXEL_MAP_R_TO_R = 0x0C76,
+ TGL_PIXEL_MAP_G_TO_G = 0x0C77,
+ TGL_PIXEL_MAP_B_TO_B = 0x0C78,
+ TGL_PIXEL_MAP_A_TO_A = 0x0C79,
+ TGL_PACK_ALIGNMENT = 0x0D05,
+ TGL_PACK_LSB_FIRST = 0x0D01,
+ TGL_PACK_ROW_LENGTH = 0x0D02,
+ TGL_PACK_SKIP_PIXELS = 0x0D04,
+ TGL_PACK_SKIP_ROWS = 0x0D03,
+ TGL_PACK_SWAP_BYTES = 0x0D00,
+ TGL_UNPACK_ALIGNMENT = 0x0CF5,
+ TGL_UNPACK_LSB_FIRST = 0x0CF1,
+ TGL_UNPACK_ROW_LENGTH = 0x0CF2,
+ TGL_UNPACK_SKIP_PIXELS = 0x0CF4,
+ TGL_UNPACK_SKIP_ROWS = 0x0CF3,
+ TGL_UNPACK_SWAP_BYTES = 0x0CF0,
+ TGL_ZOOM_X = 0x0D16,
+ TGL_ZOOM_Y = 0x0D17,
- /* Texture mapping */
- TGL_TEXTURE_ENV = 0x2300,
- TGL_TEXTURE_ENV_MODE = 0x2200,
- TGL_TEXTURE_1D = 0x0DE0,
- TGL_TEXTURE_2D = 0x0DE1,
- TGL_TEXTURE_WRAP_S = 0x2802,
- TGL_TEXTURE_WRAP_T = 0x2803,
- TGL_TEXTURE_MAG_FILTER = 0x2800,
- TGL_TEXTURE_MIN_FILTER = 0x2801,
- TGL_TEXTURE_ENV_COLOR = 0x2201,
- TGL_TEXTURE_GEN_S = 0x0C60,
- TGL_TEXTURE_GEN_T = 0x0C61,
- TGL_TEXTURE_GEN_MODE = 0x2500,
+ // Texture mapping
+ TGL_TEXTURE_ENV = 0x2300,
+ TGL_TEXTURE_ENV_MODE = 0x2200,
+ TGL_TEXTURE_1D = 0x0DE0,
+ TGL_TEXTURE_2D = 0x0DE1,
+ TGL_TEXTURE_WRAP_S = 0x2802,
+ TGL_TEXTURE_WRAP_T = 0x2803,
+ TGL_TEXTURE_MAG_FILTER = 0x2800,
+ TGL_TEXTURE_MIN_FILTER = 0x2801,
+ TGL_TEXTURE_ENV_COLOR = 0x2201,
+ TGL_TEXTURE_GEN_S = 0x0C60,
+ TGL_TEXTURE_GEN_T = 0x0C61,
+ TGL_TEXTURE_GEN_MODE = 0x2500,
TGL_TEXTURE_BORDER_COLOR = 0x1004,
- TGL_TEXTURE_WIDTH = 0x1000,
- TGL_TEXTURE_HEIGHT = 0x1001,
- TGL_TEXTURE_BORDER = 0x1005,
- TGL_TEXTURE_COMPONENTS = 0x1003,
- TGL_NEAREST_MIPMAP_NEAREST = 0x2700,
- TGL_NEAREST_MIPMAP_LINEAR = 0x2702,
- TGL_LINEAR_MIPMAP_NEAREST = 0x2701,
+ TGL_TEXTURE_WIDTH = 0x1000,
+ TGL_TEXTURE_HEIGHT = 0x1001,
+ TGL_TEXTURE_BORDER = 0x1005,
+ TGL_TEXTURE_COMPONENTS = 0x1003,
+ TGL_NEAREST_MIPMAP_NEAREST = 0x2700,
+ TGL_NEAREST_MIPMAP_LINEAR = 0x2702,
+ TGL_LINEAR_MIPMAP_NEAREST = 0x2701,
TGL_LINEAR_MIPMAP_LINEAR = 0x2703,
- TGL_OBJECT_LINEAR = 0x2401,
- TGL_OBJECT_PLANE = 0x2501,
- TGL_EYE_LINEAR = 0x2400,
- TGL_EYE_PLANE = 0x2502,
- TGL_SPHERE_MAP = 0x2402,
- TGL_DECAL = 0x2101,
- TGL_MODULATE = 0x2100,
- TGL_NEAREST = 0x2600,
- TGL_REPEAT = 0x2901,
- TGL_CLAMP = 0x2900,
- TGL_S = 0x2000,
- TGL_T = 0x2001,
- TGL_R = 0x2002,
- TGL_Q = 0x2003,
- TGL_TEXTURE_GEN_R = 0x0C62,
- TGL_TEXTURE_GEN_Q = 0x0C63,
+ TGL_OBJECT_LINEAR = 0x2401,
+ TGL_OBJECT_PLANE = 0x2501,
+ TGL_EYE_LINEAR = 0x2400,
+ TGL_EYE_PLANE = 0x2502,
+ TGL_SPHERE_MAP = 0x2402,
+ TGL_DECAL = 0x2101,
+ TGL_MODULATE = 0x2100,
+ TGL_NEAREST = 0x2600,
+ TGL_REPEAT = 0x2901,
+ TGL_CLAMP = 0x2900,
+ TGL_S = 0x2000,
+ TGL_T = 0x2001,
+ TGL_R = 0x2002,
+ TGL_Q = 0x2003,
+ TGL_TEXTURE_GEN_R = 0x0C62,
+ TGL_TEXTURE_GEN_Q = 0x0C63,
- TGL_PROXY_TEXTURE_1D = 0x8063,
- TGL_PROXY_TEXTURE_2D = 0x8064,
- TGL_TEXTURE_PRIORITY = 0x8066,
- TGL_TEXTURE_RESIDENT = 0x8067,
- TGL_TEXTURE_1D_BINDING = 0x8068,
- TGL_TEXTURE_2D_BINDING = 0x8069,
+ TGL_PROXY_TEXTURE_1D = 0x8063,
+ TGL_PROXY_TEXTURE_2D = 0x8064,
+ TGL_TEXTURE_PRIORITY = 0x8066,
+ TGL_TEXTURE_RESIDENT = 0x8067,
+ TGL_TEXTURE_1D_BINDING = 0x8068,
+ TGL_TEXTURE_2D_BINDING = 0x8069,
- /* Internal texture formats */
- TGL_ALPHA4 = 0x803B,
- TGL_ALPHA8 = 0x803C,
- TGL_ALPHA12 = 0x803D,
- TGL_ALPHA16 = 0x803E,
- TGL_LUMINANCE4 = 0x803F,
- TGL_LUMINANCE8 = 0x8040,
- TGL_LUMINANCE12 = 0x8041,
- TGL_LUMINANCE16 = 0x8042,
- TGL_LUMINANCE4_ALPHA4 = 0x8043,
- TGL_LUMINANCE6_ALPHA2 = 0x8044,
- TGL_LUMINANCE8_ALPHA8 = 0x8045,
- TGL_LUMINANCE12_ALPHA4 = 0x8046,
- TGL_LUMINANCE12_ALPHA12 = 0x8047,
- TGL_LUMINANCE16_ALPHA16 = 0x8048,
- TGL_INTENSITY = 0x8049,
- TGL_INTENSITY4 = 0x804A,
- TGL_INTENSITY8 = 0x804B,
- TGL_INTENSITY12 = 0x804C,
- TGL_INTENSITY16 = 0x804D,
- TGL_R3_G3_B2 = 0x2A10,
- TGL_RGB4 = 0x804F,
- TGL_RGB5 = 0x8050,
- TGL_RGB8 = 0x8051,
- TGL_RGB10 = 0x8052,
- TGL_RGB12 = 0x8053,
- TGL_RGB16 = 0x8054,
- TGL_RGBA2 = 0x8055,
- TGL_RGBA4 = 0x8056,
- TGL_RGB5_A1 = 0x8057,
- TGL_RGBA8 = 0x8058,
- TGL_RGB10_A2 = 0x8059,
- TGL_RGBA12 = 0x805A,
- TGL_RGBA16 = 0x805B,
+ // Internal texture formats
+ TGL_ALPHA4 = 0x803B,
+ TGL_ALPHA8 = 0x803C,
+ TGL_ALPHA12 = 0x803D,
+ TGL_ALPHA16 = 0x803E,
+ TGL_LUMINANCE4 = 0x803F,
+ TGL_LUMINANCE8 = 0x8040,
+ TGL_LUMINANCE12 = 0x8041,
+ TGL_LUMINANCE16 = 0x8042,
+ TGL_LUMINANCE4_ALPHA4 = 0x8043,
+ TGL_LUMINANCE6_ALPHA2 = 0x8044,
+ TGL_LUMINANCE8_ALPHA8 = 0x8045,
+ TGL_LUMINANCE12_ALPHA4 = 0x8046,
+ TGL_LUMINANCE12_ALPHA12 = 0x8047,
+ TGL_LUMINANCE16_ALPHA16 = 0x8048,
+ TGL_INTENSITY = 0x8049,
+ TGL_INTENSITY4 = 0x804A,
+ TGL_INTENSITY8 = 0x804B,
+ TGL_INTENSITY12 = 0x804C,
+ TGL_INTENSITY16 = 0x804D,
+ TGL_R3_G3_B2 = 0x2A10,
+ TGL_RGB4 = 0x804F,
+ TGL_RGB5 = 0x8050,
+ TGL_RGB8 = 0x8051,
+ TGL_RGB10 = 0x8052,
+ TGL_RGB12 = 0x8053,
+ TGL_RGB16 = 0x8054,
+ TGL_RGBA2 = 0x8055,
+ TGL_RGBA4 = 0x8056,
+ TGL_RGB5_A1 = 0x8057,
+ TGL_RGBA8 = 0x8058,
+ TGL_RGB10_A2 = 0x8059,
+ TGL_RGBA12 = 0x805A,
+ TGL_RGBA16 = 0x805B,
- /* Utility */
- TGL_VENDOR = 0x1F00,
- TGL_RENDERER = 0x1F01,
- TGL_VERSION = 0x1F02,
- TGL_EXTENSIONS = 0x1F03,
+ // Utility
+ TGL_VENDOR = 0x1F00,
+ TGL_RENDERER = 0x1F01,
+ TGL_VERSION = 0x1F02,
+ TGL_EXTENSIONS = 0x1F03,
- /* Errors */
- TGL_INVALID_VALUE = 0x0501,
- TGL_INVALID_ENUM = 0x0500,
- TGL_INVALID_OPERATION = 0x0502,
- TGL_STACK_OVERFLOW = 0x0503,
- TGL_STACK_UNDERFLOW = 0x0504,
- TGL_OUT_OF_MEMORY = 0x0505,
+ // Errors
+ TGL_INVALID_VALUE = 0x0501,
+ TGL_INVALID_ENUM = 0x0500,
+ TGL_INVALID_OPERATION = 0x0502,
+ TGL_STACK_OVERFLOW = 0x0503,
+ TGL_STACK_UNDERFLOW = 0x0504,
+ TGL_OUT_OF_MEMORY = 0x0505,
- /*
- * 1.0 Extensions
- */
- /* TGL_EXT_blend_minmax and TGL_EXT_blend_color */
- TGL_CONSTANT_COLOR_EXT = 0x8001,
- TGL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
- TGL_CONSTANT_ALPHA_EXT = 0x8003,
- TGL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
- TGL_BLEND_EQUATION_EXT = 0x8009,
- TGL_MIN_EXT = 0x8007,
- TGL_MAX_EXT = 0x8008,
- TGL_FUNC_ADD_EXT = 0x8006,
- TGL_FUNC_SUBTRACT_EXT = 0x800A,
+ // 1.0 Extensions
+
+ // TGL_EXT_blend_minmax and TGL_EXT_blend_color
+ TGL_CONSTANT_COLOR_EXT = 0x8001,
+ TGL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
+ TGL_CONSTANT_ALPHA_EXT = 0x8003,
+ TGL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
+ TGL_BLEND_EQUATION_EXT = 0x8009,
+ TGL_MIN_EXT = 0x8007,
+ TGL_MAX_EXT = 0x8008,
+ TGL_FUNC_ADD_EXT = 0x8006,
+ TGL_FUNC_SUBTRACT_EXT = 0x800A,
TGL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
- TGL_BLEND_COLOR_EXT = 0x8005,
+ TGL_BLEND_COLOR_EXT = 0x8005,
- /* TGL_EXT_polygon_offset */
- TGL_POLYGON_OFFSET_EXT = 0x8037,
- TGL_POLYGON_OFFSET_FACTOR_EXT = 0x8038,
- TGL_POLYGON_OFFSET_BIAS_EXT = 0x8039,
+ // TGL_EXT_polygon_offset
+ TGL_POLYGON_OFFSET_EXT = 0x8037,
+ TGL_POLYGON_OFFSET_FACTOR_EXT = 0x8038,
+ TGL_POLYGON_OFFSET_BIAS_EXT = 0x8039,
- /* TGL_EXT_vertex_array */
- TGL_VERTEX_ARRAY_EXT = 0x8074,
- TGL_NORMAL_ARRAY_EXT = 0x8075,
- TGL_COLOR_ARRAY_EXT = 0x8076,
- TGL_INDEX_ARRAY_EXT = 0x8077,
- TGL_TEXTURE_COORD_ARRAY_EXT = 0x8078,
- TGL_EDGE_FLAG_ARRAY_EXT = 0x8079,
- TGL_VERTEX_ARRAY_SIZE_EXT = 0x807A,
- TGL_VERTEX_ARRAY_TYPE_EXT = 0x807B,
- TGL_VERTEX_ARRAY_STRIDE_EXT = 0x807C,
- TGL_VERTEX_ARRAY_COUNT_EXT = 0x807D,
- TGL_NORMAL_ARRAY_TYPE_EXT = 0x807E,
- TGL_NORMAL_ARRAY_STRIDE_EXT = 0x807F,
- TGL_NORMAL_ARRAY_COUNT_EXT = 0x8080,
+ // TGL_EXT_vertex_array
+ TGL_VERTEX_ARRAY_EXT = 0x8074,
+ TGL_NORMAL_ARRAY_EXT = 0x8075,
+ TGL_COLOR_ARRAY_EXT = 0x8076,
+ TGL_INDEX_ARRAY_EXT = 0x8077,
+ TGL_TEXTURE_COORD_ARRAY_EXT = 0x8078,
+ TGL_EDGE_FLAG_ARRAY_EXT = 0x8079,
+ TGL_VERTEX_ARRAY_SIZE_EXT = 0x807A,
+ TGL_VERTEX_ARRAY_TYPE_EXT = 0x807B,
+ TGL_VERTEX_ARRAY_STRIDE_EXT = 0x807C,
+ TGL_VERTEX_ARRAY_COUNT_EXT = 0x807D,
+ TGL_NORMAL_ARRAY_TYPE_EXT = 0x807E,
+ TGL_NORMAL_ARRAY_STRIDE_EXT = 0x807F,
+ TGL_NORMAL_ARRAY_COUNT_EXT = 0x8080,
TGL_COLOR_ARRAY_SIZE_EXT = 0x8081,
TGL_COLOR_ARRAY_TYPE_EXT = 0x8082,
- TGL_COLOR_ARRAY_STRIDE_EXT = 0x8083,
- TGL_COLOR_ARRAY_COUNT_EXT = 0x8084,
+ TGL_COLOR_ARRAY_STRIDE_EXT = 0x8083,
+ TGL_COLOR_ARRAY_COUNT_EXT = 0x8084,
TGL_INDEX_ARRAY_TYPE_EXT = 0x8085,
- TGL_INDEX_ARRAY_STRIDE_EXT = 0x8086,
- TGL_INDEX_ARRAY_COUNT_EXT = 0x8087,
- TGL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
- TGL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
- TGL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A,
- TGL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B,
+ TGL_INDEX_ARRAY_STRIDE_EXT = 0x8086,
+ TGL_INDEX_ARRAY_COUNT_EXT = 0x8087,
+ TGL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
+ TGL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
+ TGL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
+ TGL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B,
TGL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
TGL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
TGL_VERTEX_ARRAY_POINTER_EXT = 0x808E,
TGL_NORMAL_ARRAY_POINTER_EXT = 0x808F,
- TGL_COLOR_ARRAY_POINTER_EXT = 0x8090,
- TGL_INDEX_ARRAY_POINTER_EXT = 0x8091,
- TGL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092,
+ TGL_COLOR_ARRAY_POINTER_EXT = 0x8090,
+ TGL_INDEX_ARRAY_POINTER_EXT = 0x8091,
+ TGL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
TGL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093
-
};
enum {
- TGL_CURRENT_BIT = 0x00000001,
- TGL_POINT_BIT = 0x00000002,
- TGL_LINE_BIT = 0x00000004,
- TGL_POLYGON_BIT = 0x00000008,
+ TGL_CURRENT_BIT = 0x00000001,
+ TGL_POINT_BIT = 0x00000002,
+ TGL_LINE_BIT = 0x00000004,
+ TGL_POLYGON_BIT = 0x00000008,
TGL_POLYGON_STIPPLE_BIT = 0x00000010,
- TGL_PIXEL_MODE_BIT = 0x00000020,
+ TGL_PIXEL_MODE_BIT = 0x00000020,
TGL_LIGHTING_BIT = 0x00000040,
- TGL_FOG_BIT = 0x00000080,
+ TGL_FOG_BIT = 0x00000080,
TGL_DEPTH_BUFFER_BIT = 0x00000100,
TGL_ACCUM_BUFFER_BIT = 0x00000200,
TGL_STENCIL_BUFFER_BIT = 0x00000400,
TGL_VIEWPORT_BIT = 0x00000800,
- TGL_TRANSFORM_BIT = 0x00001000,
- TGL_ENABLE_BIT = 0x00002000,
+ TGL_TRANSFORM_BIT = 0x00001000,
+ TGL_ENABLE_BIT = 0x00002000,
TGL_COLOR_BUFFER_BIT = 0x00004000,
- TGL_HINT_BIT = 0x00008000,
- TGL_EVAL_BIT = 0x00010000,
- TGL_LIST_BIT = 0x00020000,
- TGL_TEXTURE_BIT = 0x00040000,
- TGL_SCISSOR_BIT = 0x00080000,
- TGL_ALL_ATTRIB_BITS = 0x000fffff
+ TGL_HINT_BIT = 0x00008000,
+ TGL_EVAL_BIT = 0x00010000,
+ TGL_LIST_BIT = 0x00020000,
+ TGL_TEXTURE_BIT = 0x00040000,
+ TGL_SCISSOR_BIT = 0x00080000,
+ TGL_ALL_ATTRIB_BITS = 0x000fffff
};
-/* some types */
+// some types
-typedef int TGLenum;
-typedef void TGLvoid;
+typedef int TGLenum;
+typedef void TGLvoid;
typedef unsigned char TGLboolean;
-typedef signed char TGLbyte; /* 1-byte signed */
-typedef short TGLshort; /* 2-byte signed */
-typedef int TGLint; /* 4-byte signed */
-typedef unsigned char TGLubyte; /* 1-byte unsigned */
-typedef unsigned short TGLushort; /* 2-byte unsigned */
-typedef unsigned int TGLuint; /* 4-byte unsigned */
-typedef float TGLfloat; /* single precision float */
-typedef double TGLdouble; /* double precision float */
-typedef int TGLsizei;
+typedef signed char TGLbyte; // 1-byte signed
+typedef short TGLshort; // 2-byte signed
+typedef int TGLint; // 4-byte signed
+typedef unsigned char TGLubyte; // 1-byte unsigned
+typedef unsigned short TGLushort; // 2-byte unsigned
+typedef unsigned int TGLuint; // 4-byte unsigned
+typedef float TGLfloat; // single precision float
+typedef double TGLdouble; // double precision float
+typedef int TGLsizei;
-/* functions */
+// functions
void tglEnable(int code);
void tglDisable(int code);
@@ -681,27 +678,27 @@
void tglEnd(void);
#define PROTO_GL1(name) \
-void tgl ## name ## 1f(float); \
-void tgl ## name ## 1d(double); \
-void tgl ## name ## 1fv(float *); \
+void tgl ## name ## 1f(float); \
+void tgl ## name ## 1d(double); \
+void tgl ## name ## 1fv(float *); \
void tgl ## name ## 1dv(double *);
-#define PROTO_GL2(name) \
-void tgl ## name ## 2f(float ,float); \
-void tgl ## name ## 2d(double ,double); \
+#define PROTO_GL2(name) \
+void tgl ## name ## 2f(float, float); \
+void tgl ## name ## 2d(double, double); \
void tgl ## name ## 2fv(float *); \
void tgl ## name ## 2dv(double *);
-#define PROTO_GL3(name) \
-void tgl ## name ## 3f(float ,float ,float); \
-void tgl ## name ## 3d(double ,double ,double); \
-void tgl ## name ## 3fv(float *); \
+#define PROTO_GL3(name) \
+void tgl ## name ## 3f(float, float, float); \
+void tgl ## name ## 3d(double, double, double); \
+void tgl ## name ## 3fv(float *); \
void tgl ## name ## 3dv(double *);
-#define PROTO_GL4(name) \
-void tgl ## name ## 4f(float ,float ,float, float ); \
-void tgl ## name ## 4d(double ,double ,double, double ); \
-void tgl ## name ## 4fv(float *); \
+#define PROTO_GL4(name) \
+void tgl ## name ## 4f(float, float, float, float); \
+void tgl ## name ## 4d(double, double, double, double); \
+void tgl ## name ## 4fv(float *); \
void tgl ## name ## 4dv(double *);
PROTO_GL2(Vertex)
@@ -720,86 +717,86 @@
void tglEdgeFlag(int flag);
-/* matrix */
+// matrix
void tglMatrixMode(int mode);
void tglLoadMatrixf(const float *m);
void tglLoadIdentity(void);
void tglMultMatrixf(const float *m);
void tglPushMatrix(void);
void tglPopMatrix(void);
-void tglRotatef(float angle,float x,float y,float z);
-void tglTranslatef(float x,float y,float z);
-void tglScalef(float x,float y,float z);
+void tglRotatef(float angle, float x, float y, float z);
+void tglTranslatef(float x, float y, float z);
+void tglScalef(float x, float y, float z);
-void tglViewport(int x,int y,int width,int height);
-void tglFrustum(double left,double right,double bottom,double top,
- double nearv,double farv);
+void tglViewport(int x, int y, int width, int height);
+void tglFrustum(double left, double right, double bottom, double top,
+ double nearv, double farv);
-/* lists */
+// lists
unsigned int tglGenLists(int range);
int tglIsList(unsigned int list);
-void tglNewList(unsigned int list,int mode);
+void tglNewList(unsigned int list, int mode);
void tglEndList(void);
void tglCallList(unsigned int list);
-/* clear */
+// clear
void tglClear(int mask);
-void tglClearColor(float r,float g,float b,float a);
+void tglClearColor(float r, float g, float b, float a);
void tglClearDepth(double depth);
-/* selection */
+// selection
int tglRenderMode(int mode);
-void tglSelectBuffer(int size,unsigned int *buf);
+void tglSelectBuffer(int size, unsigned int *buf);
void tglInitNames(void);
void tglPushName(unsigned int name);
void tglPopName(void);
void tglLoadName(unsigned int name);
-/* textures */
+// textures
void tglGenTextures(int n, unsigned int *textures);
void tglDeleteTextures(int n, const unsigned int *textures);
-void tglBindTexture(int target,int texture);
-void tglTexImage2D( int target, int level, int components,
- int width, int height, int border,
+void tglBindTexture(int target, int texture);
+void tglTexImage2D(int target, int level, int components,
+ int width, int height, int border,
int format, int type, void *pixels);
-void tglTexEnvi(int target,int pname,int param);
-void tglTexParameteri(int target,int pname,int param);
-void tglPixelStorei(int pname,int param);
+void tglTexEnvi(int target, int pname, int param);
+void tglTexParameteri(int target, int pname, int param);
+void tglPixelStorei(int pname, int param);
-/* lighting */
+// lighting
-void tglMaterialfv(int mode,int type,float *v);
-void tglMaterialf(int mode,int type,float v);
-void tglColorMaterial(int mode,int type);
+void tglMaterialfv(int mode, int type, float *v);
+void tglMaterialf(int mode, int type, float v);
+void tglColorMaterial(int mode, int type);
-void tglLightfv(int light,int type,float *v);
-void tglLightf(int light,int type,float v);
-void tglLightModeli(int pname,int param);
-void tglLightModelfv(int pname,float *param);
+void tglLightfv(int light, int type, float *v);
+void tglLightf(int light, int type, float v);
+void tglLightModeli(int pname, int param);
+void tglLightModelfv(int pname, float *param);
-/* misc */
+// misc
void tglFlush(void);
-void tglHint(int target,int mode);
-void tglGetIntegerv(int pname,int *params);
+void tglHint(int target, int mode);
+void tglGetIntegerv(int pname, int *params);
void tglGetFloatv(int pname, float *v);
void tglFrontFace(int mode);
-/* opengl 1.2 arrays */
+// opengl 1.2 arrays
void tglEnableClientState(TGLenum array);
void tglDisableClientState(TGLenum array);
void tglArrayElement(TGLint i);
-void tglVertexPointer(TGLint size, TGLenum type, TGLsizei stride,
+void tglVertexPointer(TGLint size, TGLenum type, TGLsizei stride,
const TGLvoid *pointer);
-void tglColorPointer(TGLint size, TGLenum type, TGLsizei stride,
+void tglColorPointer(TGLint size, TGLenum type, TGLsizei stride,
const TGLvoid *pointer);
-void tglNormalPointer(TGLenum type, TGLsizei stride,
+void tglNormalPointer(TGLenum type, TGLsizei stride,
const TGLvoid *pointer);
-void tglTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride,
+void tglTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride,
const TGLvoid *pointer);
-/* opengl 1.2 polygon offset */
+// opengl 1.2 polygon offset
void tglPolygonOffset(TGLfloat factor, TGLfloat units);
void tglDebug(int mode);
Modified: residual/trunk/tinygl/image_util.cpp
===================================================================
--- residual/trunk/tinygl/image_util.cpp 2006-05-16 10:02:27 UTC (rev 22488)
+++ residual/trunk/tinygl/image_util.cpp 2006-05-16 14:52:36 UTC (rev 22489)
@@ -1,120 +1,107 @@
+
#include "tinygl/zgl.h"
-/*
- * image conversion
- */
+// image conversion
-void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb,
- int xsize,int ysize)
-{
- int i,n;
- unsigned char *p;
+void gl_convertRGB_to_5R6G5B(unsigned short *pixmap, unsigned char *rgb,
+ int xsize, int ysize) {
+ int i, n;
+ unsigned char *p;
- p=rgb;
- n=xsize*ysize;
- for(i=0;i<n;i++) {
- pixmap[i]=((p[0]&0xF8)<<8) | ((p[1]&0xFC)<<3) | ((p[2]&0xF8)>>3);
- p+=3;
- }
+ p = rgb;
+ n = xsize * ysize;
+ for (i = 0; i < n; i++) {
+ pixmap[i] = ((p[0] & 0xF8) << 8) | ((p[1] & 0xFC) << 3) | ((p[2] & 0xF8) >> 3);
+ p += 3;
+ }
}
-/*
- * linear interpolation with xf,yf normalized to 2^16
- */
+// linear interpolation with xf, yf normalized to 2^16
#define INTERP_NORM_BITS 16
#define INTERP_NORM (1 << INTERP_NORM_BITS)
-static inline int interpolate(int v00,int v01,int v10,int xf,int yf)
-{
- return v00+(((v01-v00)*xf + (v10-v00)*yf) >> INTERP_NORM_BITS);
+static inline int interpolate(int v00, int v01, int v10, int xf, int yf) {
+ return v00 + (((v01 - v00) * xf + (v10 - v00) * yf) >> INTERP_NORM_BITS);
}
+// TODO: more accurate resampling
-/*
- * TODO: more accurate resampling
- */
+void gl_resizeImage(unsigned char *dest, int xsize_dest, int ysize_dest,
+ unsigned char *src, int xsize_src, int ysize_src) {
+ unsigned char *pix, *pix_src;
+ float x1, y1, x1inc, y1inc;
+ int xi, yi, j, xf, yf, x, y;
-void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest,
- unsigned char *src,int xsize_src,int ysize_src)
-{
- unsigned char *pix,*pix_src;
- float x1,y1,x1inc,y1inc;
- int xi,yi,j,xf,yf,x,y;
-
- pix=dest;
- pix_src=src;
+ pix = dest;
+ pix_src = src;
- x1inc=(float) (xsize_src - 1) / (float) (xsize_dest - 1);
- y1inc=(float) (ysize_src - 1) / (float) (ysize_dest - 1);
+ x1inc = (float)(xsize_src - 1) / (float)(xsize_dest - 1);
+ y1inc = (float)(ysize_src - 1) / (float)(ysize_dest - 1);
- y1=0;
- for(y=0;y<ysize_dest;y++) {
- x1=0;
- for(x=0;x<xsize_dest;x++) {
- xi=(int) x1;
- yi=(int) y1;
- xf=(int) ((x1 - floor(x1)) * INTERP_NORM);
- yf=(int) ((y1 - floor(y1)) * INTERP_NORM);
-
- if ((xf+yf) <= INTERP_NORM) {
- for(j=0;j<3;j++) {
- pix[j]=interpolate(pix_src[(yi*xsize_src+xi)*3+j],
- pix_src[(yi*xsize_src+xi+1)*3+j],
- pix_src[((yi+1)*xsize_src+xi)*3+j],
- xf,yf);
+ y1 = 0;
+ for (y = 0; y < ysize_dest; y++) {
+ x1 = 0;
+ for (x = 0; x < xsize_dest; x++) {
+ xi = (int)x1;
+ yi = (int)y1;
+ xf = (int)((x1 - floor(x1)) * INTERP_NORM);
+ yf = (int)((y1 - floor(y1)) * INTERP_NORM);
+
+ if ((xf + yf) <= INTERP_NORM) {
+ for (j = 0; j < 3; j++) {
+ pix[j] = interpolate(pix_src[(yi * xsize_src + xi) * 3 + j],
+ pix_src[(yi * xsize_src + xi + 1) * 3 + j],
+ pix_src[((yi + 1) * xsize_src + xi) * 3 + j],
+ xf, yf);
+ }
+ } else {
+ xf = INTERP_NORM - xf;
+ yf = INTERP_NORM - yf;
+ for (j = 0; j < 3; j++) {
+ pix[j] = interpolate(pix_src[((yi + 1) * xsize_src + xi + 1) * 3 + j],
+ pix_src[((yi + 1) * xsize_src + xi) * 3 + j],
+ pix_src[(yi * xsize_src + xi + 1) * 3 + j],
+ xf, yf);
+ }
+ }
+ pix += 3;
+ x1 += x1inc;
+ }
+ y1 += y1inc;
}
- } else {
- xf=INTERP_NORM - xf;
- yf=INTERP_NORM - yf;
- for(j=0;j<3;j++) {
- pix[j]=interpolate(pix_src[((yi+1)*xsize_src+xi+1)*3+j],
- pix_src[((yi+1)*xsize_src+xi)*3+j],
- pix_src[(yi*xsize_src+xi+1)*3+j],
- xf,yf);
- }
- }
-
- pix+=3;
- x1+=x1inc;
- }
- y1+=y1inc;
- }
}
#define FRAC_BITS 16
-/* resizing with no interlating nor nearest pixel */
+// resizing with no interlating nor nearest pixel
+void gl_resizeImageNoInterpolate(unsigned char *dest, int xsize_dest, int ysize_dest,
+ unsigned char *src, int xsize_src, int ysize_src) {
+ unsigned char *pix, *pix_src, *pix1;
+ int x1, y1, x1inc, y1inc;
+ int xi, yi, x, y;
-void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest,
- unsigned char *src,int xsize_src,int ysize_src)
-{
- unsigned char *pix,*pix_src,*pix1;
- int x1,y1,x1inc,y1inc;
@@ Diff output truncated at 100000 characters. @@
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list