switch build system to Tup

git-svn-id: svn://kolibrios.org@5098 a494cfbc-eb01-0410-851d-a64ba20cac60

programs/develop/libraries/TinyGL/src/Makefile

@@ -0,0 +1,38 @@
+include ../config.mk
+
+OBJS= clip.o vertex.o api.o list.o init.o matrix.o texture.o \
+      misc.o clear.o light.o select.o get.o error.o \
+      zbuffer.o zline.o zdither.o ztriangle.o \
+      zmath.o image_util.o msghandling.o \
+      arrays.o specbuf.o glu.o kosgl.o
+	        
+
+INCLUDES = -I$(TINYGL)/include -I$(MENUETDEV)/include
+LIB = libTinyGL.a
+
+all: $(LIB)
+
+$(LIB): $(OBJS)
+	rm -f $(LIB)
+	ar rcs $(LIB) $(OBJS)
+	copy /y $@ $(TINYGL)\lib
+	del $(LIB)
+
+clean:
+	rm -f *~ *.o *.a $(TINYGL)/$(LIB)
+
+.c.o:
+	$(CC) $(CFLAGS) $(INCLUDES) -c $*.c
+
+clip.o: zgl.h zfeatures.h
+vertex.o: zgl.h zfeatures.h
+light.o: zgl.h zfeatures.h
+matrix.o: zgl.h zfeatures.h
+list.o: zgl.h opinfo.h zfeatures.h
+arrays.c: zgl.h zfeatures.h
+specbuf.o: zgl.h zfeatures.h
+glx.o: zgl.h zfeatures.h
+nglx.o: zgl.h zfeatures.h
+zline.o: zgl.h zfeatures.h zline.h
+ztriangle.o: ztriangle.c ztriangle.h zgl.h zfeatures.h
+	$(CC) $(CFLAGS) $(INCLUDES) -c $*.c

programs/develop/libraries/TinyGL/src/Tupfile.lua

@@ -0,0 +1,7 @@
+if tup.getconfig("NO_GCC") ~= "" then return end
+HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR")
+tup.include(HELPERDIR .. "/use_gcc.lua")
+tup.include(HELPERDIR .. "/use_menuetlibc.lua")
+INCLUDES = INCLUDES .. " -I../include"
+compile_gcc("*.c")
+tup.rule(OBJS, "kos32-ar rcs %o %f", {"../lib/libTinyGL.a", "../<>"})

programs/develop/libraries/TinyGL/src/api.c

@@ -0,0 +1,666 @@
+#include "zgl.h"
+#include <stdio.h>
+/* glVertex */
+
+void glVertex4f(float x,float y,float z,float w)
+{
+  GLParam p[5];
+
+  p[0].op=OP_Vertex;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  p[4].f=w;
+
+  gl_add_op(p);
+}
+
+void glVertex2f(float x,float y) 
+{
+  glVertex4f(x,y,0,1);
+}
+
+void glVertex3f(float x,float y,float z) 
+{
+  glVertex4f(x,y,z,1);
+}
+
+void glVertex3fv(float *v) 
+{
+  glVertex4f(v[0],v[1],v[2],1);
+}
+
+/* glNormal */
+
+void glNormal3f(float x,float y,float z)
+{
+  GLParam p[4];
+
+  p[0].op=OP_Normal;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+
+  gl_add_op(p);
+}
+
+void glNormal3fv(float *v) 
+{
+  glNormal3f(v[0],v[1],v[2]);
+}
+
+/* glColor */
+
+void glColor4f(float r,float g,float b,float a)
+{
+  GLParam p[8];
+
+  p[0].op=OP_Color;
+  p[1].f=b;
+  p[2].f=g;
+  p[3].f=r;
+  p[4].f=a;
+  /* direct convertion to integer to go faster if no shading */
+  RGBFtoRGBI(r,g,b,p[7].ui,p[6].ui,p[5].ui);                      
+  gl_add_op(p); 
+}
+
+void glColor4fv(float *v)
+{
+  GLParam p[8];
+
+  p[0].op=OP_Color;
+  p[1].f=v[2];
+  p[2].f=v[1];
+  p[3].f=v[0];
+  p[4].f=v[3];
+  /* direct convertion to integer to go faster if no shading */
+  p[5].ui = (unsigned int) (v[2] * (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[0] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + 
+                            ZB_POINT_BLUE_MIN);
+  gl_add_op(p);
+}
+
+void glColor3f(float x,float y,float z) 
+{
+  glColor4f(x,y,z,1);
+}
+
+void glColor3fv(float *v) 
+{
+  glColor4f(v[0],v[1],v[2],1);
+}
+
+
+/* TexCoord */
+
+void glTexCoord4f(float s,float t,float r,float q)
+{
+  GLParam p[5];
+
+  p[0].op=OP_TexCoord;
+  p[1].f=s;
+  p[2].f=t;
+  p[3].f=r;
+  p[4].f=q;
+
+  gl_add_op(p);
+}
+
+void glTexCoord2f(float s,float t)
+{
+  glTexCoord4f(s,t,0,1);
+}
+
+void glTexCoord2fv(float *v)
+{
+  glTexCoord4f(v[0],v[1],0,1);
+}
+
+void glEdgeFlag(int flag)
+{
+  GLParam p[2];
+
+  p[0].op=OP_EdgeFlag;
+  p[1].i=flag;
+
+  gl_add_op(p);
+}
+
+/* misc */
+
+void glShadeModel(int mode)
+{
+  GLParam p[2];
+
+  assert(mode == GL_FLAT || mode == GL_SMOOTH);
+
+  p[0].op=OP_ShadeModel;
+  p[1].i=mode;
+
+  gl_add_op(p);
+}
+
+void glCullFace(int mode)
+{
+  GLParam p[2];
+
+  assert(mode == GL_BACK || 
+         mode == GL_FRONT || 
+         mode == GL_FRONT_AND_BACK);
+
+  p[0].op=OP_CullFace;
+  p[1].i=mode;
+
+  gl_add_op(p);
+}
+
+void glFrontFace(int mode)
+{
+  GLParam p[2];
+
+  assert(mode == GL_CCW || mode == GL_CW);
+
+  mode = (mode != GL_CCW);
+
+  p[0].op=OP_FrontFace;
+  p[1].i=mode;
+
+  gl_add_op(p);
+}
+
+void glPolygonMode(int face,int mode)
+{
+  GLParam p[3];
+
+  assert(face == GL_BACK || 
+         face == GL_FRONT || 
+         face == GL_FRONT_AND_BACK);
+  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
+
+  p[0].op=OP_PolygonMode;
+  p[1].i=face;
+  p[2].i=mode;
+
+  gl_add_op(p);
+}
+
+
+/* glEnable / glDisable */
+
+void glEnable(int cap)
+{
+  GLParam p[3];
+
+  p[0].op=OP_EnableDisable;
+  p[1].i=cap;
+  p[2].i=1;
+
+  gl_add_op(p);
+}
+
+void glDisable(int cap)
+{
+  GLParam p[3];
+
+  p[0].op=OP_EnableDisable;
+  p[1].i=cap;
+  p[2].i=0;
+
+  gl_add_op(p);
+}
+
+/* glBegin / glEnd */
+
+void glBegin(int mode)
+{
+  GLParam p[2];
+
+  p[0].op=OP_Begin;
+  p[1].i=mode;
+
+  gl_add_op(p);
+}
+
+void glEnd(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_End;
+
+  gl_add_op(p);
+}
+
+/* matrix */
+
+void glMatrixMode(int mode)
+{
+  GLParam p[2];
+
+  p[0].op=OP_MatrixMode;
+  p[1].i=mode;
+
+  gl_add_op(p);
+}
+
+void glLoadMatrixf(const float *m)
+{
+  GLParam p[17];
+  int i;
+
+  p[0].op=OP_LoadMatrix;
+  for(i=0;i<16;i++) p[i+1].f=m[i];
+
+  gl_add_op(p);
+}
+
+void glLoadIdentity(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_LoadIdentity;
+
+  gl_add_op(p);
+}
+
+void glMultMatrixf(const float *m)
+{
+  GLParam p[17];
+  int i;
+
+  p[0].op=OP_MultMatrix;
+  for(i=0;i<16;i++) p[i+1].f=m[i];
+
+  gl_add_op(p);
+}
+
+void glPushMatrix(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_PushMatrix;
+
+  gl_add_op(p);
+}
+
+void glPopMatrix(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_PopMatrix;
+
+  gl_add_op(p);
+}
+
+void glRotatef(float angle,float x,float y,float z)
+{
+  GLParam p[5];
+
+  p[0].op=OP_Rotate;
+  p[1].f=angle;
+  p[2].f=x;
+  p[3].f=y;
+  p[4].f=z;
+
+  gl_add_op(p);
+}
+
+void glTranslatef(float x,float y,float z)
+{
+  GLParam p[4];
+
+  p[0].op=OP_Translate;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+
+  gl_add_op(p);
+}
+
+void glScalef(float x,float y,float z)
+{
+  GLParam p[4];
+
+  p[0].op=OP_Scale;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+
+  gl_add_op(p);
+}
+
+
+void glViewport(int x,int y,int width,int height)
+{
+  GLParam p[5];
+
+  p[0].op=OP_Viewport;
+  p[1].i=x;
+  p[2].i=y;
+  p[3].i=width;
+  p[4].i=height;
+
+  gl_add_op(p);
+}
+
+void glFrustum(double left,double right,double bottom,double top,
+               double near,double farv)
+{
+  GLParam p[7];
+
+  p[0].op=OP_Frustum;
+  p[1].f=left;
+  p[2].f=right;
+  p[3].f=bottom;
+  p[4].f=top;
+  p[5].f=near;
+  p[6].f=farv;
+
+  gl_add_op(p);
+}
+
+/* lightening */
+
+void glMaterialfv(int mode,int type,float *v)
+{
+  GLParam p[7];
+  int i,n;
+
+  assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
+
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  n=4;
+  if (type == GL_SHININESS) n=1;
+
+  p[3].f=v[2];
+  p[4].f=v[1];
+  p[5].f=v[0];
+  p[6].f=v[3];
+
+  for(i=n;i<4;i++) p[3+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glMaterialf(int mode,int type,float v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glColorMaterial(int mode,int type)
+{
+  GLParam p[3];
+
+  p[0].op=OP_ColorMaterial;
+  p[1].i=mode;
+  p[2].i=type;
+
+  gl_add_op(p);
+}
+
+void glLightfv(int light,int type,float *v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  /* TODO: 3 composants ? */
+  for(i=0;i<4;i++) p[3+i].f=v[i];
+
+  gl_add_op(p);
+}
+
+
+void glLightf(int light,int type,float v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glLightModeli(int pname,int param)
+{
+  GLParam p[6];
+  int i;
+
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  p[2].f=(float)param;
+  for(i=0;i<4;i++) p[3+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glLightModelfv(int pname,float *param)
+{
+  GLParam p[6];
+  int i;
+
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  for(i=0;i<4;i++) p[2+i].f=param[i];
+
+  gl_add_op(p);
+}
+
+/* clear */
+
+void glClear(int mask)
+{
+  GLParam p[2];
+
+  p[0].op=OP_Clear;
+  p[1].i=mask;
+
+  gl_add_op(p);
+}
+
+void glClearColor(float r,float g,float b,float a)
+{
+  GLParam p[5];
+
+  p[0].op=OP_ClearColor;
+  p[1].f=b;
+  p[2].f=g;
+  p[3].f=r;
+  p[4].f=a;
+
+  gl_add_op(p);
+}
+
+void glClearDepth(double depth)
+{
+  GLParam p[2];
+
+  p[0].op=OP_ClearDepth;
+  p[1].f=depth;
+
+  gl_add_op(p);
+}
+
+
+/* textures */
+
+void glTexImage2D( int target, int level, int components,
+                   int width, int height, int border,
+                   int format, int type, void *pixels)
+{
+  GLParam 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;
+
+  gl_add_op(p);
+}
+
+
+void glBindTexture(int target,int texture)
+{
+  GLParam p[3];
+
+  p[0].op=OP_BindTexture;
+  p[1].i=target;
+  p[2].i=texture;
+
+  gl_add_op(p);
+}
+
+void glTexEnvi(int target,int pname,int param)
+{
+  GLParam 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;
+
+  gl_add_op(p);
+}
+
+void glTexParameteri(int target,int pname,int param)
+{
+  GLParam 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;
+
+  gl_add_op(p);
+}
+
+void glPixelStorei(int pname,int param)
+{
+  GLParam p[3];
+
+  p[0].op=OP_PixelStore;
+  p[1].i=pname;
+  p[2].i=param;
+
+  gl_add_op(p);
+}
+
+/* selection */
+
+void glInitNames(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_InitNames;
+
+  gl_add_op(p);
+}
+
+void glPushName(unsigned int name)
+{
+  GLParam p[2];
+
+  p[0].op=OP_PushName;
+  p[1].i=name;
+
+  gl_add_op(p);
+}
+
+void glPopName(void)
+{
+  GLParam p[1];
+
+  p[0].op=OP_PopName;
+
+  gl_add_op(p);
+}
+
+void glLoadName(unsigned int name)
+{
+  GLParam p[2];
+
+  p[0].op=OP_LoadName;
+  p[1].i=name;
+
+  gl_add_op(p);
+}
+
+void 
+glPolygonOffset(GLfloat factor, GLfloat units)
+{
+  GLParam p[3];
+  p[0].op = OP_PolygonOffset;
+  p[1].f = factor;
+  p[2].f = units;
+}
+
+/* Special Functions */
+
+void glCallList(unsigned int list)
+{
+  GLParam p[2];
+
+  p[0].op=OP_CallList;
+  p[1].i=list;
+
+  gl_add_op(p);
+}
+
+void glFlush(void)
+{
+  /* nothing to do */
+}
+
+void glHint(int target,int mode)
+{
+  GLParam p[3];
+
+  p[0].op=OP_Hint;
+  p[1].i=target;
+  p[2].i=mode;
+
+  gl_add_op(p);
+}
+
+/* Non standard functions */
+
+void glDebug(int mode)
+{
+  GLContext *c=gl_get_context();
+  c->print_flag=mode;
+}
+

programs/develop/libraries/TinyGL/src/arrays.c

@@ -0,0 +1,206 @@
+#include "zgl.h"
+/*#include <assert.h>*/
+#include <stdio.h>
+
+#define VERTEX_ARRAY   0x0001
+#define COLOR_ARRAY    0x0002
+#define NORMAL_ARRAY   0x0004
+#define TEXCOORD_ARRAY 0x0008
+
+void
+glopArrayElement(GLContext *c, GLParam *param)
+{
+  int i;
+  int states = c->client_states;
+  int idx = param[1].i;
+    
+  if (states & COLOR_ARRAY) {
+    GLParam p[5];
+    int size = c->color_array_size; 
+    i = idx * (size + c->color_array_stride);
+    p[1].f = c->color_array[i];
+    p[2].f = c->color_array[i+1];
+    p[3].f = c->color_array[i+2];
+    p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
+    glopColor(c, p);  
+  }
+  if (states & NORMAL_ARRAY) {
+    i = idx * (3 + c->normal_array_stride);
+    c->current_normal.X = c->normal_array[i];
+    c->current_normal.Y = c->normal_array[i+1];
+    c->current_normal.Z = c->normal_array[i+2];
+    c->current_normal.Z = 0.0f;
+  }
+  if (states & TEXCOORD_ARRAY) {
+    int size = c->texcoord_array_size;
+    i = idx * (size + c->texcoord_array_stride);
+    c->current_tex_coord.X = c->texcoord_array[i];
+    c->current_tex_coord.Y = c->texcoord_array[i+1];
+    c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
+    c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
+  }
+  if (states & VERTEX_ARRAY) {
+    GLParam p[5];
+    int size = c->vertex_array_size;
+    i = idx * (size + c->vertex_array_stride);
+    p[1].f = c->vertex_array[i];
+    p[2].f = c->vertex_array[i+1];
+    p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
+    p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
+    glopVertex(c, p);
+  }
+}
+
+void
+glArrayElement(GLint i)
+{
+  GLParam p[2];
+  p[0].op = OP_ArrayElement;
+  p[1].i = i;
+  gl_add_op(p);
+}
+
+
+void
+glopEnableClientState(GLContext *c, GLParam *p)
+{
+  c->client_states |= p[1].i;
+}
+
+void 
+glEnableClientState(GLenum array)
+{
+  GLParam p[2];
+  p[0].op = OP_EnableClientState;
+  
+  switch(array) {
+  case GL_VERTEX_ARRAY:
+    p[1].i = VERTEX_ARRAY;
+    break;  
+  case GL_NORMAL_ARRAY:
+    p[1].i = NORMAL_ARRAY;
+    break;
+  case GL_COLOR_ARRAY:
+    p[1].i = COLOR_ARRAY;
+    break;
+  case GL_TEXTURE_COORD_ARRAY:
+    p[1].i = TEXCOORD_ARRAY;
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  gl_add_op(p);
+}
+
+void
+glopDisableClientState(GLContext *c, GLParam *p)
+{
+  c->client_states &= p[1].i;
+}
+
+void
+glDisableClientState(GLenum array)
+{
+  GLParam p[2];
+  p[0].op = OP_DisableClientState;
+    
+  switch(array) {
+  case GL_VERTEX_ARRAY:
+    p[1].i = ~VERTEX_ARRAY;
+    break;  
+  case GL_NORMAL_ARRAY:
+    p[1].i = ~NORMAL_ARRAY;
+    break;
+  case GL_COLOR_ARRAY:
+    p[1].i = ~COLOR_ARRAY;
+    break;
+  case GL_TEXTURE_COORD_ARRAY:
+    p[1].i = ~TEXCOORD_ARRAY;
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  gl_add_op(p);
+}
+
+void
+glopVertexPointer(GLContext *c, GLParam *p)
+{
+  c->vertex_array_size = p[1].i;
+  c->vertex_array_stride = p[2].i;
+  c->vertex_array = p[3].p;
+}
+
+void 
+glVertexPointer(GLint size, GLenum type, GLsizei stride, 
+                const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_VertexPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+  gl_add_op(p);
+}
+
+void
+glopColorPointer(GLContext *c, GLParam *p)
+{
+  c->color_array_size = p[1].i;
+  c->color_array_stride = p[2].i;
+  c->color_array = p[3].p;  
+}
+
+void 
+glColorPointer(GLint size, GLenum type, GLsizei stride, 
+               const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_ColorPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+  gl_add_op(p);
+}
+
+void
+glopNormalPointer(GLContext *c, GLParam *p)
+{
+  c->normal_array_stride = p[1].i;
+  c->normal_array = p[2].p;  
+}
+
+void 
+glNormalPointer(GLenum type, GLsizei stride, 
+                const GLvoid *pointer)
+{
+  GLParam p[3];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_NormalPointer;
+  p[1].i = stride;
+  p[2].p = (void*)pointer;
+}
+
+void
+glopTexCoordPointer(GLContext *c, GLParam *p)
+{
+  c->texcoord_array_size = p[1].i;
+  c->texcoord_array_stride = p[2].i;
+  c->texcoord_array = p[3].p;
+}
+
+void 
+glTexCoordPointer(GLint size, GLenum type, GLsizei stride, 
+                  const GLvoid *pointer)
+{
+  GLParam p[4];
+  assert(type == GL_FLOAT);
+  p[0].op = OP_TexCoordPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+}

programs/develop/libraries/TinyGL/src/clear.c

@@ -0,0 +1,30 @@
+#include "zgl.h"
+
+
+void glopClearColor(GLContext *c,GLParam *p)
+{
+  c->clear_color.v[0]=p[1].f;
+  c->clear_color.v[1]=p[2].f;
+  c->clear_color.v[2]=p[3].f;
+  c->clear_color.v[3]=p[4].f;
+}
+void glopClearDepth(GLContext *c,GLParam *p)
+{
+  c->clear_depth=p[1].f;
+}
+
+
+void glopClear(GLContext *c,GLParam *p)
+{
+  int mask=p[1].i;
+  int z=0;
+  int r=(int)(c->clear_color.v[0]*65535);
+  int g=(int)(c->clear_color.v[1]*65535);
+  int b=(int)(c->clear_color.v[2]*65535);
+
+  /* TODO : correct value of Z */
+
+  ZB_clear(c->zb,mask & GL_DEPTH_BUFFER_BIT,z,
+	   mask & GL_COLOR_BUFFER_BIT,r,g,b);
+}
+

programs/develop/libraries/TinyGL/src/clip.c

@@ -0,0 +1,450 @@
+#include "zgl.h"
+
+/* 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)
+
+void gl_transform_to_viewport(GLContext *c,GLVertex *v)
+{
+  float winv;
+
+  /* coordinates */
+  winv=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 */
+
+  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) 
+                  + ZB_POINT_T_MIN);
+  }
+}
+
+
+static void gl_add_select1(GLContext *c,int z1,int z2,int z3)
+{
+  unsigned int min,max;
+  min=max=z1;
+  if (z2<min) min=z2;
+  if (z3<min) min=z3;
+  if (z2>max) max=z2;
+  if (z3>max) max=z3;
+
+  gl_add_select(c,0xffffffff-min,0xffffffff-max);
+}
+
+/* point */
+
+void gl_draw_point(GLContext *c,GLVertex *p0)
+{
+  if (p0->clip_code == 0) {
+    if (c->render_mode == GL_SELECT) {
+      gl_add_select(c,p0->zp.z,p0->zp.z);
+    } else {
+      ZB_plot(c->zb,&p0->zp);
+    }
+  }
+}
+
+/* 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;
+
+  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 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;
+  
+  cc1=p1->clip_code;
+  cc2=p2->clip_code;
+
+  if ( (cc1 | cc2) == 0) {
+    if (c->render_mode == GL_SELECT) {
+      gl_add_select1(c,p1->zp.z,p2->zp.z,p2->zp.z);
+    } else {
+        if (c->depth_test)
+            ZB_line_z(c->zb,&p1->zp,&p2->zp);
+        else
+            ZB_line(c->zb,&p1->zp,&p2->zp);
+    }
+  } 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)) {
+
+      interpolate(&q1,p1,p2,tmin);
+      interpolate(&q2,p1,p2,tmax);
+      gl_transform_to_viewport(c,&q1);
+      gl_transform_to_viewport(c,&q2);
+
+      RGBFtoRGBI(q1.color.v[0],q1.color.v[1],q1.color.v[2],q1.zp.r,q1.zp.g,q1.zp.b);
+      RGBFtoRGBI(q2.color.v[0],q2.color.v[1],q2.color.v[2],q2.zp.r,q2.zp.g,q2.zp.b);
+
+      if (c->depth_test)
+          ZB_line_z(c->zb,&q1.zp,&q2.zp);
+      else
+          ZB_line(c->zb,&q1.zp,&q2.zp);
+    }
+  }
+}
+
+	 
+/* triangle */
+
+/*
+ * 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). 
+ */
+	 
+#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)
+
+
+float (*clip_proc[6])(V4 *,V4 *,V4 *)=  {
+    clip_xmin,clip_xmax,
+    clip_ymin,clip_ymax,
+    clip_zmin,clip_zmax
+};
+
+static inline void updateTmp(GLContext *c,
+			     GLVertex *q,GLVertex *p0,GLVertex *p1,float t)
+{
+  if (c->current_shade_model == GL_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];
+  }
+
+  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;
+  }
+
+  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);
+    RGBFtoRGBI(q->color.v[0],q->color.v[1],q->color.v[2],q->zp.r,q->zp.g,q->zp.b);
+  }
+}
+
+static void gl_draw_triangle_clip(GLContext *c,
+                                  GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit);
+
+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;
+  
+  co=cc[0] | cc[1] | cc[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;
+
+      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 == GL_BACK) {
+          if (front == 0) return;
+          c->draw_triangle_front(c,p0,p1,p2);
+        } else if (c->current_cull_face == GL_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)
+{
+  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;
+
+    /* find the next direction to clip */
+    while (clip_bit < 6 && (co & (1 << clip_bit)) == 0)  {
+      clip_bit++;
+    }
+
+    /* 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 */
+
+      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);
+
+      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=0;
+      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; }
+      
+      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);
+      
+      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);
+}
+
+#ifdef PROFILE
+int count_triangles,count_triangles_textured,count_pixels;
+#endif
+
+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++;
+  }
+#endif
+    
+  if (c->texture_2d_enabled) {
+#ifdef PROFILE
+    count_triangles_textured++;
+#endif
+    ZB_setTexture(c->zb,c->current_texture->images[0].pixmap);
+    ZB_fillTriangleMappingPerspective(c->zb,&p0->zp,&p1->zp,&p2->zp);
+  } else if (c->current_shade_model == GL_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 */  
+
+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);
+}
+
+
+
+

programs/develop/libraries/TinyGL/src/error.c

@@ -0,0 +1,16 @@
+#include <stdarg.h>
+#include "zgl.h"
+
+void gl_fatal_error(char *format, ...)
+{
+  va_list ap;
+
+  va_start(ap,format);
+
+  fprintf(stderr,"TinyGL: fatal error: ");
+  vfprintf(stderr,format,ap);
+  fprintf(stderr,"\n");
+  exit(1);
+
+  va_end(ap);
+}

programs/develop/libraries/TinyGL/src/get.c

@@ -0,0 +1,72 @@
+#include "zgl.h"
+
+void glGetIntegerv(int pname,int *params)
+{
+  GLContext *c=gl_get_context();
+
+  switch(pname) {
+  case GL_VIEWPORT:
+    params[0]=c->viewport.xmin;
+    params[1]=c->viewport.ymin;
+    params[2]=c->viewport.xsize;
+    params[3]=c->viewport.ysize;
+    break;
+  case GL_MAX_MODELVIEW_STACK_DEPTH:
+    *params = MAX_MODELVIEW_STACK_DEPTH;
+    break;
+  case GL_MAX_PROJECTION_STACK_DEPTH:
+    *params = MAX_PROJECTION_STACK_DEPTH;
+    break;
+  case GL_MAX_LIGHTS:
+    *params = MAX_LIGHTS;
+    break;
+  case GL_MAX_TEXTURE_SIZE:
+    *params = 256; /* not completely true, but... */
+    break;
+  case GL_MAX_TEXTURE_STACK_DEPTH:
+    *params = MAX_TEXTURE_STACK_DEPTH;
+    break;
+  default:
+    gl_fatal_error("glGet: option not implemented");
+    break;
+  }
+}
+
+void glGetFloatv(int pname, float *v)
+{
+  int i;
+  int mnr = 0; /* just a trick to return the correct matrix */
+  GLContext *c = gl_get_context();
+  switch (pname) {
+  case GL_TEXTURE_MATRIX:
+    mnr++; 
+  case GL_PROJECTION_MATRIX:
+    mnr++; 
+  case GL_MODELVIEW_MATRIX:
+    {
+      float *p = &c->matrix_stack_ptr[mnr]->m[0][0];;
+      for (i = 0; i < 4; i++) {
+        *v++ = p[0];
+        *v++ = p[4];
+        *v++ = p[8];
+        *v++ = p[12];
+        p++;
+      }
+    } 
+    break;
+  case GL_LINE_WIDTH:
+    *v = 1.0f;
+    break;
+  case GL_LINE_WIDTH_RANGE:
+    v[0] = v[1] = 1.0f;
+    break;
+  case GL_POINT_SIZE:
+    *v = 1.0f;
+    break;
+  case GL_POINT_SIZE_RANGE:
+    v[0] = v[1] = 1.0f;
+  default:
+    fprintf(stderr,"warning: unknown pname in glGetFloatv()\n");
+    break;
+  }
+}

programs/develop/libraries/TinyGL/src/glu.c

@@ -0,0 +1,343 @@
+#include <stdlib.h>
+#include <math.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+ 
+  
+void drawTorus(float rc, int numc, float rt, int numt)
+{
+    int i, j, k;
+    double s, t;
+    double x, y, z;
+    double pi, twopi;
+
+    pi = 3.14159265358979323846;
+    twopi = 2 * pi;
+ 
+    for (i = 0; i < numc; i++) {
+	glBegin(GL_QUAD_STRIP);
+        for (j = 0; j <= numt; j++) {
+	    for (k = 1; k >= 0; k--) {
+		s = (i + k) % numc + 0.5;
+		t = j % numt;
+
+		x = cos(t*twopi/numt) * cos(s*twopi/numc);
+		y = sin(t*twopi/numt) * cos(s*twopi/numc);
+		z = sin(s*twopi/numc);
+		glNormal3f(x, y, z);
+
+		x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt);
+		y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt);
+		z = rc * sin(s*twopi/numc);
+		glVertex3f(x, y, z);
+	    }
+        }
+	glEnd();
+    }
+}
+
+static void normal3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GLdouble mag;
+
+   mag = sqrt( x*x + y*y + z*z );
+   if (mag>0.00001F) {
+      x /= mag;
+      y /= mag;
+      z /= mag;
+   }
+   glNormal3f( x, y, z );
+}
+
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+		     GLdouble zNear, GLdouble zFar )
+{
+   GLdouble xmin, xmax, ymin, ymax;
+
+   ymax = zNear * tan( fovy * M_PI / 360.0 );
+   ymin = -ymax;
+
+   xmin = ymin * aspect;
+   xmax = ymax * aspect;
+
+   glFrustum( xmin, xmax, ymin, ymax, zNear, zFar );
+
+}
+
+void 
+gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,
+	  GLdouble centerx, GLdouble centery, GLdouble centerz,
+	  GLdouble upx, GLdouble upy, GLdouble upz)
+{
+   GLfloat m[16];
+   GLdouble x[3], y[3], z[3];
+   GLdouble mag;
+
+   /* Make rotation matrix */
+
+   /* Z vector */
+   z[0] = eyex - centerx;
+   z[1] = eyey - centery;
+   z[2] = eyez - centerz;
+   mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
+   if (mag) {			/* mpichler, 19950515 */
+      z[0] /= mag;
+      z[1] /= mag;
+      z[2] /= mag;
+   }
+
+   /* Y vector */
+   y[0] = upx;
+   y[1] = upy;
+   y[2] = upz;
+
+   /* X vector = Y cross Z */
+   x[0] = y[1] * z[2] - y[2] * z[1];
+   x[1] = -y[0] * z[2] + y[2] * z[0];
+   x[2] = y[0] * z[1] - y[1] * z[0];
+
+   /* Recompute Y = Z cross X */
+   y[0] = z[1] * x[2] - z[2] * x[1];
+   y[1] = -z[0] * x[2] + z[2] * x[0];
+   y[2] = z[0] * x[1] - z[1] * x[0];
+
+   /* mpichler, 19950515 */
+   /* cross product gives area of parallelogram, which is < 1.0 for
+    * non-perpendicular unit-length vectors; so normalize x, y here
+    */
+
+   mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
+   if (mag) {
+      x[0] /= mag;
+      x[1] /= mag;
+      x[2] /= mag;
+   }
+
+   mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
+   if (mag) {
+      y[0] /= mag;
+      y[1] /= mag;
+      y[2] /= mag;
+   }
+
+#define M(row,col)  m[col*4+row]
+   M(0, 0) = x[0];
+   M(0, 1) = x[1];
+   M(0, 2) = x[2];
+   M(0, 3) = 0.0;
+   M(1, 0) = y[0];
+   M(1, 1) = y[1];
+   M(1, 2) = y[2];
+   M(1, 3) = 0.0;
+   M(2, 0) = z[0];
+   M(2, 1) = z[1];
+   M(2, 2) = z[2];
+   M(2, 3) = 0.0;
+   M(3, 0) = 0.0;
+   M(3, 1) = 0.0;
+   M(3, 2) = 0.0;
+   M(3, 3) = 1.0;
+#undef M
+   glMultMatrixf(m);
+
+   /* Translate Eye to Origin */
+   glTranslatef(-eyex, -eyey, -eyez);
+
+}
+
+GLUquadricObj *gluNewQuadric(void)
+{
+  return NULL;
+}
+
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style)
+{
+}
+
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks )
+{
+   GLdouble da, r, dr, dz;
+   GLfloat z, nz, nsign;
+   GLint i, j;
+   GLfloat du = 1.0 / slices;
+   GLfloat dv = 1.0 / stacks;
+   GLfloat tcx = 0.0, tcy = 0.0;
+   
+   nsign = 1.0;
+
+   da = 2.0*M_PI / slices;
+   dr = (topRadius-baseRadius) / stacks;
+   dz = height / stacks;
+   nz = (baseRadius-topRadius) / height;  /* Z component of normal vectors */
+
+   for (i=0;i<slices;i++) {
+	 GLfloat x1 = -sin(i*da);
+	 GLfloat y1 = cos(i*da);
+	 GLfloat x2 = -sin((i+1)*da);
+	 GLfloat y2 = cos((i+1)*da);
+	 z = 0.0;
+	 r = baseRadius;
+	 tcy = 0.0;
+	 glBegin( GL_QUAD_STRIP );
+	 for (j=0;j<=stacks;j++) {
+	    if (nsign==1.0) {
+	       normal3f( x1*nsign, y1*nsign, nz*nsign );
+	       glTexCoord2f(tcx, tcy);
+	       glVertex3f( x1*r, y1*r, z );
+	       normal3f( x2*nsign, y2*nsign, nz*nsign );
+	       glTexCoord2f(tcx+du, tcy);
+	       glVertex3f( x2*r, y2*r, z );
+	    }
+	    else {
+	       normal3f( x2*nsign, y2*nsign, nz*nsign );
+	       glTexCoord2f(tcx, tcy);
+	       glVertex3f( x2*r, y2*r, z );
+	       normal3f( x1*nsign, y1*nsign, nz*nsign );
+	       glTexCoord2f(tcx+du, tcy);
+	       glVertex3f( x1*r, y1*r, z );
+	    }
+	    z += dz;
+	    r += dr;
+	    tcy += dv;
+	 }
+	 glEnd();
+	 tcx += du;
+      }
+}
+
+/* Disk (adapted from Mesa) */
+
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops )
+{
+   GLdouble a, da;
+   GLfloat dr;
+   GLfloat r1, r2, dtc;
+   GLint s, l;
+   GLfloat sa,ca;
+
+   /* Normal vectors */
+	 glNormal3f( 0.0, 0.0, +1.0 );
+
+   da = 2.0*M_PI / slices;
+   dr = (outerRadius-innerRadius) / (GLfloat) loops;
+
+   /* texture of a gluDisk is a cut out of the texture unit square */
+   /* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
+   dtc = 2.0f * outerRadius;
+
+   r1 = innerRadius;
+   for (l=0;l<loops;l++) {
+	    r2 = r1 + dr;
+	       glBegin( GL_QUAD_STRIP );
+	       for (s=0;s<=slices;s++) {
+		  if (s==slices) a = 0.0;
+		  else  a = s * da;
+		  sa = sin(a); ca = cos(a);
+                  glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc);
+                  glVertex2f( r2*sa, r2*ca );
+                  glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc);
+                  glVertex2f( r1*sa, r1*ca );
+	       }
+	       glEnd();
+	    r1 = r2;
+	 }
+
+}
+
+/*
+ * Sphere (adapted from Mesa)
+ */
+
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks)
+{
+   float rho, drho, theta, dtheta;
+   float x, y, z;
+   float s, t, ds, dt;
+   int i, j, imin, imax;
+   int normals;
+   float nsign;
+  
+   normals=1;
+   nsign=1;
+
+   drho = M_PI / (float) stacks;
+   dtheta = 2.0 * M_PI / (float) slices;
+
+  /* draw +Z end as a triangle fan */
+  glBegin( GL_TRIANGLE_FAN );
+  glNormal3f( 0.0, 0.0, 1.0 );
+  glTexCoord2f(0.5,0.0);
+  glVertex3f( 0.0, 0.0, nsign * radius );
+  for (j=0;j<=slices;j++) {
+	 theta = (j==slices) ? 0.0 : j * dtheta;
+	 x = -sin(theta) * sin(drho);
+	 y = cos(theta) * sin(drho);
+	 z = nsign * cos(drho);
+	 if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	 glVertex3f( x*radius, y*radius, z*radius );
+      }
+   glEnd();
+
+
+      ds = 1.0 / slices;
+      dt = 1.0 / stacks;
+      t = 1.0;  /* because loop now runs from 0 */
+      if (1) {
+        imin = 0;
+        imax = stacks;
+      }
+      else {
+        imin = 1;
+        imax = stacks-1;
+      }
+
+      /* draw intermediate stacks as quad strips */
+      for (i=imin;i<imax;i++) {
+	 rho = i * drho;
+	 glBegin( GL_QUAD_STRIP );
+         s = 0.0;
+	 for (j=0;j<=slices;j++) {
+	    theta = (j==slices) ? 0.0 : j * dtheta;
+	    x = -sin(theta) * sin(rho);
+	    y = cos(theta) * sin(rho);
+	    z = nsign * cos(rho);
+	    if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	    glTexCoord2f(s,1-t);
+	    glVertex3f( x*radius, y*radius, z*radius );
+	    x = -sin(theta) * sin(rho+drho);
+	    y = cos(theta) * sin(rho+drho);
+	    z = nsign * cos(rho+drho);
+	    if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	    glTexCoord2f(s,1-(t-dt));
+            s += ds;
+	    glVertex3f( x*radius, y*radius, z*radius );
+	 }
+	 glEnd();
+	 t -= dt;
+      }
+
+/* draw -Z end as a triangle fan */
+    glBegin( GL_TRIANGLE_FAN );
+    glNormal3f( 0.0, 0.0, -1.0 );
+      glTexCoord2f(0.5,1.0);
+      glVertex3f( 0.0, 0.0, -radius*nsign );
+      rho = M_PI - drho;
+      s = 1.0;
+      t = dt;
+      for (j=slices;j>=0;j--) {
+	 theta = (j==slices) ? 0.0 : j * dtheta;
+	 x = -sin(theta) * sin(rho);
+	 y = cos(theta) * sin(rho);
+	 z = nsign * cos(rho);
+	 if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	 glTexCoord2f(s,1-t);
+         s -= ds;
+	 glVertex3f( x*radius, y*radius, z*radius );
+      }
+      glEnd();
+}

programs/develop/libraries/TinyGL/src/image_util.c

@@ -0,0 +1,136 @@
+#include "zgl.h"
+
+/*
+ * image conversion
+ */
+
+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;
+  }
+}
+
+void gl_convertRGB_to_8A8R8G8B(unsigned int *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]=(((unsigned int)p[0])<<16) | 
+            (((unsigned int)p[1])<<8) | 
+            (((unsigned int)p[2])); 
+        p+=3;
+    }
+}
+
+/*
+ * 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);
+}
+
+
+/* 
+ * 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;
+
+  pix=dest;
+  pix_src=src;
+  
+  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);
+	}
+      } 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 */
+
+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;
+
+  pix=dest;
+  pix_src=src;
+  
+  x1inc=(int)((float) ((xsize_src)<<FRAC_BITS) / (float) (xsize_dest));
+  y1inc=(int)((float) ((ysize_src)<<FRAC_BITS) / (float) (ysize_dest));
+
+  y1=0;
+  for(y=0;y<ysize_dest;y++) {
+    x1=0;
+    for(x=0;x<xsize_dest;x++) {
+      xi=x1 >> FRAC_BITS;
+      yi=y1 >> FRAC_BITS;
+      pix1=pix_src+(yi*xsize_src+xi)*3;
+
+      pix[0]=pix1[0];
+      pix[1]=pix1[1];
+      pix[2]=pix1[2];
+
+      pix+=3;
+      x1+=x1inc;
+    }
+    y1+=y1inc;
+  }
+}
+

programs/develop/libraries/TinyGL/src/init.c

@@ -0,0 +1,189 @@
+#include "zgl.h"
+
+GLContext *gl_ctx;
+
+
+void initSharedState(GLContext *c)
+{
+  GLSharedState *s=&c->shared_state;
+  s->lists=gl_zalloc(sizeof(GLList *) * MAX_DISPLAY_LISTS);
+  s->texture_hash_table=
+      gl_zalloc(sizeof(GLTexture *) * TEXTURE_HASH_TABLE_SIZE);
+
+  alloc_texture(c,0);
+}
+
+void endSharedState(GLContext *c)
+{
+  GLSharedState *s=&c->shared_state;
+  int i;
+
+  for(i=0;i<MAX_DISPLAY_LISTS;i++) {
+    /* TODO */
+  }
+  gl_free(s->lists);
+
+  gl_free(s->texture_hash_table);
+}
+
+
+void glInit(void *zbuffer1)
+{
+  ZBuffer *zbuffer=(ZBuffer *)zbuffer1;
+  GLContext *c;
+  GLViewport *v;
+  int i;
+
+  c=gl_zalloc(sizeof(GLContext));
+  gl_ctx=c;
+
+  c->zb=zbuffer;
+
+  /* allocate GLVertex array */
+  c->vertex_max = POLYGON_MAX_VERTEX;
+  c->vertex = gl_malloc(POLYGON_MAX_VERTEX*sizeof(GLVertex));
+  
+  /* viewport */
+  v=&c->viewport;
+  v->xmin=0;
+  v->ymin=0;
+  v->xsize=zbuffer->xsize;
+  v->ysize=zbuffer->ysize;
+  v->updated=1;
+
+  /* shared state */
+  initSharedState(c);
+
+  /* lists */
+
+  c->exec_flag=1;
+  c->compile_flag=0;
+  c->print_flag=0;
+
+  c->in_begin=0;
+
+  /* lights */
+  for(i=0;i<MAX_LIGHTS;i++) {
+    GLLight *l=&c->lights[i];
+    l->ambient=gl_V4_New(0,0,0,1);
+    l->diffuse=gl_V4_New(1,1,1,1);
+    l->specular=gl_V4_New(1,1,1,1);
+    l->position=gl_V4_New(0,0,1,0);
+    l->norm_position=gl_V3_New(0,0,1);
+    l->spot_direction=gl_V3_New(0,0,-1);
+    l->norm_spot_direction=gl_V3_New(0,0,-1);
+    l->spot_exponent=0;
+    l->spot_cutoff=180;
+    l->attenuation[0]=1;
+    l->attenuation[1]=0;
+    l->attenuation[2]=0;
+    l->enabled=0;
+  }
+  c->first_light=NULL;
+  c->ambient_light_model=gl_V4_New(0.2,0.2,0.2,1);
+  c->local_light_model=0;
+  c->lighting_enabled=0;
+  c->light_model_two_side = 0;
+
+  /* default materials */
+  for(i=0;i<2;i++) {
+    GLMaterial *m=&c->materials[i];
+    m->emission=gl_V4_New(0,0,0,1);
+    m->ambient=gl_V4_New(0.2,0.2,0.2,1);
+    m->diffuse=gl_V4_New(0.8,0.8,0.8,1);
+    m->specular=gl_V4_New(0,0,0,1);
+    m->shininess=0;
+  }
+  c->current_color_material_mode=GL_FRONT_AND_BACK;
+  c->current_color_material_type=GL_AMBIENT_AND_DIFFUSE;
+  c->color_material_enabled=0;
+
+  /* textures */
+  glInitTextures(c);
+
+  /* default state */
+  c->current_color.X=1.0;
+  c->current_color.Y=1.0;
+  c->current_color.Z=1.0;
+  c->current_color.W=1.0;
+  c->longcurrent_color[0] = 65535;
+  c->longcurrent_color[1] = 65535;
+  c->longcurrent_color[2] = 65535;
+
+  c->current_normal.X=1.0;
+  c->current_normal.Y=0.0;
+  c->current_normal.Z=0.0;
+  c->current_normal.W=0.0;
+
+  c->current_edge_flag=1;
+  
+  c->current_tex_coord.X=0;
+  c->current_tex_coord.Y=0;
+  c->current_tex_coord.Z=0;
+  c->current_tex_coord.W=1;
+
+  c->polygon_mode_front=GL_FILL;
+  c->polygon_mode_back=GL_FILL;
+
+  c->current_front_face=0; /* 0 = GL_CCW  1 = GL_CW */
+  c->current_cull_face=GL_BACK;
+  c->current_shade_model=GL_SMOOTH;
+  c->cull_face_enabled=0;
+  
+  /* clear */
+  c->clear_color.v[0]=0;
+  c->clear_color.v[1]=0;
+  c->clear_color.v[2]=0;
+  c->clear_color.v[3]=0;
+  c->clear_depth=0;
+
+  /* selection */
+  c->render_mode=GL_RENDER;
+  c->select_buffer=NULL;
+  c->name_stack_size=0;
+
+  /* matrix */
+  c->matrix_mode=0;
+  
+  c->matrix_stack_depth_max[0]=MAX_MODELVIEW_STACK_DEPTH;
+  c->matrix_stack_depth_max[1]=MAX_PROJECTION_STACK_DEPTH;
+  c->matrix_stack_depth_max[2]=MAX_TEXTURE_STACK_DEPTH;
+
+  for(i=0;i<3;i++) {
+    c->matrix_stack[i]=gl_zalloc(c->matrix_stack_depth_max[i] * sizeof(M4));
+    c->matrix_stack_ptr[i]=c->matrix_stack[i];
+  }
+
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glMatrixMode(GL_TEXTURE);
+  glLoadIdentity();
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  c->matrix_model_projection_updated=1;
+
+  /* opengl 1.1 arrays */
+  c->client_states = 0;
+  
+  /* opengl 1.1 polygon offset */
+  c->offset_states = 0;
+  
+  /* clear the resize callback function pointer */
+  c->gl_resize_viewport = NULL;
+  
+  /* specular buffer */
+  c->specbuf_first = NULL;
+  c->specbuf_used_counter = 0;
+  c->specbuf_num_buffers = 0;
+
+  /* depth test */
+  c->depth_test = 0;
+}
+
+void glClose(void)
+{
+  GLContext *c=gl_get_context();
+  endSharedState(c);
+  gl_free(c);
+}

programs/develop/libraries/TinyGL/src/kosgl.c

@@ -0,0 +1,127 @@
+/* simple gl like driver for TinyGL and KolibriOS - porting iadn */
+#include <GL/gl.h>
+#include "kosgl.h"
+#include "zgl.h"
+
+
+
+typedef struct {
+    GLContext *gl_context;
+    int xsize,ysize;
+    int dx,dy;
+    int x,y;
+} TinyGLContext;
+
+
+KOSGLContext kosglCreateContext(KOSGLContext shareList, int flags)
+{
+  TinyGLContext *ctx;
+
+  if (shareList != NULL) {
+    gl_fatal_error("No sharing available in TinyGL");    
+  }
+
+    ctx=gl_malloc(sizeof(TinyGLContext));
+  if (!ctx)
+      return NULL;
+  ctx->gl_context=NULL;
+  return (KOSGLContext) ctx;
+}
+
+void kosglDestroyContext( KOSGLContext ctx1 )
+{
+  TinyGLContext *ctx = (TinyGLContext *) ctx1;
+  if (ctx->gl_context != NULL) {
+    glClose();
+  }
+  gl_free(ctx);
+}
+
+/* resize the glx viewport : we try to use the xsize and ysize
+   given. We return the effective size which is guaranted to be smaller */
+
+static int gl_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr)
+{
+  TinyGLContext *ctx;
+  int xsize,ysize;
+   
+  ctx=(TinyGLContext *)c->opaque;
+
+  xsize=*xsize_ptr;
+  ysize=*ysize_ptr;
+
+  /* we ensure that xsize and ysize are multiples of 2 for the zbuffer. 
+     TODO: find a better solution */
+  xsize&=~3;
+  ysize&=~3;
+
+  if (xsize == 0 || ysize == 0) return -1;
+
+  *xsize_ptr=xsize-1;
+  *ysize_ptr=ysize-1;
+  ctx->dx = xsize;
+  ctx->dy = ysize;
+ 
+  ctx->xsize=xsize;
+  ctx->ysize=ysize;  
+    
+  /* resize the Z buffer */
+  ZB_resize(c->zb,NULL,xsize,ysize);
+  return 0;
+}
+
+/* we assume here that drawable is a window */
+int kosglMakeCurrent( int win_x0, int win_y0,int win_x, int win_y, KOSGLContext ctx1)
+{ 	
+  TinyGLContext *ctx = (TinyGLContext *) ctx1;
+  int mode;
+  ZBuffer *zb;
+ 
+  if (ctx->gl_context == NULL) {
+      /* create the TinyGL context */
+      ctx->x = win_x0;
+	  ctx->y = win_y0;
+	  ctx->dx = win_x;
+	  ctx->dy = win_y;
+
+      /* currently, we only support 16 bit rendering */
+      mode = ZB_MODE_RGB24;
+      zb=ZB_open(win_x,win_y,mode,0,NULL,NULL,NULL);      
+    
+      if (zb == NULL) {
+          fprintf(stderr, "Error while initializing Z buffer\n");
+          exit(1);
+      }
+      
+      /* initialisation of the TinyGL interpreter */
+      glInit(zb); 
+
+      ctx->gl_context=gl_get_context();
+      
+      ctx->gl_context->opaque=(void *) ctx;
+      ctx->gl_context->gl_resize_viewport=gl_resize_viewport;
+
+      /* set the viewport : we force a call to gl_resize_viewport */
+      ctx->gl_context->viewport.xsize=-1;
+      ctx->gl_context->viewport.ysize=-1;
+      
+      glViewport(0, 0, win_x, win_y);
+    
+  }  
+  return 1;
+}
+
+void kosglSwapBuffers( )
+{
+    GLContext *gl_context;
+    TinyGLContext *ctx;
+     
+    /* retrieve the current TinyGLContext */
+    gl_context=gl_get_context();
+    ctx=(TinyGLContext *)gl_context->opaque;
+
+	__asm__ __volatile__("int $0x40"::"a"(7),
+                                      "b"((char *)gl_context->zb->pbuf),
+								      "c"((ctx->dx<<16)|ctx->dy),
+									  "d"((ctx->x<<16)|ctx->y));
+}

programs/develop/libraries/TinyGL/src/light.c

@@ -0,0 +1,306 @@
+#include "zgl.h"
+#include "msghandling.h"
+
+void glopMaterial(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  int type=p[2].i;
+  float *v=&p[3].f;
+  int i;
+  GLMaterial *m;
+
+  if (mode == GL_FRONT_AND_BACK) {
+    p[1].i=GL_FRONT;
+    glopMaterial(c,p);
+    mode=GL_BACK;
+  }
+  if (mode == GL_FRONT) m=&c->materials[0];
+  else m=&c->materials[1];
+
+  switch(type) {
+  case GL_EMISSION:
+    for(i=0;i<4;i++)
+      m->emission.v[i]=v[i];
+    break;
+  case GL_AMBIENT:
+    for(i=0;i<4;i++)
+      m->ambient.v[i]=v[i];
+    break;
+  case GL_DIFFUSE:
+    for(i=0;i<4;i++)
+      m->diffuse.v[i]=v[i];
+    break;
+  case GL_SPECULAR:
+    for(i=0;i<4;i++)
+      m->specular.v[i]=v[i];
+    break;
+  case GL_SHININESS:
+    m->shininess=v[0];
+    m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION;
+    break;
+  case GL_AMBIENT_AND_DIFFUSE:
+    for(i=0;i<4;i++)
+      m->diffuse.v[i]=v[i];
+    for(i=0;i<4;i++)
+      m->ambient.v[i]=v[i];
+    break;
+  default:
+    assert(0);
+  }
+}
+
+void glopColorMaterial(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  int type=p[2].i;
+
+  c->current_color_material_mode=mode;
+  c->current_color_material_type=type;
+}
+
+void glopLight(GLContext *c,GLParam *p)
+{
+  int light=p[1].i;
+  int type=p[2].i;
+  V4 v;
+  GLLight *l;
+  int i;
+  
+  assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS );
+
+  l=&c->lights[light-GL_LIGHT0];
+
+  for(i=0;i<4;i++) v.v[i]=p[3+i].f;
+
+  switch(type) {
+  case GL_AMBIENT:
+    l->ambient=v;
+    break;
+  case GL_DIFFUSE:
+    l->diffuse=v;
+    break;
+  case GL_SPECULAR:
+    l->specular=v;
+    break;
+  case GL_POSITION:
+    {
+      V4 pos;
+      gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v);
+
+      l->position=pos;
+
+      if (l->position.v[3] == 0) {
+        l->norm_position.X=pos.X;
+        l->norm_position.Y=pos.Y;
+        l->norm_position.Z=pos.Z;
+        
+        gl_V3_Norm(&l->norm_position);
+      }
+    }
+    break;
+  case GL_SPOT_DIRECTION:
+    for(i=0;i<3;i++) {
+      l->spot_direction.v[i]=v.v[i];
+      l->norm_spot_direction.v[i]=v.v[i];
+    }
+    gl_V3_Norm(&l->norm_spot_direction);
+    break;
+  case GL_SPOT_EXPONENT:
+    l->spot_exponent=v.v[0];
+    break;
+  case GL_SPOT_CUTOFF:
+    {
+      float a=v.v[0];
+      assert(a == 180 || (a>=0 && a<=90));
+      l->spot_cutoff=a;
+      if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0);
+    }
+    break;
+  case GL_CONSTANT_ATTENUATION:
+    l->attenuation[0]=v.v[0];
+    break;
+  case GL_LINEAR_ATTENUATION:
+    l->attenuation[1]=v.v[0];
+    break;
+  case GL_QUADRATIC_ATTENUATION:
+    l->attenuation[2]=v.v[0];
+    break;
+  default:
+    assert(0);
+  }
+}
+  
+
+void glopLightModel(GLContext *c,GLParam *p)
+{
+  int pname=p[1].i;
+  float *v=&p[2].f;
+  int i;
+
+  switch(pname) {
+  case GL_LIGHT_MODEL_AMBIENT:
+    for(i=0;i<4;i++) 
+      c->ambient_light_model.v[i]=v[i];
+    break;
+  case GL_LIGHT_MODEL_LOCAL_VIEWER:
+    c->local_light_model=(int)v[0];
+    break;
+  case GL_LIGHT_MODEL_TWO_SIDE:
+    c->light_model_two_side = (int)v[0];
+    break;
+  default:
+    tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname);
+    //assert(0);
+    break;
+  }
+}
+
+
+static inline float clampf(float a,float min,float max)
+{
+  if (a<min) return min;
+  else if (a>max) return max;
+  else return a;
+}
+
+void gl_enable_disable_light(GLContext *c,int light,int v)
+{
+  GLLight *l=&c->lights[light];
+  if (v && !l->enabled) {
+    l->enabled=1;
+    l->next=c->first_light;
+    c->first_light=l;
+    l->prev=NULL;
+  } else if (!v && l->enabled) {
+    l->enabled=0;
+    if (l->prev == NULL) c->first_light=l->next;
+    else l->prev->next=l->next;
+    if (l->next != NULL) l->next->prev=l->prev;
+  }
+}
+
+/* non optimized lightening model */
+void gl_shade_vertex(GLContext *c,GLVertex *v)
+{
+  float R,G,B,A;
+  GLMaterial *m;
+  GLLight *l;
+  V3 n,s,d;
+  float dist,tmp,att,dot,dot_spot,dot_spec;
+  int twoside = c->light_model_two_side;
+
+  m=&c->materials[0];
+
+  n.X=v->normal.X;
+  n.Y=v->normal.Y;
+  n.Z=v->normal.Z;
+
+  R=m->emission.v[0]+m->ambient.v[0]*c->ambient_light_model.v[0];
+  G=m->emission.v[1]+m->ambient.v[1]*c->ambient_light_model.v[1];
+  B=m->emission.v[2]+m->ambient.v[2]*c->ambient_light_model.v[2];
+  A=clampf(m->diffuse.v[3],0,1);
+
+  for(l=c->first_light;l!=NULL;l=l->next) {
+    float lR,lB,lG;
+    
+    /* ambient */
+    lR=l->ambient.v[0] * m->ambient.v[0];
+    lG=l->ambient.v[1] * m->ambient.v[1];
+    lB=l->ambient.v[2] * m->ambient.v[2];
+
+    if (l->position.v[3] == 0) {
+      /* light at infinity */
+      d.X=l->position.v[0];
+      d.Y=l->position.v[1];
+      d.Z=l->position.v[2];
+      att=1;
+    } else {
+      /* distance attenuation */
+      d.X=l->position.v[0]-v->ec.v[0];
+      d.Y=l->position.v[1]-v->ec.v[1];
+      d.Z=l->position.v[2]-v->ec.v[2];
+      dist=sqrt(d.X*d.X+d.Y*d.Y+d.Z*d.Z);
+      if (dist>1E-3) {
+        tmp=1/dist;
+        d.X*=tmp;
+        d.Y*=tmp;
+        d.Z*=tmp;
+      }
+      att=1.0f/(l->attenuation[0]+dist*(l->attenuation[1]+
+				     dist*l->attenuation[2]));
+    }
+    dot=d.X*n.X+d.Y*n.Y+d.Z*n.Z;
+    if (twoside && dot < 0) dot = -dot;
+    if (dot>0) {
+      /* diffuse light */
+      lR+=dot * l->diffuse.v[0] * m->diffuse.v[0];
+      lG+=dot * l->diffuse.v[1] * m->diffuse.v[1];
+      lB+=dot * l->diffuse.v[2] * m->diffuse.v[2];
+
+      /* spot light */
+      if (l->spot_cutoff != 180) {
+        dot_spot=-(d.X*l->norm_spot_direction.v[0]+
+                   d.Y*l->norm_spot_direction.v[1]+
+                   d.Z*l->norm_spot_direction.v[2]);
+        if (twoside && dot_spot < 0) dot_spot = -dot_spot;
+        if (dot_spot < l->cos_spot_cutoff) {
+          /* no contribution */
+          continue;
+        } else {
+          /* TODO: optimize */
+          if (l->spot_exponent > 0) {
+            att=att*pow(dot_spot,l->spot_exponent);
+          }
+        }
+      }
+
+      /* specular light */
+      
+      if (c->local_light_model) {
+        V3 vcoord;
+        vcoord.X=v->ec.X;
+        vcoord.Y=v->ec.Y;
+        vcoord.Z=v->ec.Z;
+        gl_V3_Norm(&vcoord);
+        s.X=d.X-vcoord.X;
+        s.Y=d.Y-vcoord.X;
+        s.Z=d.Z-vcoord.X;
+      } else {
+        s.X=d.X;
+        s.Y=d.Y;
+        s.Z=d.Z+1.0;
+      }
+      dot_spec=n.X*s.X+n.Y*s.Y+n.Z*s.Z;
+      if (twoside && dot_spec < 0) dot_spec = -dot_spec;
+      if (dot_spec>0) {
+        GLSpecBuf *specbuf;
+        int idx;
+        tmp=sqrt(s.X*s.X+s.Y*s.Y+s.Z*s.Z);
+        if (tmp > 1E-3) {
+          dot_spec=dot_spec / tmp;
+        }
+      
+        /* TODO: optimize */
+        /* testing specular buffer code */
+        /* dot_spec= pow(dot_spec,m->shininess);*/
+        specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess);
+        idx = (int)(dot_spec*SPECULAR_BUFFER_SIZE);
+        if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE;
+        dot_spec = specbuf->buf[idx];
+        lR+=dot_spec * l->specular.v[0] * m->specular.v[0];
+        lG+=dot_spec * l->specular.v[1] * m->specular.v[1];
+        lB+=dot_spec * l->specular.v[2] * m->specular.v[2];
+      }
+    }
+
+    R+=att * lR;
+    G+=att * lG;
+    B+=att * lB;
+  }
+
+  v->color.v[0]=clampf(R,0,1);
+  v->color.v[1]=clampf(G,0,1);
+  v->color.v[2]=clampf(B,0,1);
+  v->color.v[3]=A;
+}
+

programs/develop/libraries/TinyGL/src/list.c

@@ -0,0 +1,251 @@
+#include "zgl.h"
+
+static char *op_table_str[]=
+{
+#define ADD_OP(a,b,c) "gl" #a " " #c,
+
+#include "opinfo.h"
+};
+
+static void (*op_table_func[])(GLContext *,GLParam *)=
+{
+#define ADD_OP(a,b,c) glop ## a ,
+
+#include "opinfo.h"
+};
+
+static int op_table_size[]=
+{
+#define ADD_OP(a,b,c) b + 1 ,
+
+#include "opinfo.h"
+};
+
+
+
+static GLList *find_list(GLContext *c,unsigned int list)
+{
+  return c->shared_state.lists[list];
+}
+
+static void delete_list(GLContext *c,int list)
+{
+  GLParamBuffer *pb,*pb1;
+  GLList *l;
+
+  l=find_list(c,list);
+  assert(l != NULL);
+  
+  /* free param buffer */
+  pb=l->first_op_buffer;
+  while (pb!=NULL) {
+    pb1=pb->next;
+    gl_free(pb);
+    pb=pb1;
+  }
+  
+  gl_free(l);
+  c->shared_state.lists[list]=NULL;
+}
+
+static GLList *alloc_list(GLContext *c,int list)
+{
+  GLList *l;
+  GLParamBuffer *ob;
+
+  l=gl_zalloc(sizeof(GLList));
+  ob=gl_zalloc(sizeof(GLParamBuffer));
+
+  ob->next=NULL;
+  l->first_op_buffer=ob;
+  
+  ob->ops[0].op=OP_EndList;
+
+  c->shared_state.lists[list]=l;
+  return l;
+}
+
+
+void gl_print_op(FILE *f,GLParam *p)
+{
+  int op;
+  char *s;
+
+  op=p[0].op;
+  p++;
+  s=op_table_str[op];
+  while (*s != 0) {
+    if (*s == '%') {
+      s++;
+      switch (*s++) {
+      case 'f':
+	fprintf(f,"%g",p[0].f);
+	break;
+      default:
+	fprintf(f,"%d",p[0].i);
+	break;
+      }
+      p++;
+    } else {
+      fputc(*s,f);
+      s++;
+    }
+  }
+  fprintf(f,"\n");
+}
+
+
+void gl_compile_op(GLContext *c,GLParam *p)
+{
+  int op,op_size;
+  GLParamBuffer *ob,*ob1;
+  int index,i;
+
+  op=p[0].op;
+  op_size=op_table_size[op];
+  index=c->current_op_buffer_index;
+  ob=c->current_op_buffer;
+
+  /* we should be able to add a NextBuffer opcode */
+  if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) {
+
+    ob1=gl_zalloc(sizeof(GLParamBuffer));
+    ob1->next=NULL;
+
+    ob->next=ob1;
+    ob->ops[index].op=OP_NextBuffer;
+    ob->ops[index+1].p=(void *)ob1;
+
+    c->current_op_buffer=ob1;
+    ob=ob1;
+    index=0;
+  }
+
+  for(i=0;i<op_size;i++) {
+    ob->ops[index]=p[i];
+    index++;
+  }
+  c->current_op_buffer_index=index;
+}
+
+void gl_add_op(GLParam *p)
+{
+  GLContext *c=gl_get_context();
+  int op;
+
+  op=p[0].op;
+  if (c->exec_flag) {
+    op_table_func[op](c,p);
+  }
+  if (c->compile_flag) {
+    gl_compile_op(c,p);
+  }
+  if (c->print_flag) {
+    gl_print_op(stderr,p);
+  }
+}
+
+/* this opcode is never called directly */
+void glopEndList(GLContext *c,GLParam *p)
+{
+  assert(0);
+}
+
+/* this opcode is never called directly */
+void glopNextBuffer(GLContext *c,GLParam *p)
+{
+  assert(0);
+}
+
+
+void glopCallList(GLContext *c,GLParam *p)
+{
+  GLList *l;
+  int list,op;
+
+  list=p[1].ui;
+  l=find_list(c,list);
+  if (l == NULL) gl_fatal_error("list %d not defined",list);
+  p=l->first_op_buffer->ops;
+
+  while (1) {
+    op=p[0].op;
+    if (op == OP_EndList) break;
+    if (op == OP_NextBuffer) {
+      p=(GLParam *)p[1].p;
+    } else {
+      op_table_func[op](c,p);
+      p+=op_table_size[op];
+    }
+  }
+}
+
+
+
+void glNewList(unsigned int list,int mode)
+{
+  GLList *l;
+  GLContext *c=gl_get_context();
+
+  assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE);
+  assert(c->compile_flag == 0);
+
+  l=find_list(c,list);
+  if (l!=NULL) delete_list(c,list);
+  l=alloc_list(c,list);
+
+  c->current_op_buffer=l->first_op_buffer;
+  c->current_op_buffer_index=0;
+  
+  c->compile_flag=1;
+  c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE);
+}
+
+void glEndList(void)
+{
+  GLContext *c=gl_get_context();
+  GLParam p[1];
+
+  assert(c->compile_flag == 1);
+  
+  /* end of list */
+  p[0].op=OP_EndList;
+  gl_compile_op(c,p);
+  
+  c->compile_flag=0;
+  c->exec_flag=1;
+}
+
+int glIsList(unsigned int list)
+{
+  GLContext *c=gl_get_context();
+  GLList *l;
+  l=find_list(c,list);
+  return (l != NULL);
+}
+
+unsigned int glGenLists(int range)
+{
+  GLContext *c=gl_get_context();
+  int count,i,list;
+  GLList **lists;
+
+  lists=c->shared_state.lists;
+  count=0;
+  for(i=0;i<MAX_DISPLAY_LISTS;i++) {
+    if (lists[i]==NULL) {
+      count++;
+      if (count == range) {
+	list=i-range+1;
+	for(i=0;i<range;i++) {
+	  alloc_list(c,list+i);
+	}
+	return list;
+      }
+    } else {
+      count=0;
+    }
+  }
+  return 0;
+}
+

programs/develop/libraries/TinyGL/src/matrix.c

@@ -0,0 +1,241 @@
+#include "zgl.h"
+
+void gl_print_matrix( const float *m)
+{
+   int i;
+
+   for (i=0;i<4;i++) {
+      fprintf(stderr,"%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
+   }
+}
+
+static inline void gl_matrix_update(GLContext *c)
+{
+  c->matrix_model_projection_updated=(c->matrix_mode<=1);
+}
+
+
+void glopMatrixMode(GLContext *c,GLParam *p)
+{
+  int mode=p[1].i;
+  switch(mode) {
+  case GL_MODELVIEW:
+    c->matrix_mode=0;
+    break;
+  case GL_PROJECTION:
+    c->matrix_mode=1;
+    break;
+  case GL_TEXTURE:
+    c->matrix_mode=2;
+    break;
+  default:
+    assert(0);
+  }
+}
+
+void glopLoadMatrix(GLContext *c,GLParam *p)
+{
+  M4 *m;
+  int i;
+  
+  GLParam *q;
+
+  m=c->matrix_stack_ptr[c->matrix_mode];
+  q=p+1;
+
+  for(i=0;i<4;i++) {
+    m->m[0][i]=q[0].f;
+    m->m[1][i]=q[1].f;
+    m->m[2][i]=q[2].f;
+    m->m[3][i]=q[3].f;
+    q+=4;
+  }
+
+  gl_matrix_update(c);
+}
+
+void glopLoadIdentity(GLContext *c,GLParam *p)
+{
+
+  gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]);
+
+  gl_matrix_update(c);
+}
+
+void glopMultMatrix(GLContext *c,GLParam *p)
+{
+  M4 m;
+  int i;
+
+  GLParam *q;
+  q=p+1;
+
+  for(i=0;i<4;i++) {
+    m.m[0][i]=q[0].f;
+    m.m[1][i]=q[1].f;
+    m.m[2][i]=q[2].f;
+    m.m[3][i]=q[3].f;
+    q+=4;
+  }
+
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+
+  gl_matrix_update(c);
+}
+
+
+void glopPushMatrix(GLContext *c,GLParam *p)
+{
+  int n=c->matrix_mode;
+  M4 *m;
+
+  assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 )
+	   < c->matrix_stack_depth_max[n] );
+
+  m=++c->matrix_stack_ptr[n];
+  
+  gl_M4_Move(&m[0],&m[-1]);
+
+  gl_matrix_update(c);
+}
+
+void glopPopMatrix(GLContext *c,GLParam *p)
+{
+  int n=c->matrix_mode;
+
+  assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] );
+  c->matrix_stack_ptr[n]--;
+  gl_matrix_update(c);
+}
+
+
+void glopRotate(GLContext *c,GLParam *p)
+{
+  M4 m;
+  float u[3];
+  float angle;
+  int dir_code;
+
+  angle = p[1].f * M_PI / 180.0;
+  u[0]=p[2].f;
+  u[1]=p[3].f;
+  u[2]=p[4].f;
+
+  /* simple case detection */
+  dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0);
+
+  switch(dir_code) {
+  case 0:
+    gl_M4_Id(&m);
+    break;
+  case 4:
+    if (u[0] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,0);
+    break;
+  case 2:
+    if (u[1] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,1);
+    break;
+  case 1:
+    if (u[2] < 0) angle=-angle;
+    gl_M4_Rotate(&m,angle,2);
+    break;
+  default:
+    {
+      float cost, sint;
+
+      /* normalize vector */
+      float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2];
+      if (len == 0.0f) return;
+      len = 1.0f / sqrt(len);
+      u[0] *= len;
+      u[1] *= len;
+      u[2] *= len;
+
+      /* store cos and sin values */
+      cost=cos(angle);
+      sint=sin(angle);
+
+      /* fill in the values */
+      m.m[3][0]=m.m[3][1]=m.m[3][2]=
+        m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f;
+      m.m[3][3]=1.0f;
+
+      /* do the math */
+      m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]);
+      m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint;
+      m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint;
+      m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint;
+      m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]);
+      m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint;
+      m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint;
+      m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint;
+      m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]);
+    }
+  }
+
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+
+  gl_matrix_update(c);
+}
+
+void glopScale(GLContext *c,GLParam *p)
+{
+  float *m;
+  float x=p[1].f,y=p[2].f,z=p[3].f;
+
+  m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
+
+  m[0] *= x;   m[1] *= y;   m[2]  *= z;
+  m[4] *= x;   m[5] *= y;   m[6]  *= z;
+  m[8] *= x;   m[9] *= y;   m[10] *= z;
+  m[12] *= x;   m[13] *= y;   m[14] *= z;
+  gl_matrix_update(c);
+}
+
+void glopTranslate(GLContext *c,GLParam *p)
+{
+  float *m;
+  float x=p[1].f,y=p[2].f,z=p[3].f;
+
+  m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
+
+  m[3] = m[0] * x + m[1] * y + m[2]  * z + m[3];
+  m[7] = m[4] * x + m[5] * y + m[6]  * z + m[7];
+  m[11] = m[8] * x + m[9] * y + m[10] * z + m[11];
+  m[15] = m[12] * x + m[13] * y + m[14] * z + m[15];
+
+  gl_matrix_update(c);
+}
+
+
+void glopFrustum(GLContext *c,GLParam *p)
+{
+  float *r;
+  M4 m;
+  float left=p[1].f;
+  float right=p[2].f;
+  float bottom=p[3].f;
+  float top=p[4].f;
+  float near=p[5].f;
+  float farp=p[6].f;
+  float x,y,A,B,C,D;
+
+  x = (2.0*near) / (right-left);
+  y = (2.0*near) / (top-bottom);
+  A = (right+left) / (right-left);
+  B = (top+bottom) / (top-bottom);
+  C = -(farp+near) / ( farp-near);
+  D = -(2.0*farp*near) / (farp-near);
+
+  r=&m.m[0][0];
+  r[0]= x; r[1]=0; r[2]=A; r[3]=0;
+  r[4]= 0; r[5]=y; r[6]=B; r[7]=0;
+  r[8]= 0; r[9]=0; r[10]=C; r[11]=D;
+  r[12]= 0; r[13]=0; r[14]=-1; r[15]=0;
+
+  gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
+
+  gl_matrix_update(c);
+}
+  

programs/develop/libraries/TinyGL/src/misc.c

@@ -0,0 +1,147 @@
+#include "zgl.h"
+#include "msghandling.h"
+
+void glopViewport(GLContext *c,GLParam *p)
+{
+  int xsize,ysize,xmin,ymin,xsize_req,ysize_req;
+  
+  xmin=p[1].i;
+  ymin=p[2].i;
+  xsize=p[3].i;
+  ysize=p[4].i;
+
+  /* we may need to resize the zbuffer */
+
+  if (c->viewport.xmin != xmin ||
+      c->viewport.ymin != ymin ||
+      c->viewport.xsize != xsize ||
+      c->viewport.ysize != ysize) {
+
+    xsize_req=xmin+xsize;
+    ysize_req=ymin+ysize;
+
+    if (c->gl_resize_viewport && 
+        c->gl_resize_viewport(c,&xsize_req,&ysize_req) != 0) {
+      gl_fatal_error("glViewport: error while resizing display");
+    }
+
+    xsize=xsize_req-xmin;
+    ysize=ysize_req-ymin;
+    if (xsize <= 0 || ysize <= 0) {
+      gl_fatal_error("glViewport: size too small");
+    }
+
+    tgl_trace("glViewport: %d %d %d %d\n",
+              xmin, ymin, xsize, ysize);
+    c->viewport.xmin=xmin;
+    c->viewport.ymin=ymin;
+    c->viewport.xsize=xsize;
+    c->viewport.ysize=ysize;
+    
+    c->viewport.updated=1;
+  }
+}
+
+void glopEnableDisable(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  int v=p[2].i;
+
+  switch(code) {
+  case GL_CULL_FACE:
+    c->cull_face_enabled=v;
+    break;
+  case GL_LIGHTING:
+    c->lighting_enabled=v;
+    break;
+  case GL_COLOR_MATERIAL:
+    c->color_material_enabled=v;
+      break;
+  case GL_TEXTURE_2D:
+    c->texture_2d_enabled=v;
+    break;
+  case GL_NORMALIZE:
+    c->normalize_enabled=v;
+    break;
+  case GL_DEPTH_TEST:
+    c->depth_test = v;
+    break;
+  case GL_POLYGON_OFFSET_FILL:
+    if (v) c->offset_states |= TGL_OFFSET_FILL;
+    else c->offset_states &= ~TGL_OFFSET_FILL;
+    break; 
+  case GL_POLYGON_OFFSET_POINT:
+    if (v) c->offset_states |= TGL_OFFSET_POINT;
+    else c->offset_states &= ~TGL_OFFSET_POINT;
+    break; 
+  case GL_POLYGON_OFFSET_LINE:
+    if (v) c->offset_states |= TGL_OFFSET_LINE;
+    else c->offset_states &= ~TGL_OFFSET_LINE;
+    break; 
+  default:
+    if (code>=GL_LIGHT0 && code<GL_LIGHT0+MAX_LIGHTS) {
+      gl_enable_disable_light(c,code - GL_LIGHT0, v);
+    } else {
+      /*
+      fprintf(stderr,"glEnableDisable: 0x%X not supported.\n",code);
+      */
+    }
+    break;
+  }
+}
+
+void glopShadeModel(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_shade_model=code;
+}
+
+void glopCullFace(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_cull_face=code;
+}
+
+void glopFrontFace(GLContext *c,GLParam *p)
+{
+  int code=p[1].i;
+  c->current_front_face=code;
+}
+
+void glopPolygonMode(GLContext *c,GLParam *p)
+{
+  int face=p[1].i;
+  int mode=p[2].i;
+  
+  switch(face) {
+  case GL_BACK:
+    c->polygon_mode_back=mode;
+    break;
+  case GL_FRONT:
+    c->polygon_mode_front=mode;
+    break;
+  case GL_FRONT_AND_BACK:
+    c->polygon_mode_front=mode;
+    c->polygon_mode_back=mode;
+    break;
+  default:
+    assert(0);
+  }
+}
+
+void glopHint(GLContext *c,GLParam *p)
+{
+#if 0
+  int target=p[1].i;
+  int mode=p[2].i;
+
+  /* do nothing */
+#endif
+}
+
+void 
+glopPolygonOffset(GLContext *c, GLParam *p)
+{
+  c->offset_factor = p[1].f;
+  c->offset_units = p[2].f;
+}

programs/develop/libraries/TinyGL/src/msghandling.c

@@ -0,0 +1,52 @@
+#include <stdarg.h>
+#include <stdio.h>
+
+#define NDEBUG
+
+#ifdef NDEBUG
+#define NO_DEBUG_OUTPUT
+#endif
+
+/* Use this function to output messages when something unexpected
+   happens (which might be an indication of an error). *Don't* use it
+   when there's internal errors in the code - these should be handled
+   by asserts. */
+void
+tgl_warning(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*WARNING* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}
+
+/* This function should be used for debug output only. */
+void
+tgl_trace(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*DEBUG* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}
+
+/* Use this function to output info about things in the code which
+   should be fixed (missing handling of special cases, important
+   features not implemented, known bugs/buglets, ...). */
+void
+tgl_fixme(const char *format, ...)
+{
+#ifndef NO_DEBUG_OUTPUT
+  va_list args;
+  va_start(args, format);
+  fprintf(stderr, "*FIXME* ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+#endif /* !NO_DEBUG_OUTPUT */
+}

programs/develop/libraries/TinyGL/src/msghandling.h

@@ -0,0 +1,8 @@
+#ifndef _msghandling_h_
+#define _msghandling_h_
+
+extern void tgl_warning(const char *text, ...);
+extern void tgl_trace(const char *text, ...);
+extern void tgl_fixme(const char *text, ...);
+
+#endif /* _msghandling_h_ */

programs/develop/libraries/TinyGL/src/opinfo.h

@@ -0,0 +1,71 @@
+
+
+ADD_OP(Color,7,"%f %f %f %f %d %d %d")
+ADD_OP(TexCoord,4,"%f %f %f %f")
+ADD_OP(EdgeFlag,1,"%d")
+ADD_OP(Normal,3,"%f %f %f")
+
+ADD_OP(Begin,1,"%C")
+ADD_OP(Vertex,4,"%f %f %f %f")
+ADD_OP(End,0,"")
+
+ADD_OP(EnableDisable,2,"%C %d")
+
+ADD_OP(MatrixMode,1,"%C")
+ADD_OP(LoadMatrix,16,"")
+ADD_OP(LoadIdentity,0,"")
+ADD_OP(MultMatrix,16,"")
+ADD_OP(PushMatrix,0,"")
+ADD_OP(PopMatrix,0,"")
+ADD_OP(Rotate,4,"%f %f %f %f")
+ADD_OP(Translate,3,"%f %f %f")
+ADD_OP(Scale,3,"%f %f %f")
+
+ADD_OP(Viewport,4,"%d %d %d %d")
+ADD_OP(Frustum,6,"%f %f %f %f %f %f")
+
+ADD_OP(Material,6,"%C %C %f %f %f %f")
+ADD_OP(ColorMaterial,2,"%C %C")
+ADD_OP(Light,6,"%C %C %f %f %f %f")
+ADD_OP(LightModel,5,"%C %f %f %f %f")
+
+ADD_OP(Clear,1,"%d")
+ADD_OP(ClearColor,4,"%f %f %f %f")
+ADD_OP(ClearDepth,1,"%f")
+
+ADD_OP(InitNames,0,"")
+ADD_OP(PushName,1,"%d")
+ADD_OP(PopName,0,"")
+ADD_OP(LoadName,1,"%d")
+
+ADD_OP(TexImage2D,9,"%d %d %d %d %d %d %d %d %d")
+ADD_OP(BindTexture,2,"%C %d")
+ADD_OP(TexEnv,7,"%C %C %C %f %f %f %f")
+ADD_OP(TexParameter,7,"%C %C %C %f %f %f %f")
+ADD_OP(PixelStore,2,"%C %C")
+
+ADD_OP(ShadeModel,1,"%C")
+ADD_OP(CullFace,1,"%C")
+ADD_OP(FrontFace,1,"%C")
+ADD_OP(PolygonMode,2,"%C %C")
+
+ADD_OP(CallList,1,"%d")
+ADD_OP(Hint,2,"%C %C")
+
+/* special opcodes */
+ADD_OP(EndList,0,"")
+ADD_OP(NextBuffer,1,"%p")
+
+/* opengl 1.1 arrays */
+ADD_OP(ArrayElement, 1, "%d")
+ADD_OP(EnableClientState, 1, "%C")
+ADD_OP(DisableClientState, 1, "%C")
+ADD_OP(VertexPointer, 4, "%d %C %d %p")
+ADD_OP(ColorPointer, 4, "%d %C %d %p")
+ADD_OP(NormalPointer, 3, "%C %d %p")
+ADD_OP(TexCoordPointer, 4, "%d %C %d %p")
+
+/* opengl 1.1 polygon offset */
+ADD_OP(PolygonOffset, 2, "%f %f")
+
+#undef ADD_OP

programs/develop/libraries/TinyGL/src/select.c

@@ -0,0 +1,114 @@
+#include "zgl.h"
+
+int glRenderMode(int mode)
+{
+  GLContext *c=gl_get_context();
+  int result=0;
+  
+  switch(c->render_mode) {
+  case GL_RENDER:
+    break;
+  case GL_SELECT:
+    if (c->select_overflow) {
+      result=-c->select_hits;
+    } else {
+      result=c->select_hits;
+    }
+    c->select_overflow=0;
+    c->select_ptr=c->select_buffer;
+    c->name_stack_size=0;
+    break;
+  default:
+    assert(0);
+  }
+  switch(mode) {
+  case GL_RENDER:
+    c->render_mode=GL_RENDER;
+    break;
+  case GL_SELECT:
+    c->render_mode=GL_SELECT;
+    assert( c->select_buffer != NULL);
+    c->select_ptr=c->select_buffer;
+    c->select_hits=0;
+    c->select_overflow=0;
+    c->select_hit=NULL;
+    break;
+  default:
+    assert(0);
+  }
+  return result;
+}
+
+void glSelectBuffer(int size,unsigned int *buf)
+{
+  GLContext *c=gl_get_context();
+
+  assert(c->render_mode != GL_SELECT);
+  
+  c->select_buffer=buf;
+  c->select_size=size;
+}
+
+
+void glopInitNames(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    c->name_stack_size=0;
+    c->select_hit=NULL;
+  }
+}
+
+void glopPushName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    assert(c->name_stack_size<MAX_NAME_STACK_DEPTH);
+    c->name_stack[c->name_stack_size++]=p[1].i;
+    c->select_hit=NULL;
+  }
+}
+
+void glopPopName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+    assert(c->name_stack_size>0);
+    c->name_stack_size--;
+    c->select_hit=NULL;
+  }
+}
+
+void glopLoadName(GLContext *c,GLParam *p)
+{
+  if (c->render_mode == GL_SELECT) {
+   assert(c->name_stack_size>0);
+   c->name_stack[c->name_stack_size-1]=p[1].i;
+   c->select_hit=NULL;
+  }
+}
+
+void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax)
+{
+  unsigned int *ptr;
+  int n,i;
+
+  if (!c->select_overflow) {
+    if (c->select_hit==NULL) {
+      n=c->name_stack_size;
+      if ((c->select_ptr-c->select_buffer+3+n) > 
+	  c->select_size) {
+	c->select_overflow=1;
+      } else {
+	ptr=c->select_ptr;
+	c->select_hit=ptr;
+	*ptr++=c->name_stack_size;
+	*ptr++=zmin;
+	*ptr++=zmax;
+	for(i=0;i<n;i++) *ptr++=c->name_stack[i];
+	c->select_ptr=ptr;
+	c->select_hits++;
+      }
+    } else {
+      if (zmin<c->select_hit[1]) c->select_hit[1]=zmin;
+      if (zmax>c->select_hit[2]) c->select_hit[2]=zmax;
+    }
+  }
+}

programs/develop/libraries/TinyGL/src/specbuf.c

@@ -0,0 +1,52 @@
+#include "zgl.h"
+#include "msghandling.h"
+#include <math.h>
+#include <stdlib.h>
+
+static void calc_buf(GLSpecBuf *buf, const float shininess)
+{
+  int i;
+  float val, inc;
+  val = 0.0f;
+  inc = 1.0f/SPECULAR_BUFFER_SIZE;
+  for (i = 0; i <= SPECULAR_BUFFER_SIZE; i++) {
+    buf->buf[i] = pow(val, shininess);
+    val += inc;
+  }
+}
+
+GLSpecBuf *
+specbuf_get_buffer(GLContext *c, const int shininess_i, 
+                   const float shininess)
+{
+  GLSpecBuf *found, *oldest;
+  found = oldest = c->specbuf_first;
+  while (found && found->shininess_i != shininess_i) {
+    if (found->last_used < oldest->last_used) {
+      oldest = found;
+    }
+    found = found->next; 
+  }
+  if (found) { /* hey, found one! */
+    found->last_used = c->specbuf_used_counter++;
+    return found;
+  }
+  if (oldest == NULL || c->specbuf_num_buffers < MAX_SPECULAR_BUFFERS) {
+    /* create new buffer */
+    GLSpecBuf *buf = gl_malloc(sizeof(GLSpecBuf));
+    if (!buf) gl_fatal_error("could not allocate specular buffer");
+    c->specbuf_num_buffers++;
+    buf->next = c->specbuf_first;
+    c->specbuf_first = buf;
+    buf->last_used = c->specbuf_used_counter++;
+    buf->shininess_i = shininess_i;
+    calc_buf(buf, shininess);
+    return buf;     
+  }
+  /* overwrite the lru buffer */
+  /*tgl_trace("overwriting spec buffer :(\n");*/
+  oldest->shininess_i = shininess_i;
+  oldest->last_used = c->specbuf_used_counter++;
+  calc_buf(oldest, shininess);
+  return oldest;
+}

programs/develop/libraries/TinyGL/src/specbuf.h

@@ -0,0 +1,22 @@
+#ifndef _tgl_specbuf_h_
+#define _tgl_specbuf_h_
+
+/* Max # of specular light pow buffers */
+#define MAX_SPECULAR_BUFFERS 8
+/* # of entries in specular buffer */
+#define SPECULAR_BUFFER_SIZE 1024
+/* specular buffer granularity */
+#define SPECULAR_BUFFER_RESOLUTION 1024
+
+typedef struct GLSpecBuf {
+  int shininess_i;
+  int last_used;
+  float buf[SPECULAR_BUFFER_SIZE+1];
+  struct GLSpecBuf *next;
+} GLSpecBuf;
+
+GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, 
+                              const float shininess);
+void specbuf_cleanup(GLContext *c); /* free all memory used */
+
+#endif /* _tgl_specbuf_h_ */

programs/develop/libraries/TinyGL/src/texture.c

@@ -0,0 +1,229 @@
+/*
+ * Texture Manager
+ */
+
+#include "zgl.h"
+
+static GLTexture *find_texture(GLContext *c,int h)
+{
+  GLTexture *t;
+
+  t=c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE];
+  while (t!=NULL) {
+    if (t->handle == h) return t;
+    t=t->next;
+  }
+  return NULL;
+}
+
+static void free_texture(GLContext *c,int h)
+{
+  GLTexture *t,**ht;
+  GLImage *im;
+  int i;
+
+  t=find_texture(c,h);
+  if (t->prev==NULL) {
+    ht=&c->shared_state.texture_hash_table
+      [t->handle % TEXTURE_HASH_TABLE_SIZE];
+    *ht=t->next;
+  } else {
+    t->prev->next=t->next;
+  }
+  if (t->next!=NULL) t->next->prev=t->prev;
+
+  for(i=0;i<MAX_TEXTURE_LEVELS;i++) {
+    im=&t->images[i];
+    if (im->pixmap != NULL) gl_free(im->pixmap);
+  }
+
+  gl_free(t);
+}
+
+GLTexture *alloc_texture(GLContext *c,int h)
+{
+  GLTexture *t,**ht;
+  
+  t=gl_zalloc(sizeof(GLTexture));
+
+  ht=&c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE];
+
+  t->next=*ht;
+  t->prev=NULL;
+  if (t->next != NULL) t->next->prev=t;
+  *ht=t;
+
+  t->handle=h;
+  
+  return t;
+}
+
+
+void glInitTextures(GLContext *c)
+{
+  /* textures */
+
+  c->texture_2d_enabled=0;
+  c->current_texture=find_texture(c,0);
+}
+
+void glGenTextures(int n, unsigned int *textures)
+{
+  GLContext *c=gl_get_context();
+  int max,i;
+  GLTexture *t;
+
+  max=0;
+  for(i=0;i<TEXTURE_HASH_TABLE_SIZE;i++) {
+    t=c->shared_state.texture_hash_table[i];
+    while (t!=NULL) {
+      if (t->handle>max) max=t->handle;
+      t=t->next;
+    }
+
+  }
+  for(i=0;i<n;i++) {
+    textures[i]=max+i+1;
+  }
+}
+
+
+void glDeleteTextures(int n, const unsigned int *textures)
+{
+  GLContext *c=gl_get_context();
+  int i;
+  GLTexture *t;
+
+  for(i=0;i<n;i++) {
+    t=find_texture(c,textures[i]);
+    if (t!=NULL && t!=0) {
+      if (t==c->current_texture) {
+	glBindTexture(GL_TEXTURE_2D,0);
+      }
+      free_texture(c,textures[i]);
+    }
+  }
+}
+
+
+void glopBindTexture(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int texture=p[2].i;
+  GLTexture *t;
+
+  assert(target == GL_TEXTURE_2D && texture >= 0);
+
+  t=find_texture(c,texture);
+  if (t==NULL) {
+    t=alloc_texture(c,texture);
+  }
+  c->current_texture=t;
+}
+
+void glopTexImage2D(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int level=p[2].i;
+  int components=p[3].i;
+  int width=p[4].i;
+  int height=p[5].i;
+  int border=p[6].i;
+  int format=p[7].i;
+  int type=p[8].i;
+  void *pixels=p[9].p;
+  GLImage *im;
+  unsigned char *pixels1;
+  int do_free;
+
+  if (!(target == GL_TEXTURE_2D && level == 0 && components == 3 && 
+        border == 0 && format == GL_RGB &&
+        type == GL_UNSIGNED_BYTE)) {
+    gl_fatal_error("glTexImage2D: combinaison of parameters not handled");
+  }
+  
+  do_free=0;
+  if (width != 256 || height != 256) {
+    pixels1 = gl_malloc(256 * 256 * 3);
+    /* no interpolation is done here to respect the original image aliasing ! */
+    gl_resizeImageNoInterpolate(pixels1,256,256,pixels,width,height);
+    do_free=1;
+    width=256;
+    height=256;
+  } else {
+    pixels1=pixels;
+  }
+
+  im=&c->current_texture->images[level];
+  im->xsize=width;
+  im->ysize=height;
+  if (im->pixmap!=NULL) gl_free(im->pixmap);
+#if TGL_FEATURE_RENDER_BITS == 24 
+  im->pixmap=gl_malloc(width*height*3);
+  if(im->pixmap) {
+      memcpy(im->pixmap,pixels1,width*height*3);
+  }
+#elif TGL_FEATURE_RENDER_BITS == 32
+  im->pixmap=gl_malloc(width*height*4);
+  if(im->pixmap) {
+      gl_convertRGB_to_8A8R8G8B(im->pixmap,pixels1,width,height);
+  }
+#elif TGL_FEATURE_RENDER_BITS == 16
+  im->pixmap=gl_malloc(width*height*2);
+  if(im->pixmap) {
+      gl_convertRGB_to_5R6G5B(im->pixmap,pixels1,width,height);
+  }
+#else
+#error TODO
+#endif
+  if (do_free) gl_free(pixels1);
+}
+
+
+/* TODO: not all tests are done */
+void glopTexEnv(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int pname=p[2].i;
+  int param=p[3].i;
+
+  if (target != GL_TEXTURE_ENV) {
+  error:
+    gl_fatal_error("glTexParameter: unsupported option");
+  }
+
+  if (pname != GL_TEXTURE_ENV_MODE) goto error;
+
+  if (param != GL_DECAL) goto error;
+}
+
+/* TODO: not all tests are done */
+void glopTexParameter(GLContext *c,GLParam *p)
+{
+  int target=p[1].i;
+  int pname=p[2].i;
+  int param=p[3].i;
+  
+  if (target != GL_TEXTURE_2D) {
+  error:
+    gl_fatal_error("glTexParameter: unsupported option");
+  }
+
+  switch(pname) {
+  case GL_TEXTURE_WRAP_S:
+  case GL_TEXTURE_WRAP_T:
+    if (param != GL_REPEAT) goto error;
+    break;
+  }
+}
+
+void glopPixelStore(GLContext *c,GLParam *p)
+{
+  int pname=p[1].i;
+  int param=p[2].i;
+
+  if (pname != GL_UNPACK_ALIGNMENT ||
+      param != 1) {
+    gl_fatal_error("glPixelStore: unsupported option");
+  }
+}

programs/develop/libraries/TinyGL/src/vertex.c

@@ -0,0 +1,364 @@
+#include "zgl.h"
+
+void glopNormal(GLContext * c, GLParam * p)
+{
+    V3 v;
+
+    v.X = p[1].f;
+    v.Y = p[2].f;
+    v.Z = p[3].f;
+
+    c->current_normal.X = v.X;
+    c->current_normal.Y = v.Y;
+    c->current_normal.Z = v.Z;
+    c->current_normal.W = 0;
+}
+
+void glopTexCoord(GLContext * c, GLParam * p)
+{
+    c->current_tex_coord.X = p[1].f;
+    c->current_tex_coord.Y = p[2].f;
+    c->current_tex_coord.Z = p[3].f;
+    c->current_tex_coord.W = p[4].f;
+}
+
+void glopEdgeFlag(GLContext * c, GLParam * p)
+{
+    c->current_edge_flag = p[1].i;
+}
+
+void glopColor(GLContext * c, GLParam * p)
+{
+
+    c->current_color.X = p[1].f;
+    c->current_color.Y = p[2].f;
+    c->current_color.Z = p[3].f;
+    c->current_color.W = p[4].f;
+    c->longcurrent_color[0] = p[5].ui;
+    c->longcurrent_color[1] = p[6].ui;
+    c->longcurrent_color[2] = p[7].ui;
+
+    if (c->color_material_enabled) {
+	GLParam q[7];
+	q[0].op = OP_Material;
+	q[1].i = c->current_color_material_mode;
+	q[2].i = c->current_color_material_type;
+	q[3].f = p[1].f;
+	q[4].f = p[2].f;
+	q[5].f = p[3].f;
+	q[6].f = p[4].f;
+	glopMaterial(c, q);
+    }
+}
+
+
+void gl_eval_viewport(GLContext * c)
+{
+    GLViewport *v;
+    float zsize = (1 << (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS));
+
+    v = &c->viewport;
+
+    v->trans.X = ((v->xsize - 0.5) / 2.0) + v->xmin;
+    v->trans.Y = ((v->ysize - 0.5) / 2.0) + v->ymin;
+    v->trans.Z = ((zsize - 0.5) / 2.0) + ((1 << ZB_POINT_Z_FRAC_BITS)) / 2;
+
+    v->scale.X = (v->xsize - 0.5) / 2.0;
+    v->scale.Y = -(v->ysize - 0.5) / 2.0;
+    v->scale.Z = -((zsize - 0.5) / 2.0);
+}
+
+void glopBegin(GLContext * c, GLParam * p)
+{
+    int type;
+    M4 tmp;
+
+    assert(c->in_begin == 0);
+
+    type = p[1].i;
+    c->begin_type = type;
+    c->in_begin = 1;
+    c->vertex_n = 0;
+    c->vertex_cnt = 0;
+
+    if (c->matrix_model_projection_updated) {
+
+	if (c->lighting_enabled) {
+	    /* precompute inverse modelview */
+	    gl_M4_Inv(&tmp, c->matrix_stack_ptr[0]);
+	    gl_M4_Transpose(&c->matrix_model_view_inv, &tmp);
+	} else {
+	    float *m = &c->matrix_model_projection.m[0][0];
+	    /* precompute projection matrix */
+	    gl_M4_Mul(&c->matrix_model_projection,
+		      c->matrix_stack_ptr[1],
+		      c->matrix_stack_ptr[0]);
+	    /* test to accelerate computation */
+	    c->matrix_model_projection_no_w_transform = 0;
+	    if (m[12] == 0.0 && m[13] == 0.0 && m[14] == 0.0)
+		c->matrix_model_projection_no_w_transform = 1;
+	}
+
+	/* test if the texture matrix is not Identity */
+	c->apply_texture_matrix = !gl_M4_IsId(c->matrix_stack_ptr[2]);
+
+	c->matrix_model_projection_updated = 0;
+    }
+    /*  viewport */
+    if (c->viewport.updated) {
+	gl_eval_viewport(c);
+	c->viewport.updated = 0;
+    }
+    /* triangle drawing functions */
+    if (c->render_mode == GL_SELECT) {
+	c->draw_triangle_front = gl_draw_triangle_select;
+	c->draw_triangle_back = gl_draw_triangle_select;
+    } else {
+	switch (c->polygon_mode_front) {
+	case GL_POINT:
+	    c->draw_triangle_front = gl_draw_triangle_point;
+	    break;
+	case GL_LINE:
+	    c->draw_triangle_front = gl_draw_triangle_line;
+	    break;
+	default:
+	    c->draw_triangle_front = gl_draw_triangle_fill;
+	    break;
+	}
+
+	switch (c->polygon_mode_back) {
+	case GL_POINT:
+	    c->draw_triangle_back = gl_draw_triangle_point;
+	    break;
+	case GL_LINE:
+	    c->draw_triangle_back = gl_draw_triangle_line;
+	    break;
+	default:
+	    c->draw_triangle_back = gl_draw_triangle_fill;
+	    break;
+	}
+    }
+}
+
+/* coords, tranformation , clip code and projection */
+/* TODO : handle all cases */
+static inline void gl_vertex_transform(GLContext * c, GLVertex * v)
+{
+    float *m;
+    V4 *n;
+
+    if (c->lighting_enabled) {
+	/* eye coordinates needed for lighting */
+
+	m = &c->matrix_stack_ptr[0]->m[0][0];
+	v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
+		   v->coord.Z * m[2] + m[3]);
+	v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
+		   v->coord.Z * m[6] + m[7]);
+	v->ec.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
+		   v->coord.Z * m[10] + m[11]);
+	v->ec.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
+		   v->coord.Z * m[14] + m[15]);
+
+	/* projection coordinates */
+	m = &c->matrix_stack_ptr[1]->m[0][0];
+	v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] +
+		   v->ec.Z * m[2] + v->ec.W * m[3]);
+	v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] +
+		   v->ec.Z * m[6] + v->ec.W * m[7]);
+	v->pc.Z = (v->ec.X * m[8] + v->ec.Y * m[9] +
+		   v->ec.Z * m[10] + v->ec.W * m[11]);
+	v->pc.W = (v->ec.X * m[12] + v->ec.Y * m[13] +
+		   v->ec.Z * m[14] + v->ec.W * m[15]);
+
+	m = &c->matrix_model_view_inv.m[0][0];
+	n = &c->current_normal;
+
+	v->normal.X = (n->X * m[0] + n->Y * m[1] + n->Z * m[2]);
+	v->normal.Y = (n->X * m[4] + n->Y * m[5] + n->Z * m[6]);
+	v->normal.Z = (n->X * m[8] + n->Y * m[9] + n->Z * m[10]);
+
+	if (c->normalize_enabled) {
+	    gl_V3_Norm(&v->normal);
+	}
+    } else {
+	/* no eye coordinates needed, no normal */
+	/* NOTE: W = 1 is assumed */
+	m = &c->matrix_model_projection.m[0][0];
+
+	v->pc.X = (v->coord.X * m[0] + v->coord.Y * m[1] +
+		   v->coord.Z * m[2] + m[3]);
+	v->pc.Y = (v->coord.X * m[4] + v->coord.Y * m[5] +
+		   v->coord.Z * m[6] + m[7]);
+	v->pc.Z = (v->coord.X * m[8] + v->coord.Y * m[9] +
+		   v->coord.Z * m[10] + m[11]);
+	if (c->matrix_model_projection_no_w_transform) {
+	    v->pc.W = m[15];
+	} else {
+	    v->pc.W = (v->coord.X * m[12] + v->coord.Y * m[13] +
+		       v->coord.Z * m[14] + m[15]);
+	}
+    }
+
+    v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W);
+}
+
+void glopVertex(GLContext * c, GLParam * p)
+{
+    GLVertex *v;
+    int n, i, cnt;
+
+    assert(c->in_begin != 0);
+
+    n = c->vertex_n;
+    cnt = c->vertex_cnt;
+    cnt++;
+    c->vertex_cnt = cnt;
+
+    /* quick fix to avoid crashes on large polygons */
+    if (n >= c->vertex_max) {
+	GLVertex *newarray;
+	c->vertex_max <<= 1;	/* just double size */
+	newarray = gl_malloc(sizeof(GLVertex) * c->vertex_max);
+	if (!newarray) {
+	    gl_fatal_error("unable to allocate GLVertex array.\n");
+	}
+	memcpy(newarray, c->vertex, n * sizeof(GLVertex));
+	gl_free(c->vertex);
+	c->vertex = newarray;
+    }
+    /* new vertex entry */
+    v = &c->vertex[n];
+    n++;
+
+    v->coord.X = p[1].f;
+    v->coord.Y = p[2].f;
+    v->coord.Z = p[3].f;
+    v->coord.W = p[4].f;
+
+    gl_vertex_transform(c, v);
+
+    /* color */
+
+    if (c->lighting_enabled) {
+	gl_shade_vertex(c, v);
+    } else {
+	v->color = c->current_color;
+    }
+
+    /* tex coords */
+
+    if (c->texture_2d_enabled) {
+	if (c->apply_texture_matrix) {
+	    gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);
+	} else {
+	    v->tex_coord = c->current_tex_coord;
+	}
+    }
+    /* precompute the mapping to the viewport */
+    if (v->clip_code == 0)
+	gl_transform_to_viewport(c, v);
+
+	/* edge flag */
+
+    v->edge_flag = c->current_edge_flag;
+
+    switch (c->begin_type) {
+    case GL_POINTS:
+	gl_draw_point(c, &c->vertex[0]);
+	n = 0;
+	break;
+
+    case GL_LINES:
+	if (n == 2) {
+	    gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
+	    n = 0;
+	}
+	break;
+    case GL_LINE_STRIP:
+    case GL_LINE_LOOP:
+	if (n == 1) {
+	    c->vertex[2] = c->vertex[0];
+	} else if (n == 2) {
+	    gl_draw_line(c, &c->vertex[0], &c->vertex[1]);
+	    c->vertex[0] = c->vertex[1];
+	    n = 1;
+	}
+	break;
+
+    case GL_TRIANGLES:
+	if (n == 3) {
+		gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+	    n = 0;
+	}
+	break;
+    case GL_TRIANGLE_STRIP:
+	if (cnt >= 3) {
+	    if (n == 3)
+		n = 0;
+            /* needed to respect triangle orientation */
+            switch(cnt & 1) {
+            case 0:
+      		gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]);
+      		break;
+            default:
+            case 1:
+      		gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]);
+      		break;
+            }
+	}
+	break;
+    case GL_TRIANGLE_FAN:
+	if (n == 3) {
+	    gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+	    c->vertex[1] = c->vertex[2];
+	    n = 2;
+	}
+	break;
+
+    case GL_QUADS:
+	if (n == 4) {
+	    c->vertex[2].edge_flag = 0;
+	    gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+	    c->vertex[2].edge_flag = 1;
+	    c->vertex[0].edge_flag = 0;
+	    gl_draw_triangle(c, &c->vertex[0], &c->vertex[2], &c->vertex[3]);
+	    n = 0;
+	}
+	break;
+
+    case GL_QUAD_STRIP:
+	if (n == 4) {
+	    gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]);
+	    gl_draw_triangle(c, &c->vertex[1], &c->vertex[3], &c->vertex[2]);
+	    for (i = 0; i < 2; i++)
+		c->vertex[i] = c->vertex[i + 2];
+	    n = 2;
+	}
+	break;
+    case GL_POLYGON:
+	break;
+    default:
+	gl_fatal_error("glBegin: type %x not handled\n", c->begin_type);
+    }
+
+    c->vertex_n = n;
+}
+
+void glopEnd(GLContext * c, GLParam * param)
+{
+    assert(c->in_begin == 1);
+
+    if (c->begin_type == GL_LINE_LOOP) {
+	if (c->vertex_cnt >= 3) {
+	    gl_draw_line(c, &c->vertex[0], &c->vertex[2]);
+	}
+    } else if (c->begin_type == GL_POLYGON) {
+	int i = c->vertex_cnt;
+	while (i >= 3) {
+	    i--;
+	    gl_draw_triangle(c, &c->vertex[i], &c->vertex[0], &c->vertex[i - 1]);
+	}
+    }
+    c->in_begin = 0;
+}

programs/develop/libraries/TinyGL/src/zbuffer.c

@@ -0,0 +1,509 @@
+/*
+
+ * Z buffer: 16 bits Z / 16 bits color
+ * 
+ */
+#include <stdlib.h>
+#include <stdio.h>
+/*#include <assert.h>*/
+#include <string.h>
+#include "zbuffer.h"
+
+ZBuffer *ZB_open(int xsize, int ysize, int mode,
+		 int nb_colors,
+		 unsigned char *color_indexes,
+		 int *color_table,
+		 void *frame_buffer)
+{
+    ZBuffer *zb;
+    int size;
+
+    zb = gl_malloc(sizeof(ZBuffer));
+    if (zb == NULL)
+	return NULL;
+
+    zb->xsize = xsize;
+    zb->ysize = ysize;
+    zb->mode = mode;
+    zb->linesize = (xsize * PSZB + 3) & ~3;
+
+    switch (mode) {
+#ifdef TGL_FEATURE_8_BITS
+    case ZB_MODE_INDEX:
+	ZB_initDither(zb, nb_colors, color_indexes, color_table);
+	break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+#endif
+    case ZB_MODE_5R6G5B:
+	zb->nb_colors = 0;
+	break;
+    default:
+	goto error;
+    }
+
+    size = zb->xsize * zb->ysize * sizeof(unsigned short);
+
+    zb->zbuf = gl_malloc(size);
+    if (zb->zbuf == NULL)
+	goto error;
+
+	zb->frame_buffer_allocated = 0;
+	zb->pbuf = NULL;
+
+    zb->current_texture = NULL;
+
+    return zb;
+  error:
+    gl_free(zb);
+    return NULL;
+}
+
+void ZB_close(ZBuffer * zb)
+{
+#ifdef TGL_FEATURE_8_BITS
+    if (zb->mode == ZB_MODE_INDEX)
+	ZB_closeDither(zb);
+#endif
+
+    if (zb->frame_buffer_allocated)
+	gl_free(zb->pbuf);
+
+    gl_free(zb->zbuf);
+    gl_free(zb);
+}
+
+void ZB_resize(ZBuffer * zb, void *frame_buffer, int xsize, int ysize)
+{
+    int size;
+
+    /* xsize must be a multiple of 4 */
+    xsize = xsize & ~3;
+
+    zb->xsize = xsize;
+    zb->ysize = ysize;
+    zb->linesize = (xsize * PSZB + 3) & ~3;
+
+    size = zb->xsize * zb->ysize * sizeof(unsigned short);
+
+    gl_free(zb->zbuf);
+    zb->zbuf = gl_malloc(size);
+
+    if (zb->frame_buffer_allocated)
+	gl_free(zb->pbuf);
+
+    if (frame_buffer == NULL) {
+	zb->pbuf = gl_malloc((zb->ysize+1) * (zb->linesize));
+	zb->frame_buffer_allocated = 1;
+    } else {
+	zb->pbuf = frame_buffer;
+	zb->frame_buffer_allocated = 0;
+    }
+}
+
+static void ZB_copyBuffer(ZBuffer * zb,
+                          void *buf,
+                          int linesize)
+{
+    unsigned char *p1;
+    PIXEL *q;
+    int y, n;
+
+    q = zb->pbuf;
+    p1 = buf;
+    n = zb->xsize * PSZB;
+    for (y = 0; y < zb->ysize; y++) {
+	memcpy(p1, q, n);
+	p1 += linesize;
+	q = (PIXEL *) ((char *) q + zb->linesize);
+    }
+}
+
+#if TGL_FEATURE_RENDER_BITS == 16
+
+/* 32 bpp copy */
+
+#ifdef TGL_FEATURE_32_BITS
+
+#define RGB16_TO_RGB32(p0,p1,v)\
+{\
+    unsigned int g,b,gb;\
+    g = (v & 0x07E007E0) << 5;\
+    b = (v & 0x001F001F) << 3;\
+    gb = g | b;\
+    p0 = (gb & 0x0000FFFF) | ((v & 0x0000F800) << 8);\
+    p1 = (gb >> 16) | ((v & 0xF8000000) >> 8);\
+}
+
+static void ZB_copyFrameBufferRGB32(ZBuffer * zb,
+                                    void *buf,
+                                    int linesize)
+{
+    unsigned short *q;
+    unsigned int *p, *p1, v, w0, w1;
+    int y, n;
+
+    q = zb->pbuf;
+    p1 = (unsigned int *) buf;
+
+    for (y = 0; y < zb->ysize; y++) {
+	p = p1;
+	n = zb->xsize >> 2;
+	do {
+	    v = *(unsigned int *) q;
+#if BYTE_ORDER == BIG_ENDIAN
+	    RGB16_TO_RGB32(w1, w0, v);
+#else
+	    RGB16_TO_RGB32(w0, w1, v);
+#endif
+	    p[0] = w0;
+	    p[1] = w1;
+
+	    v = *(unsigned int *) (q + 2);
+#if BYTE_ORDER == BIG_ENDIAN
+	    RGB16_TO_RGB32(w1, w0, v);
+#else
+	    RGB16_TO_RGB32(w0, w1, v);
+#endif
+	    p[2] = w0;
+	    p[3] = w1;
+
+	    q += 4;
+	    p += 4;
+	} while (--n > 0);
+
+	p1 += linesize;
+    }
+}
+
+#endif
+
+/* 24 bit packed pixel handling */
+
+#ifdef TGL_FEATURE_24_BITS
+
+/* order: RGBR GBRG BRGB */
+
+/* XXX: packed pixel 24 bit support not tested */
+/* XXX: big endian case not optimised */
+
+#if BYTE_ORDER == BIG_ENDIAN
+
+#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\
+{\
+    unsigned int r1,g1,b1,gb1,g2,b2,gb2;\
+    v1 = (v1 << 16) | (v1 >> 16);\
+    v2 = (v2 << 16) | (v2 >> 16);\
+    r1 = (v1 & 0xF800F800);\
+    g1 = (v1 & 0x07E007E0) << 5;\
+    b1 = (v1 & 0x001F001F) << 3;\
+    gb1 = g1 | b1;\
+    p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\
+    g2 = (v2 & 0x07E007E0) << 5;\
+    b2 = (v2 & 0x001F001F) << 3;\
+    gb2 = g2 | b2;\
+    p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\
+    p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\
+}
+
+#else
+
+#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\
+{\
+    unsigned int r1,g1,b1,gb1,g2,b2,gb2;\
+    r1 = (v1 & 0xF800F800);\
+    g1 = (v1 & 0x07E007E0) << 5;\
+    b1 = (v1 & 0x001F001F) << 3;\
+    gb1 = g1 | b1;\
+    p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\
+    g2 = (v2 & 0x07E007E0) << 5;\
+    b2 = (v2 & 0x001F001F) << 3;\
+    gb2 = g2 | b2;\
+    p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\
+    p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\
+}
+
+#endif
+
+static void ZB_copyFrameBufferRGB24(ZBuffer * zb,
+                                    void *buf,
+                                    int linesize)
+{
+    unsigned short *q;
+    unsigned int *p, *p1, w0, w1, w2, v0, v1;
+    int y, n;
+
+    q = zb->pbuf;
+    p1 = (unsigned int *) buf;
+    linesize = linesize * 3;
+
+    for (y = 0; y < zb->ysize; y++) {
+	p = p1;
+	n = zb->xsize >> 2;
+	do {
+	    v0 = *(unsigned int *) q;
+	    v1 = *(unsigned int *) (q + 2);
+	    RGB16_TO_RGB24(w0, w1, w2, v0, v1);
+	    p[0] = w0;
+	    p[1] = w1;
+	    p[2] = w2;
+
+	    q += 4;
+	    p += 3;
+	} while (--n > 0);
+
+	(char *) p1 += linesize;
+    }
+}
+
+#endif
+
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+			int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_8_BITS
+    case ZB_MODE_INDEX:
+	ZB_ditherFrameBuffer(zb, buf, linesize >> 1);
+	break;
+#endif
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+	ZB_copyBuffer(zb, buf, linesize);
+	break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+	ZB_copyFrameBufferRGB32(zb, buf, linesize >> 1);
+	break;
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+	ZB_copyFrameBufferRGB24(zb, buf, linesize >> 1);
+	break;
+#endif
+    default:
+	assert(0);
+    }
+}
+
+#endif /* TGL_FEATURE_RENDER_BITS == 16 */
+
+#if TGL_FEATURE_RENDER_BITS == 24
+
+#define RGB24_TO_RGB16(r, g, b) \
+  ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3))
+
+/* XXX: not optimized */
+static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, 
+                                     void *buf, int linesize) 
+{
+    PIXEL *q;
+    unsigned short *p, *p1;
+    int y, n;
+
+    q = zb->pbuf;
+    p1 = (unsigned short *) buf;
+
+    for (y = 0; y < zb->ysize; y++) {
+	p = p1;
+	n = zb->xsize >> 2;
+	do {
+            p[0] = RGB24_TO_RGB16(q[0], q[1], q[2]);
+            p[1] = RGB24_TO_RGB16(q[3], q[4], q[5]);
+            p[2] = RGB24_TO_RGB16(q[6], q[7], q[8]);
+            p[3] = RGB24_TO_RGB16(q[9], q[10], q[11]);
+	    q = (PIXEL *)((char *)q + 4 * PSZB);
+	    p += 4;
+	} while (--n > 0);
+	p1 = (unsigned short *)((char *)p1 + linesize);
+    }
+}
+
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+			int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+	ZB_copyFrameBuffer5R6G5B(zb, buf, linesize);
+	break;
+#endif
+#ifdef TGL_FEATURE_24_BITS
+    case ZB_MODE_RGB24:
+	ZB_copyBuffer(zb, buf, linesize);
+	break;
+#endif
+    default:
+	assert(0);
+    }
+}
+
+#endif /* TGL_FEATURE_RENDER_BITS == 24 */
+
+#if TGL_FEATURE_RENDER_BITS == 32
+
+#define RGB32_TO_RGB16(v) \
+  (((v >> 8) & 0xf800) | (((v) >> 5) & 0x07e0) | (((v) & 0xff) >> 3))
+
+/* XXX: not optimized */
+static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, 
+                                     void *buf, int linesize) 
+{
+    PIXEL *q;
+    unsigned short *p, *p1;
+    int y, n;
+
+    q = zb->pbuf;
+    p1 = (unsigned short *) buf;
+
+    for (y = 0; y < zb->ysize; y++) {
+	p = p1;
+	n = zb->xsize >> 2;
+	do {
+            p[0] = RGB32_TO_RGB16(q[0]);
+            p[1] = RGB32_TO_RGB16(q[1]);
+            p[2] = RGB32_TO_RGB16(q[2]);
+            p[3] = RGB32_TO_RGB16(q[3]);
+	    q += 4;
+	    p += 4;
+	} while (--n > 0);
+	p1 = (unsigned short *)((char *)p1 + linesize);
+    }
+}
+
+void ZB_copyFrameBuffer(ZBuffer * zb, void *buf,
+			int linesize)
+{
+    switch (zb->mode) {
+#ifdef TGL_FEATURE_16_BITS
+    case ZB_MODE_5R6G5B:
+	ZB_copyFrameBuffer5R6G5B(zb, buf, linesize);
+	break;
+#endif
+#ifdef TGL_FEATURE_32_BITS
+    case ZB_MODE_RGBA:
+	ZB_copyBuffer(zb, buf, linesize);
+	break;
+#endif
+    default:
+	assert(0);
+    }
+}
+
+#endif /* TGL_FEATURE_RENDER_BITS == 32 */
+
+
+/*
+ * adr must be aligned on an 'int'
+ */
+void memset_s(void *adr, int val, int count)
+{
+    int i, n, v;
+    unsigned int *p;
+    unsigned short *q;
+
+    p = adr;
+    v = val | (val << 16);
+
+    n = count >> 3;
+    for (i = 0; i < n; i++) {
+	p[0] = v;
+	p[1] = v;
+	p[2] = v;
+	p[3] = v;
+	p += 4;
+    }
+
+    q = (unsigned short *) p;
+    n = count & 7;
+    for (i = 0; i < n; i++)
+	*q++ = val;
+}
+
+void memset_l(void *adr, int val, int count)
+{
+    int i, n, v;
+    unsigned int *p;
+
+    p = adr;
+    v = val;
+    n = count >> 2;
+    for (i = 0; i < n; i++) {
+	p[0] = v;
+	p[1] = v;
+	p[2] = v;
+	p[3] = v;
+	p += 4;
+    }
+
+    n = count & 3;
+    for (i = 0; i < n; i++)
+	*p++ = val;
+}
+
+/* count must be a multiple of 4 and >= 4 */
+void memset_RGB24(void *adr,int r, int v, int b,long count)
+{
+    long i, n;
+    register long v1,v2,v3,*pt=(long *)(adr);
+    unsigned char *p,R=(unsigned char)r,V=(unsigned char)v,B=(unsigned char)b;
+
+    p=(unsigned char *)adr;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    *p++=R;
+    *p++=V;
+    *p++=B;
+    v1=*pt++;
+    v2=*pt++;
+    v3=*pt++;
+    n = count >> 2;
+    for(i=1;i<n;i++) {
+        *pt++=v1;
+        *pt++=v2;
+        *pt++=v3;
+    }
+}
+
+void ZB_clear(ZBuffer * zb, int clear_z, int z,
+	      int clear_color, int r, int g, int b)
+{
+#if TGL_FEATURE_RENDER_BITS != 24
+    int color;
+#endif
+    int y;
+    PIXEL *pp;
+
+    if (clear_z) {
+	memset_s(zb->zbuf, z, zb->xsize * zb->ysize);
+    }
+    if (clear_color) {
+	pp = zb->pbuf;
+	for (y = 0; y < zb->ysize; y++) {
+#if TGL_FEATURE_RENDER_BITS == 15 || TGL_FEATURE_RENDER_BITS == 16
+            color = RGB_TO_PIXEL(r, g, b);
+	    memset_s(pp, color, zb->xsize);
+#elif TGL_FEATURE_RENDER_BITS == 32
+            color = RGB_TO_PIXEL(r, g, b);
+	    memset_l(pp, color, zb->xsize);
+#elif TGL_FEATURE_RENDER_BITS == 24 
+            memset_RGB24(pp,r>>8,g>>8,b>>8,zb->xsize);
+#else
+#error TODO
+#endif
+	    pp = (PIXEL *) ((char *) pp + zb->linesize);
+	}
+    }
+}

programs/develop/libraries/TinyGL/src/zbuffer.h

@@ -0,0 +1,169 @@
+#ifndef _tgl_zbuffer_h_
+#define _tgl_zbuffer_h_
+
+/*
+ * Z buffer
+ */
+
+#include "zfeatures.h"
+
+#define ZB_Z_BITS 16
+
+#define ZB_POINT_Z_FRAC_BITS 14
+
+#define ZB_POINT_S_MIN ( (1<<13) )
+#define ZB_POINT_S_MAX ( (1<<22)-(1<<13) )
+#define ZB_POINT_T_MIN ( (1<<21) )
+#define ZB_POINT_T_MAX ( (1<<30)-(1<<21) )
+
+#define ZB_POINT_RED_MIN ( (1<<10) )
+#define ZB_POINT_RED_MAX ( (1<<16)-(1<<10) )
+#define ZB_POINT_GREEN_MIN ( (1<<9) )
+#define ZB_POINT_GREEN_MAX ( (1<<16)-(1<<9) )
+#define ZB_POINT_BLUE_MIN ( (1<<10) )
+#define ZB_POINT_BLUE_MAX ( (1<<16)-(1<<10) )
+
+/* display modes */
+#define ZB_MODE_5R6G5B  1  /* true color 16 bits */
+#define ZB_MODE_INDEX   2  /* color index 8 bits */
+#define ZB_MODE_RGBA    3  /* 32 bit rgba mode */
+#define ZB_MODE_RGB24   4  /* 24 bit rgb mode */
+#define ZB_NB_COLORS    225 /* number of colors for 8 bit display */
+
+#if TGL_FEATURE_RENDER_BITS == 15
+
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) >> 1) & 0x7c00) | (((g) >> 6) & 0x03e0) | ((b) >> 11))
+typedef unsigned short PIXEL;
+/* bytes per pixel */
+#define PSZB 2 
+/* bits per pixel = (1 << PSZH) */
+#define PSZSH 4 
+
+#elif TGL_FEATURE_RENDER_BITS == 16
+
+/* 16 bit mode */
+#define RGB_TO_PIXEL(r,g,b) \
+  (((r) & 0xF800) | (((g) >> 5) & 0x07E0) | ((b) >> 11))
+typedef unsigned short PIXEL;
+#define PSZB 2 
+#define PSZSH 4 
+
+#elif TGL_FEATURE_RENDER_BITS == 24
+
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8))
+typedef unsigned char PIXEL;
+#define PSZB 3
+#define PSZSH 5
+
+#elif TGL_FEATURE_RENDER_BITS == 32
+
+#define RGB_TO_PIXEL(r,g,b) \
+  ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8))
+typedef unsigned int PIXEL;
+#define PSZB 4
+#define PSZSH 5
+
+#else
+
+#error Incorrect number of bits per pixel
+
+#endif
+
+typedef struct {
+    int xsize,ysize;
+    int linesize; /* line size, in bytes */
+    int mode;
+    
+    unsigned short *zbuf;
+    PIXEL *pbuf;
+    int frame_buffer_allocated;
+    
+    int nb_colors;
+    unsigned char *dctable;
+    int *ctable;
+    PIXEL *current_texture;
+} ZBuffer;
+
+typedef struct {
+  int x,y,z;     /* integer coordinates in the zbuffer */
+  int s,t;       /* coordinates for the mapping */
+  int r,g,b;     /* color indexes */
+  
+  float sz,tz;   /* temporary coordinates for mapping */
+} ZBufferPoint;
+
+/* zbuffer.c */
+
+ZBuffer *ZB_open(int xsize,int ysize,int mode,
+		 int nb_colors,
+		 unsigned char *color_indexes,
+		 int *color_table,
+		 void *frame_buffer);
+
+
+void ZB_close(ZBuffer *zb);
+
+void ZB_resize(ZBuffer *zb,void *frame_buffer,int xsize,int ysize);
+void ZB_clear(ZBuffer *zb,int clear_z,int z,
+	      int clear_color,int r,int g,int b);
+/* linesize is in BYTES */
+void ZB_copyFrameBuffer(ZBuffer *zb,void *buf,int linesize);
+
+/* zdither.c */
+
+void ZB_initDither(ZBuffer *zb,int nb_colors,
+		   unsigned char *color_indexes,int *color_table);
+void ZB_closeDither(ZBuffer *zb);
+void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *dest,
+			  int linesize);
+
+/* zline.c */
+
+void ZB_plot(ZBuffer *zb,ZBufferPoint *p);
+void ZB_line(ZBuffer *zb,ZBufferPoint *p1,ZBufferPoint *p2);
+void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2);
+
+/* ztriangle.c */
+
+void ZB_setTexture(ZBuffer *zb, PIXEL *texture);
+
+void ZB_fillTriangleFlat(ZBuffer *zb,
+		 ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+
+void ZB_fillTriangleSmooth(ZBuffer *zb,
+		   ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+
+void ZB_fillTriangleMapping(ZBuffer *zb,
+		    ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3);
+
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                    ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2);
+
+
+typedef void (*ZB_fillTriangleFunc)(ZBuffer  *,
+	    ZBufferPoint *,ZBufferPoint *,ZBufferPoint *);
+
+/*
+ * Memory allocator for TinyGL
+ */
+
+/* modify these functions so that they suit your needs */
+
+static inline void gl_free(void *p)
+{
+    free(p);    
+}
+
+static inline void *gl_malloc(int size)
+{
+    return malloc(size);    
+}
+
+static inline void *gl_zalloc(int size)
+{    
+    return calloc(1, size);
+}
+
+#endif /* _tgl_zbuffer_h_ */

programs/develop/libraries/TinyGL/src/zdither.c

@@ -0,0 +1,159 @@
+/* 
+ * Highly optimised dithering 16 bits -> 8 bits. 
+ * The formulas were taken in Mesa (Bob Mercier mercier@hollywood.cinenet.net).
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "zbuffer.h"
+/*#include <assert.h>*/
+
+#if defined(TGL_FEATURE_8_BITS)
+
+#define _R	5
+#define _G	9
+#define _B	5
+#define _DX	4
+#define _DY	4
+#define _D	(_DX*_DY)
+#define _MIX(r,g,b)	( ((g)<<6) | ((b)<<3) | (r) )
+
+#define DITHER_TABLE_SIZE (1 << 15)
+
+#define DITHER_INDEX(r,g,b) ((b) + (g) * _B + (r) * (_B * _G))
+
+#define MAXC	256
+static int kernel8[_DY*_DX] = {
+    0 * MAXC,  8 * MAXC,  2 * MAXC, 10 * MAXC,
+   12 * MAXC,  4 * MAXC, 14 * MAXC,  6 * MAXC,
+    3 * MAXC, 11 * MAXC,  1 * MAXC,  9 * MAXC,
+   15 * MAXC,  7 * MAXC, 13 * MAXC,  5 * MAXC,
+};
+
+/* we build the color table and the lookup table */
+
+void ZB_initDither(ZBuffer *zb,int nb_colors,
+		   unsigned char *color_indexes,int *color_table)
+{
+  int c,r,g,b,i,index,r1,g1,b1;
+
+  if (nb_colors < (_R * _G * _B)) {
+    fprintf(stderr,"zdither: not enough colors\n");
+    exit(1);
+  }
+
+  for(i=0;i<nb_colors;i++) color_table[i]=0;
+
+  zb->nb_colors=nb_colors;
+  zb->ctable=gl_malloc(nb_colors * sizeof(int));
+
+  for (r = 0; r < _R; r++) {
+    for (g = 0; g < _G; g++) {
+      for (b = 0; b < _B; b++) {
+	r1=(r*255) / (_R - 1);
+	g1=(g*255) / (_G - 1);
+	b1=(b*255) / (_B - 1);
+	index=DITHER_INDEX(r,g,b);
+	c=(r1 << 16) | (g1 << 8) | b1;
+	zb->ctable[index]=c;
+	color_table[index]=c;
+      }
+    }
+  }
+
+  zb->dctable=gl_malloc( DITHER_TABLE_SIZE );
+
+  for(i=0;i<DITHER_TABLE_SIZE;i++) {
+    r=(i >> 12) & 0x7;
+    g=(i >> 8) & 0xF;
+    b=(i >> 3) & 0x7;
+    index=DITHER_INDEX(r,g,b);
+    zb->dctable[i]=color_indexes[index];
+  }
+}
+
+void ZB_closeDither(ZBuffer *zb)
+{
+    gl_free(zb->ctable);
+    gl_free(zb->dctable);
+}
+
+#if 0
+int ZDither_lookupColor(int r,int g,int b)
+{
+  unsigned char *ctable=zdither_color_table;
+  return ctable[_MIX(_DITH0(_R, r), _DITH0(_G, g),_DITH0(_B, b))];
+}
+#endif
+
+
+#define DITHER_PIXEL2(a)			\
+{ \
+  register int v,t,r,g,c;			\
+  v=*(unsigned int *)(pp+(a));                  \
+  g=(v & 0x07DF07DF) + g_d; \
+  r=(((v & 0xF800F800) >> 2) + r_d) & 0x70007000; \
+  t=r | g; \
+  c=ctable[t & 0xFFFF] | (ctable[t >> 16] << 8); \
+  *(unsigned short *)(dest+(a))=c; 	\
+}
+
+/* NOTE: all the memory access are 16 bit aligned, so if buf or
+   linesize are not multiple of 2, it cannot work efficiently (or
+   hang!) */
+
+void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *buf,
+			  int linesize)
+{
+  int xk,yk,x,y,c1,c2;
+  unsigned char *dest1;
+  unsigned short *pp1;
+  int r_d,g_d,b_d;
+  unsigned char *ctable=zb->dctable;
+  register unsigned char *dest;
+  register unsigned short *pp;
+
+  assert( ((long)buf & 1) == 0 && (linesize & 1) == 0);
+
+  for(yk=0;yk<4;yk++) {
+    for(xk=0;xk<4;xk+=2) {
+#if BYTE_ORDER == BIG_ENDIAN
+      c1=kernel8[yk*4+xk+1];
+      c2=kernel8[yk*4+xk];
+#else
+      c1=kernel8[yk*4+xk];
+      c2=kernel8[yk*4+xk+1];
+#endif
+      r_d=((c1 << 2) & 0xF800) >> 2;
+      g_d=(c1 >> 4) & 0x07C0;
+      b_d=(c1 >> 9) & 0x001F;
+      
+      r_d|=(((c2 << 2) & 0xF800) >> 2) << 16;
+      g_d|=((c2 >> 4) & 0x07C0) << 16;
+      b_d|=((c2 >> 9) & 0x001F) << 16;
+      g_d=b_d | g_d;
+
+      dest1=buf + (yk * linesize) + xk;
+      pp1=zb->pbuf + (yk * zb->xsize) + xk;
+      
+      for(y=yk;y<zb->ysize;y+=4) {
+	dest=dest1;
+	pp=pp1;
+	for(x=xk;x<zb->xsize;x+=16) {
+
+	  DITHER_PIXEL2(0);
+	  DITHER_PIXEL2(1*4);
+	  DITHER_PIXEL2(2*4);
+	  DITHER_PIXEL2(3*4);
+
+	  pp+=16;
+	  dest+=16;
+	}
+	dest1+=linesize*4;
+	pp1+=zb->xsize*4;
+      }
+    }
+  }
+}
+
+#endif

programs/develop/libraries/TinyGL/src/zfeatures.h

@@ -0,0 +1,54 @@
+#ifndef _tgl_features_h_
+#define _tgl_features_h_
+
+#define NDEBUG
+/*for menuetlibc*/
+#ifdef NDEBUG
+/*
+ * If not debugging, assert does nothing.
+ */
+#define assert(x)	((void)0)
+#else /* debugging enabled */
+#include <assert.h>
+#endif
+
+/* It is possible to enable/disable (compile time) features in this
+   header file. */
+
+/*#define TGL_FEATURE_ARRAYS         1*/
+/*#define TGL_FEATURE_DISPLAYLISTS   1*/
+/*#define TGL_FEATURE_POLYGON_OFFSET 1*/
+
+/*
+ * Matrix of internal and external pixel formats supported. 'Y' means
+ * supported.
+ * 
+ *           External  8    16    24    32
+ * Internal 
+ *  15                 .     .     .     .
+ *  16                 Y     Y     Y     Y
+ *  24                 .     Y     Y     .
+ *  32                 .     Y     .     Y
+ * 
+ *
+ * 15 bpp does not work yet (although it is easy to add it - ask me if
+ * you need it).
+ * 
+ * Internal pixel format: see TGL_FEATURE_RENDER_BITS
+ * External pixel format: see TGL_FEATURE_xxx_BITS 
+ */
+
+/* enable various convertion code from internal pixel format (usually
+   16 bits per pixel) to any external format */
+/*#define TGL_FEATURE_16_BITS        1*/
+/*#define TGL_FEATURE_8_BITS         1*/
+#define TGL_FEATURE_24_BITS        1
+/*#define TGL_FEATURE_32_BITS        1*/
+
+
+/*#define TGL_FEATURE_RENDER_BITS    15*/
+/*#define TGL_FEATURE_RENDER_BITS    16*/
+#define TGL_FEATURE_RENDER_BITS    24
+/*#define TGL_FEATURE_RENDER_BITS    32*/
+
+#endif /* _tgl_features_h_ */

programs/develop/libraries/TinyGL/src/zgl.h

@@ -0,0 +1,392 @@
+#ifndef _tgl_zgl_h_
+#define _tgl_zgl_h_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+/*#include <assert.h>*/
+#include <GL/gl.h>
+#include "zbuffer.h"
+#include "zmath.h"
+#include "zfeatures.h"
+
+#define fputc(...) /*nothing*/
+#define fprintf(...) /*nothing*/
+#define vfprintf(...) /*nothing*/
+#undef stderr
+#define stderr ((FILE*)-1)
+
+
+/*#define DEBUG */
+/*#define NDEBUG */
+
+enum {
+
+#define ADD_OP(a,b,c) OP_ ## a ,
+
+#include "opinfo.h"
+
+};
+
+/* initially # of allocated GLVertexes (will grow when necessary) */
+#define POLYGON_MAX_VERTEX 16
+
+/* Max # of specular light pow buffers */
+#define MAX_SPECULAR_BUFFERS 8
+/* # of entries in specular buffer */
+#define SPECULAR_BUFFER_SIZE 1024
+/* specular buffer granularity */
+#define SPECULAR_BUFFER_RESOLUTION 1024
+
+
+#define MAX_MODELVIEW_STACK_DEPTH  32
+#define MAX_PROJECTION_STACK_DEPTH 8
+#define MAX_TEXTURE_STACK_DEPTH    8
+#define MAX_NAME_STACK_DEPTH       64
+#define MAX_TEXTURE_LEVELS         11
+#define MAX_LIGHTS                 16
+
+#define VERTEX_HASH_SIZE 1031
+
+#define MAX_DISPLAY_LISTS 1024
+#define OP_BUFFER_MAX_SIZE 512
+
+#define TGL_OFFSET_FILL    0x1
+#define TGL_OFFSET_LINE    0x2
+#define TGL_OFFSET_POINT   0x4
+
+typedef struct GLSpecBuf {
+  int shininess_i;
+  int last_used;
+  float buf[SPECULAR_BUFFER_SIZE+1];
+  struct GLSpecBuf *next;
+} GLSpecBuf;
+
+typedef struct GLLight {
+  V4 ambient;
+  V4 diffuse;
+  V4 specular;
+  V4 position;	
+  V3 spot_direction;
+  float spot_exponent;
+  float spot_cutoff;
+  float attenuation[3];
+  /* precomputed values */
+  float cos_spot_cutoff;
+  V3 norm_spot_direction;
+  V3 norm_position;
+  /* we use a linked list to know which are the enabled lights */
+  int enabled;
+  struct GLLight *next,*prev;
+} GLLight;
+
+typedef struct GLMaterial {
+  V4 emission;
+  V4 ambient;
+  V4 diffuse;
+  V4 specular;
+  float shininess;
+
+  /* computed values */
+  int shininess_i;
+  int do_specular;  
+} GLMaterial;
+
+
+typedef struct GLViewport {
+  int xmin,ymin,xsize,ysize;
+  V3 scale;
+  V3 trans;
+  int updated;
+} GLViewport;
+
+typedef union {
+  int op;
+  float f;
+  int i;
+  unsigned int ui;
+  void *p;
+} GLParam;
+
+typedef struct GLParamBuffer {
+  GLParam ops[OP_BUFFER_MAX_SIZE];
+  struct GLParamBuffer *next;
+} GLParamBuffer;
+
+typedef struct GLList {
+  GLParamBuffer *first_op_buffer;
+  /* TODO: extensions for an hash table or a better allocating scheme */
+} GLList;
+
+typedef struct GLVertex {
+  int edge_flag;
+  V3 normal;
+  V4 coord;
+  V4 tex_coord;
+  V4 color;
+  
+  /* computed values */
+  V4 ec;                /* eye coordinates */
+  V4 pc;                /* coordinates in the normalized volume */
+  int clip_code;        /* clip code */
+  ZBufferPoint zp;      /* integer coordinates for the rasterization */
+} GLVertex;
+
+typedef struct GLImage {
+  void *pixmap;
+  int xsize,ysize;
+} GLImage;
+
+/* textures */
+
+#define TEXTURE_HASH_TABLE_SIZE 256
+
+typedef struct GLTexture {
+  GLImage images[MAX_TEXTURE_LEVELS];
+  int handle;
+  struct GLTexture *next,*prev;
+} GLTexture;
+
+
+/* shared state */
+
+typedef struct GLSharedState {
+  GLList **lists;
+  GLTexture **texture_hash_table;
+} GLSharedState;
+
+struct GLContext;
+
+typedef void (*gl_draw_triangle_func)(struct GLContext *c,
+                                      GLVertex *p0,GLVertex *p1,GLVertex *p2);
+
+/* display context */
+
+typedef struct GLContext {
+  /* Z buffer */
+  ZBuffer *zb;
+
+  /* lights */
+  GLLight lights[MAX_LIGHTS];
+  GLLight *first_light;
+  V4 ambient_light_model;
+  int local_light_model;
+  int lighting_enabled;
+  int light_model_two_side;
+
+  /* materials */
+  GLMaterial materials[2];
+  int color_material_enabled;
+  int current_color_material_mode;
+  int current_color_material_type;
+
+  /* textures */
+  GLTexture *current_texture;
+  int texture_2d_enabled;
+
+  /* shared state */
+  GLSharedState shared_state;
+
+  /* current list */
+  GLParamBuffer *current_op_buffer;
+  int current_op_buffer_index;
+  int exec_flag,compile_flag,print_flag;
+
+  /* matrix */
+
+  int matrix_mode;
+  M4 *matrix_stack[3];
+  M4 *matrix_stack_ptr[3];
+  int matrix_stack_depth_max[3];
+
+  M4 matrix_model_view_inv;
+  M4 matrix_model_projection;
+  int matrix_model_projection_updated;
+  int matrix_model_projection_no_w_transform; 
+  int apply_texture_matrix;
+
+  /* viewport */
+  GLViewport viewport;
+
+  /* current state */
+  int polygon_mode_back;
+  int polygon_mode_front;
+
+  int current_front_face;
+  int current_shade_model;
+  int current_cull_face;
+  int cull_face_enabled;
+  int normalize_enabled;
+  gl_draw_triangle_func draw_triangle_front,draw_triangle_back;
+
+  /* selection */
+  int render_mode;
+  unsigned int *select_buffer;
+  int select_size;
+  unsigned int *select_ptr,*select_hit;
+  int select_overflow;
+  int select_hits;
+
+  /* names */
+  unsigned int name_stack[MAX_NAME_STACK_DEPTH];
+  int name_stack_size;
+
+  /* clear */
+  float clear_depth;
+  V4 clear_color;
+
+  /* current vertex state */
+  V4 current_color;
+  unsigned int longcurrent_color[3]; /* precomputed integer color */
+  V4 current_normal;
+  V4 current_tex_coord;
+  int current_edge_flag;
+
+  /* glBegin / glEnd */
+  int in_begin;
+  int begin_type;
+  int vertex_n,vertex_cnt;
+  int vertex_max;
+  GLVertex *vertex;
+
+  /* opengl 1.1 arrays  */
+  float *vertex_array;
+  int vertex_array_size;
+  int vertex_array_stride;
+  float *normal_array;
+  int normal_array_stride;
+  float *color_array;
+  int color_array_size;
+  int color_array_stride;
+  float *texcoord_array;
+  int texcoord_array_size;
+  int texcoord_array_stride;
+  int client_states;
+  
+  /* opengl 1.1 polygon offset */
+  float offset_factor;
+  float offset_units;
+  int offset_states;
+  
+  /* specular buffer. could probably be shared between contexts, 
+    but that wouldn't be 100% thread safe */
+  GLSpecBuf *specbuf_first;
+  int specbuf_used_counter;
+  int specbuf_num_buffers;
+
+  /* opaque structure for user's use */
+  void *opaque;
+  /* resize viewport function */
+  int (*gl_resize_viewport)(struct GLContext *c,int *xsize,int *ysize);
+
+  /* depth test */
+  int depth_test;
+} GLContext;
+
+extern GLContext *gl_ctx;
+
+void gl_add_op(GLParam *p);
+
+/* clip.c */
+void gl_transform_to_viewport(GLContext *c,GLVertex *v);
+void gl_draw_triangle(GLContext *c,GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_line(GLContext *c,GLVertex *p0,GLVertex *p1);
+void gl_draw_point(GLContext *c,GLVertex *p0);
+
+void gl_draw_triangle_point(GLContext *c,
+                            GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_line(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_fill(GLContext *c,
+                           GLVertex *p0,GLVertex *p1,GLVertex *p2);
+void gl_draw_triangle_select(GLContext *c,
+                             GLVertex *p0,GLVertex *p1,GLVertex *p2);
+
+/* matrix.c */
+void gl_print_matrix(const float *m);
+/*
+void glopLoadIdentity(GLContext *c,GLParam *p);
+void glopTranslate(GLContext *c,GLParam *p);*/
+
+/* light.c */
+void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax);
+void gl_enable_disable_light(GLContext *c,int light,int v);
+void gl_shade_vertex(GLContext *c,GLVertex *v);
+
+void glInitTextures(GLContext *c);
+void glEndTextures(GLContext *c);
+GLTexture *alloc_texture(GLContext *c,int h);
+
+/* image_util.c */
+void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb,
+                             int xsize,int ysize);
+void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb,
+                               int xsize, int ysize);
+void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest,
+                    unsigned char *src,int xsize_src,int ysize_src);
+void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest,
+                                 unsigned char *src,int xsize_src,int ysize_src);
+
+static inline GLContext *gl_get_context(void)
+{
+  return gl_ctx;
+};
+
+void gl_fatal_error(char *format, ...);
+
+
+/* specular buffer "api" */
+GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, 
+                              const float shininess);
+
+#ifdef __BEOS__
+void dprintf(const char *, ...);
+
+#else /* !BEOS */
+
+#ifdef DEBUG
+
+#define dprintf(format, args...)  \
+  fprintf(stderr,"In '%s': " format "\n",__FUNCTION__, ##args);
+
+#else
+
+#define dprintf(format, args...)
+
+#endif
+#endif /* !BEOS */
+
+/* glopXXX functions */
+
+#define ADD_OP(a,b,c) void glop ## a (GLContext *,GLParam *);
+#include "opinfo.h"
+
+/* this clip epsilon is needed to avoid some rounding errors after
+   several clipping stages */
+
+#define CLIP_EPSILON (1E-5)
+
+static inline int gl_clipcode(float x,float y,float z,float w1)
+{
+  float w;
+
+  w=w1 * (1.0 + CLIP_EPSILON);
+  return (x<-w) |
+    ((x>w)<<1) |
+    ((y<-w)<<2) |
+    ((y>w)<<3) |
+    ((z<-w)<<4) | 
+    ((z>w)<<5) ;
+}
+
+#define RGBFtoRGBI(rf,gf,bf,ri,gi,bi) \
+{\
+  ri = (unsigned int) (rf * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + \
+                            ZB_POINT_RED_MIN); \
+  gi = (unsigned int) (gf * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + \
+                            ZB_POINT_GREEN_MIN); \
+  bi = (unsigned int) (bf * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + \
+                            ZB_POINT_BLUE_MIN);\
+}
+
+#endif /* _tgl_zgl_h_ */

programs/develop/libraries/TinyGL/src/zline.c

@@ -0,0 +1,84 @@
+#include <stdlib.h>
+#include "zbuffer.h"
+
+#define ZCMP(z,zpix) ((z) >= (zpix))
+
+void ZB_plot(ZBuffer * zb, ZBufferPoint * p)
+{
+    unsigned short *pz;
+    PIXEL *pp;
+    int zz;
+
+    pz = zb->zbuf + (p->y * zb->xsize + p->x);
+    pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p->y + p->x * PSZB);
+    zz = p->z >> ZB_POINT_Z_FRAC_BITS;
+    if (ZCMP(zz, *pz)) {
+#if TGL_FEATURE_RENDER_BITS == 24 
+        pp[0]=p->r>>8;
+        pp[1]=p->g>>8;
+        pp[2]=p->b>>8;
+#else
+	*pp = RGB_TO_PIXEL(p->r, p->g, p->b);
+#endif
+	*pz = zz;
+    }
+}
+
+#define INTERP_Z
+static void ZB_line_flat_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, 
+                           int color)
+{
+#include "zline.h"
+}
+
+/* line with color interpolation */
+#define INTERP_Z
+#define INTERP_RGB
+static void ZB_line_interp_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+#include "zline.h"
+}
+
+/* no Z interpolation */
+
+static void ZB_line_flat(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, 
+                             int color)
+{
+#include "zline.h"
+}
+
+#define INTERP_RGB
+static void ZB_line_interp(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+#include "zline.h"
+}
+
+void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+    int color1, color2;
+
+    color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b);
+    color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b);
+
+    /* choose if the line should have its color interpolated or not */
+    if (color1 == color2) {
+        ZB_line_flat_z(zb, p1, p2, color1);
+    } else {
+        ZB_line_interp_z(zb, p1, p2);
+    }
+}
+
+void ZB_line(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2)
+{
+    int color1, color2;
+
+    color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b);
+    color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b);
+
+    /* choose if the line should have its color interpolated or not */
+    if (color1 == color2) {
+        ZB_line_flat(zb, p1, p2, color1);
+    } else {
+        ZB_line_interp(zb, p1, p2);
+    }
+}

programs/develop/libraries/TinyGL/src/zline.h

@@ -0,0 +1,121 @@
+{
+    int n, dx, dy, sx, pp_inc_1, pp_inc_2;
+    register int a;
+    register PIXEL *pp;
+#if defined(INTERP_RGB) || TGL_FEATURE_RENDER_BITS == 24
+    register unsigned int r, g, b;
+#endif
+#ifdef INTERP_RGB
+    register unsigned int rinc, ginc, binc;
+#endif
+#ifdef INTERP_Z
+    register unsigned short *pz;
+    int zinc;
+    register int z, zz;
+#endif
+
+    if (p1->y > p2->y || (p1->y == p2->y && p1->x > p2->x)) {
+	ZBufferPoint *tmp;
+	tmp = p1;
+	p1 = p2;
+	p2 = tmp;
+    }
+    sx = zb->xsize;
+    pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p1->y + p1->x * PSZB);
+#ifdef INTERP_Z
+    pz = zb->zbuf + (p1->y * sx + p1->x);
+    z = p1->z;
+#endif
+
+    dx = p2->x - p1->x;
+    dy = p2->y - p1->y;
+#ifdef INTERP_RGB
+    r = p1->r << 8;
+    g = p1->g << 8;
+    b = p1->b << 8;
+#elif TGL_FEATURE_RENDER_BITS == 24
+    /* for 24 bits, we store the colors in different variables */
+    r = p2->r >> 8;
+    g = p2->g >> 8;
+    b = p2->b >> 8;
+#endif
+
+#ifdef INTERP_RGB
+#define RGB(x) x
+#if TGL_FEATURE_RENDER_BITS == 24
+#define RGBPIXEL pp[0] = r >> 16, pp[1] = g >> 16, pp[2] = b >> 16
+#else
+#define RGBPIXEL *pp = RGB_TO_PIXEL(r >> 8,g >> 8,b >> 8)
+#endif
+#else /* INTERP_RGB */
+#define RGB(x)
+#if TGL_FEATURE_RENDER_BITS == 24
+#define RGBPIXEL pp[0] = r, pp[1] = g, pp[2] = b
+#else
+#define RGBPIXEL *pp = color
+#endif
+#endif /* INTERP_RGB */
+
+#ifdef INTERP_Z
+#define ZZ(x) x
+#define PUTPIXEL() 				\
+  {						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,*pz))  { 			\
+      RGBPIXEL;	\
+      *pz=zz; 					\
+    }						\
+  }
+#else /* INTERP_Z */
+#define ZZ(x)
+#define PUTPIXEL() RGBPIXEL
+#endif /* INTERP_Z */
+
+#define DRAWLINE(dx,dy,inc_1,inc_2) \
+    n=dx;\
+    ZZ(zinc=(p2->z-p1->z)/n);\
+    RGB(rinc=((p2->r-p1->r) << 8)/n;\
+        ginc=((p2->g-p1->g) << 8)/n;\
+        binc=((p2->b-p1->b) << 8)/n);\
+    a=2*dy-dx;\
+    dy=2*dy;\
+    dx=2*dx-dy;\
+    pp_inc_1 = (inc_1) * PSZB;\
+    pp_inc_2 = (inc_2) * PSZB;\
+    do {\
+        PUTPIXEL();\
+        ZZ(z+=zinc);\
+        RGB(r+=rinc;g+=ginc;b+=binc);\
+        if (a>0) { pp=(PIXEL *)((char *)pp + pp_inc_1); ZZ(pz+=(inc_1));  a-=dx; }\
+	else { pp=(PIXEL *)((char *)pp + pp_inc_2); ZZ(pz+=(inc_2)); a+=dy; }\
+    } while (--n >= 0);
+
+/* fin macro */
+
+    if (dx == 0 && dy == 0) {
+	PUTPIXEL();
+    } else if (dx > 0) {
+	if (dx >= dy) {
+	    DRAWLINE(dx, dy, sx + 1, 1);
+	} else {
+	    DRAWLINE(dy, dx, sx + 1, sx);
+	}
+    } else {
+	dx = -dx;
+	if (dx >= dy) {
+	    DRAWLINE(dx, dy, sx - 1, -1);
+	} else {
+	    DRAWLINE(dy, dx, sx - 1, sx);
+	}
+    }
+}
+
+#undef INTERP_Z
+#undef INTERP_RGB
+
+/* internal defines */
+#undef DRAWLINE
+#undef PUTPIXEL
+#undef ZZ
+#undef RGB
+#undef RGBPIXEL 

programs/develop/libraries/TinyGL/src/zmath.c

@@ -0,0 +1,274 @@
+/* Some simple mathematical functions. Don't look for some logic in
+   the function names :-) */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "zmath.h"
+
+
+/* ******* Gestion des matrices 4x4 ****** */
+
+void gl_M4_Id(M4 *a)
+{
+	int i,j;
+	for(i=0;i<4;i++)
+	for(j=0;j<4;j++) 
+	if (i==j) a->m[i][j]=1.0; else a->m[i][j]=0.0;
+}
+
+int gl_M4_IsId(M4 *a)
+{
+	int i,j;
+	for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      if (i==j) { 
+        if (a->m[i][j] != 1.0) return 0;
+      } else if (a->m[i][j] != 0.0) return 0;
+    }
+  return 1;
+}
+
+void gl_M4_Mul(M4 *c,M4 *a,M4 *b)
+{
+  int i,j,k;
+  float s;
+  for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      s=0.0;
+      for(k=0;k<4;k++) s+=a->m[i][k]*b->m[k][j];
+      c->m[i][j]=s;
+    }
+}
+
+/* c=c*a */
+void gl_M4_MulLeft(M4 *c,M4 *b)
+{
+  int i,j,k;
+  float s;
+  M4 a;
+
+  /*memcpy(&a, c, 16*sizeof(float));
+  */
+  a=*c;
+
+  for(i=0;i<4;i++)
+    for(j=0;j<4;j++) {
+      s=0.0;
+      for(k=0;k<4;k++) s+=a.m[i][k]*b->m[k][j];
+      c->m[i][j]=s;
+    }
+}
+
+void gl_M4_Move(M4 *a,M4 *b)
+{
+	memcpy(a,b,sizeof(M4));
+}
+
+void gl_MoveV3(V3 *a,V3 *b)
+{
+	memcpy(a,b,sizeof(V3));
+}
+
+
+void gl_MulM4V3(V3 *a,M4 *b,V3 *c)
+{
+	 a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3];
+	 a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3];
+	 a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3];
+}
+
+void gl_MulM3V3(V3 *a,M4 *b,V3 *c)
+{
+	 a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z;
+	 a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z;
+	 a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z;
+}
+
+void gl_M4_MulV4(V4 *a,M4 *b,V4 *c)
+{
+	 a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]*c->W;
+	 a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]*c->W;
+	 a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]*c->W;
+	 a->W=b->m[3][0]*c->X+b->m[3][1]*c->Y+b->m[3][2]*c->Z+b->m[3][3]*c->W;
+}
+	
+/* transposition of a 4x4 matrix */
+void gl_M4_Transpose(M4 *a,M4 *b)
+{
+  a->m[0][0]=b->m[0][0]; 
+  a->m[0][1]=b->m[1][0]; 
+  a->m[0][2]=b->m[2][0]; 
+  a->m[0][3]=b->m[3][0]; 
+
+  a->m[1][0]=b->m[0][1]; 
+  a->m[1][1]=b->m[1][1]; 
+  a->m[1][2]=b->m[2][1]; 
+  a->m[1][3]=b->m[3][1]; 
+
+  a->m[2][0]=b->m[0][2]; 
+  a->m[2][1]=b->m[1][2]; 
+  a->m[2][2]=b->m[2][2]; 
+  a->m[2][3]=b->m[3][2]; 
+
+  a->m[3][0]=b->m[0][3]; 
+  a->m[3][1]=b->m[1][3]; 
+  a->m[3][2]=b->m[2][3]; 
+  a->m[3][3]=b->m[3][3]; 
+}
+
+/* inversion of an orthogonal matrix of type Y=M.X+P */ 
+void gl_M4_InvOrtho(M4 *a,M4 b)
+{
+	int i,j;
+	float s;
+	for(i=0;i<3;i++)
+	for(j=0;j<3;j++) a->m[i][j]=b.m[j][i];
+	a->m[3][0]=0.0; a->m[3][1]=0.0; a->m[3][2]=0.0; a->m[3][3]=1.0;
+	for(i=0;i<3;i++) {
+		s=0;
+		for(j=0;j<3;j++) s-=b.m[j][i]*b.m[j][3];
+		a->m[i][3]=s;
+	}
+}
+
+/* Inversion of a general nxn matrix.
+   Note : m is destroyed */
+
+int Matrix_Inv(float *r,float *m,int n)
+{
+	 int i,j,k,l;
+	 float max,tmp,t;
+
+	 /* identit<69>e dans r */
+	 for(i=0;i<n*n;i++) r[i]=0;
+	 for(i=0;i<n;i++) r[i*n+i]=1;
+	 
+	 for(j=0;j<n;j++) {
+			
+			/* recherche du nombre de plus grand module sur la colonne j */
+			max=m[j*n+j];
+			k=j;
+			for(i=j+1;i<n;i++)
+				if (fabs(m[i*n+j])>fabs(max)) {
+					 k=i;
+					 max=m[i*n+j];
+				}
+
+      /* non intersible matrix */
+      if (max==0) return 1;
+
+			
+			/* permutation des lignes j et k */
+			if (k!=j) {
+				 for(i=0;i<n;i++) {
+						tmp=m[j*n+i];
+						m[j*n+i]=m[k*n+i];
+						m[k*n+i]=tmp;
+						
+						tmp=r[j*n+i];
+						r[j*n+i]=r[k*n+i];
+						r[k*n+i]=tmp;
+				 }
+			}
+			
+			/* multiplication de la ligne j par 1/max */
+			max=1/max;
+			for(i=0;i<n;i++) {
+				 m[j*n+i]*=max;
+				 r[j*n+i]*=max;
+			}
+			
+			
+			for(l=0;l<n;l++) if (l!=j) {
+				 t=m[l*n+j];
+				 for(i=0;i<n;i++) {
+						m[l*n+i]-=m[j*n+i]*t;
+						r[l*n+i]-=r[j*n+i]*t;
+				 }
+			}
+	 }
+
+	 return 0;
+}
+
+
+/* inversion of a 4x4 matrix */
+
+void gl_M4_Inv(M4 *a,M4 *b)
+{
+  M4 tmp;
+  memcpy(&tmp, b, 16*sizeof(float));
+  Matrix_Inv(&a->m[0][0],&tmp.m[0][0],4);
+}
+
+void gl_M4_Rotate(M4 *a,float t,int u)
+{
+	 float s,c;
+	 int v,w;
+   if ((v=u+1)>2) v=0;
+	 if ((w=v+1)>2) w=0;
+	 s=sin(t);
+	 c=cos(t);
+	 gl_M4_Id(a);
+	 a->m[v][v]=c;	a->m[v][w]=-s;
+	 a->m[w][v]=s;	a->m[w][w]=c;
+}
+	
+
+/* inverse of a 3x3 matrix */
+void gl_M3_Inv(M3 *a,M3 *m)
+{
+	 float det;
+	 
+	 det = m->m[0][0]*m->m[1][1]*m->m[2][2]-m->m[0][0]*m->m[1][2]*m->m[2][1]-
+		 m->m[1][0]*m->m[0][1]*m->m[2][2]+m->m[1][0]*m->m[0][2]*m->m[2][1]+
+		 m->m[2][0]*m->m[0][1]*m->m[1][2]-m->m[2][0]*m->m[0][2]*m->m[1][1];
+
+	 a->m[0][0] = (m->m[1][1]*m->m[2][2]-m->m[1][2]*m->m[2][1])/det;
+	 a->m[0][1] = -(m->m[0][1]*m->m[2][2]-m->m[0][2]*m->m[2][1])/det;
+	 a->m[0][2] = -(-m->m[0][1]*m->m[1][2]+m->m[0][2]*m->m[1][1])/det;
+	 
+	 a->m[1][0] = -(m->m[1][0]*m->m[2][2]-m->m[1][2]*m->m[2][0])/det;
+	 a->m[1][1] = (m->m[0][0]*m->m[2][2]-m->m[0][2]*m->m[2][0])/det;
+	 a->m[1][2] = -(m->m[0][0]*m->m[1][2]-m->m[0][2]*m->m[1][0])/det;
+
+	 a->m[2][0] = (m->m[1][0]*m->m[2][1]-m->m[1][1]*m->m[2][0])/det;
+	 a->m[2][1] = -(m->m[0][0]*m->m[2][1]-m->m[0][1]*m->m[2][0])/det;
+	 a->m[2][2] = (m->m[0][0]*m->m[1][1]-m->m[0][1]*m->m[1][0])/det;
+}
+
+																										
+/* vector arithmetic */
+
+int gl_V3_Norm(V3 *a)
+{
+	float n;
+	n=sqrt(a->X*a->X+a->Y*a->Y+a->Z*a->Z);
+	if (n==0) return 1;
+	a->X/=n;
+	a->Y/=n;
+	a->Z/=n;
+	return 0;
+}
+
+V3 gl_V3_New(float x,float y,float z)
+{
+	 V3 a;
+	 a.X=x;
+	 a.Y=y;
+	 a.Z=z;
+	 return a;
+}
+
+V4 gl_V4_New(float x,float y,float z,float w)
+{
+  V4 a;
+  a.X=x;
+  a.Y=y;
+  a.Z=z;
+  a.W=w;
+  return a;
+}
+
+

programs/develop/libraries/TinyGL/src/zmath.h

@@ -0,0 +1,56 @@
+#ifndef __ZMATH__
+#define __ZMATH__
+
+/*for menuetlibc*/
+#define pow powf
+
+/* Matrix & Vertex */
+
+typedef struct {
+	float m[4][4];
+} M4;
+
+typedef struct {
+	float m[3][3];
+} M3;
+
+typedef struct {
+	 float m[3][4];
+} M34;
+
+
+#define X v[0]
+#define Y v[1]
+#define Z v[2]
+#define W v[3]
+
+typedef struct {
+	 float v[3];
+} V3;
+
+typedef struct {
+	 float v[4];
+} V4;
+	
+void gl_M4_Id(M4 *a);
+int gl_M4_IsId(M4 *a);
+void gl_M4_Move(M4 *a,M4 *b);
+void gl_MoveV3(V3 *a,V3 *b);
+void gl_MulM4V3(V3 *a,M4 *b,V3 *c);
+void gl_MulM3V3(V3 *a,M4 *b,V3 *c);
+
+void gl_M4_MulV4(V4 * a,M4 *b,V4 * c);
+void gl_M4_InvOrtho(M4 *a,M4 b);
+void gl_M4_Inv(M4 *a,M4 *b);
+void gl_M4_Mul(M4 *c,M4 *a,M4 *b);
+void gl_M4_MulLeft(M4 *c,M4 *a);
+void gl_M4_Transpose(M4 *a,M4 *b);
+void gl_M4_Rotate(M4 *c,float t,int u);
+int  gl_V3_Norm(V3 *a);
+
+V3 gl_V3_New(float x,float y,float z);
+V4 gl_V4_New(float x,float y,float z,float w);
+
+int gl_Matrix_Inv(float *r,float *m,int n);
+
+#endif  /*__ZMATH__*/

programs/develop/libraries/TinyGL/src/ztriangle.c

@@ -0,0 +1,394 @@
+#include <stdlib.h>
+#include "zbuffer.h"
+
+#define ZCMP(z,zpix) ((z) >= (zpix))
+
+void ZB_fillTriangleFlat(ZBuffer *zb,
+			 ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+#if TGL_FEATURE_RENDER_BITS == 24
+    unsigned char colorR, colorG, colorB;
+#else
+    int color;
+#endif
+
+#define INTERP_Z
+
+#if TGL_FEATURE_RENDER_BITS == 24 
+
+#define DRAW_INIT()				\
+{						\
+  colorR=p2->r>>8; \
+  colorG=p2->g>>8; \
+  colorB=p2->b>>8; \
+}
+
+#define PUT_PIXEL(_a)		\
+{						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,pz[_a])) {				\
+      pp[3 * _a]=colorR;\
+      pp[3 * _a + 1]=colorG;\
+      pp[3 * _a + 2]=colorB;\
+      pz[_a]=zz;				\
+    }\
+    z+=dzdx;					\
+}
+
+#else
+
+#define DRAW_INIT()				\
+{						\
+  color=RGB_TO_PIXEL(p2->r,p2->g,p2->b);	\
+}
+  
+#define PUT_PIXEL(_a)				\
+{						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,pz[_a])) {				\
+      pp[_a]=color;				\
+      pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+}
+#endif /* TGL_FEATURE_RENDER_BITS == 24 */
+
+#include "ztriangle.h"
+}
+
+/*
+ * Smooth filled triangle.
+ * The code below is very tricky :)
+ */
+
+void ZB_fillTriangleSmooth(ZBuffer *zb,
+			   ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+#if TGL_FEATURE_RENDER_BITS == 16
+        int _drgbdx;
+#endif
+
+#define INTERP_Z
+#define INTERP_RGB
+
+#define SAR_RND_TO_ZERO(v,n) (v / (1<<n))
+
+#if TGL_FEATURE_RENDER_BITS == 24
+
+#define DRAW_INIT() 				\
+{						\
+}
+
+#define PUT_PIXEL(_a)				\
+{						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,pz[_a])) {				\
+      pp[3 * _a]=or1 >> 8;\
+      pp[3 * _a + 1]=og1 >> 8;\
+      pp[3 * _a + 2]=ob1 >> 8;\
+      pz[_a]=zz;				\
+    }\
+    z+=dzdx;					\
+    og1+=dgdx;					\
+    or1+=drdx;					\
+    ob1+=dbdx;					\
+}
+
+#elif TGL_FEATURE_RENDER_BITS == 16
+
+#define DRAW_INIT() 				\
+{						\
+  _drgbdx=(SAR_RND_TO_ZERO(drdx,6) << 22) & 0xFFC00000;		\
+  _drgbdx|=SAR_RND_TO_ZERO(dgdx,5) & 0x000007FF;		\
+  _drgbdx|=(SAR_RND_TO_ZERO(dbdx,7) << 12) & 0x001FF000; 	\
+}
+
+
+#define PUT_PIXEL(_a)				\
+{						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,pz[_a])) {				\
+      tmp=rgb & 0xF81F07E0;			\
+      pp[_a]=tmp | (tmp >> 16);			\
+      pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    rgb=(rgb+drgbdx) & ( ~ 0x00200800);		\
+}
+
+#define DRAW_LINE()							   \
+{									   \
+  register unsigned short *pz;					   \
+  register PIXEL *pp;					   \
+  register unsigned int tmp,z,zz,rgb,drgbdx;				   \
+  register int n;							   \
+  n=(x2 >> 16) - x1;							   \
+  pp=pp1+x1;								   \
+  pz=pz1+x1;								   \
+  z=z1;									   \
+  rgb=(r1 << 16) & 0xFFC00000;						   \
+  rgb|=(g1 >> 5) & 0x000007FF;						   \
+  rgb|=(b1 << 5) & 0x001FF000;						   \
+  drgbdx=_drgbdx;							   \
+  while (n>=3) {							   \
+    PUT_PIXEL(0);							   \
+    PUT_PIXEL(1);							   \
+    PUT_PIXEL(2);							   \
+    PUT_PIXEL(3);							   \
+    pz+=4;								   \
+    pp+=4;								   \
+    n-=4;								   \
+  }									   \
+  while (n>=0) {							   \
+    PUT_PIXEL(0);							   \
+    pz+=1;								   \
+    pp+=1;								   \
+    n-=1;								   \
+  }									   \
+}
+
+#else
+
+#define DRAW_INIT() 				\
+{						\
+}
+
+#define PUT_PIXEL(_a)				\
+{						\
+    zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+    if (ZCMP(zz,pz[_a])) {				\
+      pp[_a] = RGB_TO_PIXEL(or1, og1, ob1);\
+      pz[_a]=zz;				\
+    }\
+    z+=dzdx;					\
+    og1+=dgdx;					\
+    or1+=drdx;					\
+    ob1+=dbdx;					\
+}
+
+#endif /* TGL_FEATURE_RENDER_BITS */
+
+#include "ztriangle.h"
+}
+
+void ZB_setTexture(ZBuffer *zb,PIXEL *texture)
+{
+    zb->current_texture=texture;
+}
+
+void ZB_fillTriangleMapping(ZBuffer *zb,
+			    ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+
+#define INTERP_Z
+#define INTERP_ST
+
+#define DRAW_INIT()				\
+{						\
+  texture=zb->current_texture;			\
+}
+
+#if TGL_FEATURE_RENDER_BITS == 24
+
+#define PUT_PIXEL(_a)				\
+{						\
+   unsigned char *ptr;\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+     if (ZCMP(zz,pz[_a])) {				\
+       ptr = texture + (((t & 0x3FC00000) | s) >> 14) * 3; \
+       pp[3 * _a]= ptr[0];\
+       pp[3 * _a + 1]= ptr[1];\
+       pp[3 * _a + 2]= ptr[2];\
+       pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    s+=dsdx;					\
+    t+=dtdx;					\
+}
+
+#else
+
+#define PUT_PIXEL(_a)				\
+{						\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+     if (ZCMP(zz,pz[_a])) {				\
+       pp[_a]=texture[((t & 0x3FC00000) | s) >> 14];	\
+       pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    s+=dsdx;					\
+    t+=dtdx;					\
+}
+
+#endif
+
+#include "ztriangle.h"
+}
+
+/*
+ * Texture mapping with perspective correction.
+ * We use the gradient method to make less divisions.
+ * TODO: pipeline the division
+ */
+#if 1
+
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                            ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+    float fdzdx,fndzdx,ndszdx,ndtzdx;
+
+#define INTERP_Z
+#define INTERP_STZ
+
+#define NB_INTERP 8
+
+#define DRAW_INIT()				\
+{						\
+  texture=zb->current_texture;\
+  fdzdx=(float)dzdx;\
+  fndzdx=NB_INTERP * fdzdx;\
+  ndszdx=NB_INTERP * dszdx;\
+  ndtzdx=NB_INTERP * dtzdx;\
+}
+
+
+#if TGL_FEATURE_RENDER_BITS == 24
+
+#define PUT_PIXEL(_a)				\
+{						\
+   unsigned char *ptr;\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+     if (ZCMP(zz,pz[_a])) {				\
+       ptr = texture + (((t & 0x3FC00000) | (s & 0x003FC000)) >> 14) * 3;\
+       pp[3 * _a]= ptr[0];\
+       pp[3 * _a + 1]= ptr[1];\
+       pp[3 * _a + 2]= ptr[2];\
+       pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    s+=dsdx;					\
+    t+=dtdx;					\
+}
+
+#else
+
+#define PUT_PIXEL(_a)				\
+{						\
+   zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+     if (ZCMP(zz,pz[_a])) {				\
+       pp[_a]=*(PIXEL *)((char *)texture+ \
+               (((t & 0x3FC00000) | (s & 0x003FC000)) >> (17 - PSZSH)));\
+       pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    s+=dsdx;					\
+    t+=dtdx;					\
+}
+
+#endif
+
+#define DRAW_LINE()				\
+{						\
+  register unsigned short *pz;		\
+  register PIXEL *pp;		\
+  register unsigned int s,t,z,zz;	\
+  register int n,dsdx,dtdx;		\
+  float sz,tz,fz,zinv; \
+  n=(x2>>16)-x1;                             \
+  fz=(float)z1;\
+  zinv=1.0 / fz;\
+  pp=(PIXEL *)((char *)pp1 + x1 * PSZB); \
+  pz=pz1+x1;					\
+  z=z1;						\
+  sz=sz1;\
+  tz=tz1;\
+  while (n>=(NB_INTERP-1)) {						   \
+    {\
+      float ss,tt;\
+      ss=(sz * zinv);\
+      tt=(tz * zinv);\
+      s=(int) ss;\
+      t=(int) tt;\
+      dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\
+      dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\
+      fz+=fndzdx;\
+      zinv=1.0 / fz;\
+    }\
+    PUT_PIXEL(0);							   \
+    PUT_PIXEL(1);							   \
+    PUT_PIXEL(2);							   \
+    PUT_PIXEL(3);							   \
+    PUT_PIXEL(4);							   \
+    PUT_PIXEL(5);							   \
+    PUT_PIXEL(6);							   \
+    PUT_PIXEL(7);							   \
+    pz+=NB_INTERP;							   \
+    pp=(PIXEL *)((char *)pp + NB_INTERP * PSZB);\
+    n-=NB_INTERP;							   \
+    sz+=ndszdx;\
+    tz+=ndtzdx;\
+  }									   \
+    {\
+      float ss,tt;\
+      ss=(sz * zinv);\
+      tt=(tz * zinv);\
+      s=(int) ss;\
+      t=(int) tt;\
+      dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\
+      dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\
+    }\
+  while (n>=0) {							   \
+    PUT_PIXEL(0);							   \
+    pz+=1;								   \
+    pp=(PIXEL *)((char *)pp + PSZB);\
+    n-=1;								   \
+  }									   \
+}
+  
+#include "ztriangle.h"
+}
+
+#endif
+
+#if 0
+
+/* slow but exact version (only there for reference, incorrect for 24
+   bits) */
+
+void ZB_fillTriangleMappingPerspective(ZBuffer *zb,
+                            ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2)
+{
+    PIXEL *texture;
+
+#define INTERP_Z
+#define INTERP_STZ
+
+#define DRAW_INIT()				\
+{						\
+  texture=zb->current_texture;			\
+}
+
+#define PUT_PIXEL(_a)				\
+{						\
+   float zinv; \
+   int s,t; \
+   zz=z >> ZB_POINT_Z_FRAC_BITS;		\
+     if (ZCMP(zz,pz[_a])) {				\
+       zinv= 1.0 / (float) z; \
+       s= (int) (sz * zinv); \
+       t= (int) (tz * zinv); \
+       pp[_a]=texture[((t & 0x3FC00000) | s) >> 14];	\
+       pz[_a]=zz;				\
+    }						\
+    z+=dzdx;					\
+    sz+=dszdx;					\
+    tz+=dtzdx;					\
+}
+
+#include "ztriangle.h"
+}
+
+
+#endif

programs/develop/libraries/TinyGL/src/ztriangle.h

@@ -0,0 +1,363 @@
+/*
+ * We draw a triangle with various interpolations
+ */
+
+{
+  ZBufferPoint *t,*pr1,*pr2,*l1,*l2;
+  float fdx1, fdx2, fdy1, fdy2, fz, d1, d2;
+  unsigned short *pz1;
+  PIXEL *pp1;
+  int part,update_left,update_right;
+
+  int nb_lines,dx1,dy1,tmp,dx2,dy2;
+
+  int error,derror;
+  int x1,dxdy_min,dxdy_max;
+/* warning: x2 is multiplied by 2^16 */
+  int x2,dx2dy2;  
+
+#ifdef INTERP_Z
+  int z1,dzdx,dzdy,dzdl_min,dzdl_max;
+#endif
+#ifdef INTERP_RGB
+  int r1,drdx,drdy,drdl_min,drdl_max;
+  int g1,dgdx,dgdy,dgdl_min,dgdl_max;
+  int b1,dbdx,dbdy,dbdl_min,dbdl_max;
+#endif
+#ifdef INTERP_ST
+  int s1,dsdx,dsdy,dsdl_min,dsdl_max;
+  int t1,dtdx,dtdy,dtdl_min,dtdl_max;
+#endif
+#ifdef INTERP_STZ
+  float sz1,dszdx,dszdy,dszdl_min,dszdl_max;
+  float tz1,dtzdx,dtzdy,dtzdl_min,dtzdl_max;
+#endif
+
+  /* we sort the vertex with increasing y */
+  if (p1->y < p0->y) {
+    t = p0;
+    p0 = p1;
+    p1 = t;
+  }
+  if (p2->y < p0->y) {
+    t = p2;
+    p2 = p1;
+    p1 = p0;
+    p0 = t;
+  } else if (p2->y < p1->y) {
+    t = p1;
+    p1 = p2;
+    p2 = t;
+  }
+
+  /* we compute dXdx and dXdy for all interpolated values */
+  
+  fdx1 = p1->x - p0->x;
+  fdy1 = p1->y - p0->y;
+
+  fdx2 = p2->x - p0->x;
+  fdy2 = p2->y - p0->y;
+
+  fz = fdx1 * fdy2 - fdx2 * fdy1;
+  if (fz == 0)
+    return;
+  fz = 1.0 / fz;
+
+  fdx1 *= fz;
+  fdy1 *= fz;
+  fdx2 *= fz;
+  fdy2 *= fz;
+
+#ifdef INTERP_Z
+  d1 = p1->z - p0->z;
+  d2 = p2->z - p0->z;
+  dzdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dzdy = (int) (fdx1 * d2 - fdx2 * d1);
+#endif
+
+#ifdef INTERP_RGB
+  d1 = p1->r - p0->r;
+  d2 = p2->r - p0->r;
+  drdx = (int) (fdy2 * d1 - fdy1 * d2);
+  drdy = (int) (fdx1 * d2 - fdx2 * d1);
+
+  d1 = p1->g - p0->g;
+  d2 = p2->g - p0->g;
+  dgdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dgdy = (int) (fdx1 * d2 - fdx2 * d1);
+
+  d1 = p1->b - p0->b;
+  d2 = p2->b - p0->b;
+  dbdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dbdy = (int) (fdx1 * d2 - fdx2 * d1);
+
+#endif
+  
+#ifdef INTERP_ST
+  d1 = p1->s - p0->s;
+  d2 = p2->s - p0->s;
+  dsdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dsdy = (int) (fdx1 * d2 - fdx2 * d1);
+  
+  d1 = p1->t - p0->t;
+  d2 = p2->t - p0->t;
+  dtdx = (int) (fdy2 * d1 - fdy1 * d2);
+  dtdy = (int) (fdx1 * d2 - fdx2 * d1);
+#endif
+
+#ifdef INTERP_STZ
+  {
+    float zz;
+    zz=(float) p0->z;
+    p0->sz= (float) p0->s * zz;
+    p0->tz= (float) p0->t * zz;
+    zz=(float) p1->z;
+    p1->sz= (float) p1->s * zz;
+    p1->tz= (float) p1->t * zz;
+    zz=(float) p2->z;
+    p2->sz= (float) p2->s * zz;
+    p2->tz= (float) p2->t * zz;
+
+    d1 = p1->sz - p0->sz;
+    d2 = p2->sz - p0->sz;
+    dszdx = (fdy2 * d1 - fdy1 * d2);
+    dszdy = (fdx1 * d2 - fdx2 * d1);
+    
+    d1 = p1->tz - p0->tz;
+    d2 = p2->tz - p0->tz;
+    dtzdx = (fdy2 * d1 - fdy1 * d2);
+    dtzdy = (fdx1 * d2 - fdx2 * d1);
+  }
+#endif
+
+  /* screen coordinates */
+
+  pp1 = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p0->y);
+  pz1 = zb->zbuf + p0->y * zb->xsize;
+
+  DRAW_INIT();
+
+  for(part=0;part<2;part++) {
+    if (part == 0) {
+      if (fz > 0) {
+	update_left=1;
+	update_right=1;
+	l1=p0;
+	l2=p2;
+	pr1=p0;
+	pr2=p1;
+      } else {
+	update_left=1;
+	update_right=1;
+	l1=p0;
+	l2=p1;
+	pr1=p0;
+	pr2=p2;
+      }
+      nb_lines = p1->y - p0->y;
+    } else {
+      /* second part */
+      if (fz > 0) {
+	update_left=0;
+	update_right=1;
+	pr1=p1;
+	pr2=p2;
+      } else {
+	update_left=1;
+	update_right=0;
+	l1=p1; 
+	l2=p2;
+      }
+      nb_lines = p2->y - p1->y + 1;
+    }
+
+    /* compute the values for the left edge */
+
+    if (update_left) {
+      dy1 = l2->y - l1->y;
+      dx1 = l2->x - l1->x;
+      if (dy1 > 0) 
+	tmp = (dx1 << 16) / dy1;
+      else
+	tmp = 0;
+      x1 = l1->x;
+      error = 0;
+      derror = tmp & 0x0000ffff;
+      dxdy_min = tmp >> 16;
+      dxdy_max = dxdy_min + 1;
+      
+#ifdef INTERP_Z
+      z1=l1->z;
+      dzdl_min=(dzdy + dzdx * dxdy_min); 
+      dzdl_max=dzdl_min + dzdx;
+#endif
+#ifdef INTERP_RGB
+      r1=l1->r;
+      drdl_min=(drdy + drdx * dxdy_min);
+      drdl_max=drdl_min + drdx;
+      
+      g1=l1->g;
+      dgdl_min=(dgdy + dgdx * dxdy_min);
+      dgdl_max=dgdl_min + dgdx;
+      
+      b1=l1->b;
+      dbdl_min=(dbdy + dbdx * dxdy_min);
+      dbdl_max=dbdl_min + dbdx;
+#endif
+#ifdef INTERP_ST
+      s1=l1->s;
+      dsdl_min=(dsdy + dsdx * dxdy_min);
+      dsdl_max=dsdl_min + dsdx;
+      
+      t1=l1->t;
+      dtdl_min=(dtdy + dtdx * dxdy_min);
+      dtdl_max=dtdl_min + dtdx;
+#endif
+#ifdef INTERP_STZ
+      sz1=l1->sz;
+      dszdl_min=(dszdy + dszdx * dxdy_min);
+      dszdl_max=dszdl_min + dszdx;
+      
+      tz1=l1->tz;
+      dtzdl_min=(dtzdy + dtzdx * dxdy_min);
+      dtzdl_max=dtzdl_min + dtzdx;
+#endif
+    }
+
+    /* compute values for the right edge */
+
+    if (update_right) {
+      dx2 = (pr2->x - pr1->x);
+      dy2 = (pr2->y - pr1->y);
+      if (dy2>0) 
+	dx2dy2 = ( dx2 << 16) / dy2;
+      else
+	dx2dy2 = 0;
+      x2 = pr1->x << 16;
+    }
+
+    /* we draw all the scan line of the part */
+
+    while (nb_lines>0) {
+      nb_lines--;
+#ifndef DRAW_LINE
+      /* generic draw line */
+      {
+          register PIXEL *pp;
+          register int n;
+#ifdef INTERP_Z
+          register unsigned short *pz;
+          register unsigned int z,zz;
+#endif
+#ifdef INTERP_RGB
+          register unsigned int or1,og1,ob1;
+#endif
+#ifdef INTERP_ST
+          register unsigned int s,t;
+#endif
+#ifdef INTERP_STZ
+          float sz,tz;
+#endif
+
+          n=(x2 >> 16) - x1;
+          pp=(PIXEL *)((char *)pp1 + x1 * PSZB);
+#ifdef INTERP_Z
+          pz=pz1+x1;
+          z=z1;
+#endif
+#ifdef INTERP_RGB
+          or1 = r1;
+          og1 = g1;
+          ob1 = b1;
+#endif
+#ifdef INTERP_ST
+          s=s1;
+          t=t1;
+#endif
+#ifdef INTERP_STZ
+          sz=sz1;
+          tz=tz1;
+#endif
+          while (n>=3) {
+              PUT_PIXEL(0);
+              PUT_PIXEL(1);
+              PUT_PIXEL(2);
+              PUT_PIXEL(3);
+#ifdef INTERP_Z
+              pz+=4;
+#endif
+              pp=(PIXEL *)((char *)pp + 4 * PSZB);
+              n-=4;
+          }
+          while (n>=0) {
+              PUT_PIXEL(0);
+#ifdef INTERP_Z
+              pz+=1;
+#endif
+              pp=(PIXEL *)((char *)pp + PSZB);
+              n-=1;
+          }
+      }
+#else
+      DRAW_LINE();
+#endif
+      
+      /* left edge */
+      error+=derror;
+      if (error > 0) {
+	error-=0x10000;
+	x1+=dxdy_max;
+#ifdef INTERP_Z
+	z1+=dzdl_max;
+#endif      
+#ifdef INTERP_RGB
+	r1+=drdl_max;
+	g1+=dgdl_max;
+	b1+=dbdl_max;
+#endif
+#ifdef INTERP_ST
+	s1+=dsdl_max;
+	t1+=dtdl_max;
+#endif
+#ifdef INTERP_STZ
+	sz1+=dszdl_max;
+	tz1+=dtzdl_max;
+#endif
+      } else {
+	x1+=dxdy_min;
+#ifdef INTERP_Z
+	z1+=dzdl_min;
+#endif      
+#ifdef INTERP_RGB
+	r1+=drdl_min;
+	g1+=dgdl_min;
+	b1+=dbdl_min;
+#endif
+#ifdef INTERP_ST
+	s1+=dsdl_min;
+	t1+=dtdl_min;
+#endif
+#ifdef INTERP_STZ
+	sz1+=dszdl_min;
+	tz1+=dtzdl_min;
+#endif
+      } 
+      
+      /* right edge */
+      x2+=dx2dy2;
+
+      /* screen coordinates */
+      pp1=(PIXEL *)((char *)pp1 + zb->linesize);
+      pz1+=zb->xsize;
+    }
+  }
+}
+
+#undef INTERP_Z
+#undef INTERP_RGB
+#undef INTERP_ST
+#undef INTERP_STZ
+
+#undef DRAW_INIT
+#undef DRAW_LINE  
+#undef PUT_PIXEL