GL3D GWIN window + demo

3rdparty/tinygl-0.4-ugfx/BeOS/GLView.cpp

@@ -0,0 +1,205 @@
+#include "GLView.h"
+#include <stdio.h>
+#include <interface/Bitmap.h>
+
+BLocker BGLView::locker;
+
+BGLView::BGLView(BRect rect, char *name,
+                 ulong resizingMode, ulong mode,
+                 ulong options)
+  : BView(rect, name, resizingMode, mode|B_FRAME_EVENTS|B_WILL_DRAW)
+{
+#ifdef __INTEL__
+  color_space cs = B_RGB16_LITTLE;
+#else
+  color_space cs = B_RGB16_BIG;
+#endif
+  this->bitmaps[0] = new BBitmap(rect, cs, false, true);
+  this->bitmaps[1] = new BBitmap(rect, cs, false, true);
+
+  this->currBitmap = 0;
+  int w = this->bitmaps[0]->BytesPerRow() / 2;
+  int h = rect.Height() + 1;
+  void *buffers[2];
+  buffers[0] = this->bitmaps[0]->Bits();
+  buffers[1] = this->bitmaps[1]->Bits();
+  this->context = ostgl_create_context(w, h, 16, buffers, 2);
+  ostgl_make_current(this->context, 0); 
+}
+
+BGLView::~BGLView()
+{
+  ostgl_delete_context(this->context);
+  delete this->bitmaps[0];
+  delete this->bitmaps[1];
+}
+
+void 
+BGLView::LockGL()
+{  
+  BGLView::locker.Lock();
+  ostgl_make_current(this->context, this->currBitmap);
+}
+
+void 
+BGLView::UnlockGL()
+{
+  BGLView::locker.Unlock();
+}
+
+void 
+BGLView::SwapBuffers()
+{
+  if (Window()->Lock()) {
+    DrawBitmap(this->bitmaps[this->currBitmap]);
+    Window()->Unlock();
+    this->currBitmap ^= 1;
+  }
+}
+
+/*
+BView *
+BGLView::EmbeddedView()
+{
+  return NULL;
+}
+
+status_t 
+BGLView::CopyPixelsOut(BPoint source, BBitmap *dest)
+{
+  assert(0);
+  return 0;
+}
+
+status_t 
+BGLView::CopyPixelsIn(BBitmap *source, BPoint dest)
+{
+  assert(0);
+  return 0;
+}
+*/
+
+void 
+BGLView::ErrorCallback(GLenum /*errorCode*/)
+{
+}
+
+void 
+BGLView::Draw(BRect rect)
+{
+  //fprintf(stderr, "GLView::Draw()");
+  DrawBitmap(this->bitmaps[this->currBitmap^1], rect, rect);
+}
+
+void 
+BGLView::AttachedToWindow()
+{
+}
+
+void 
+BGLView::AllAttached()
+{
+}
+
+void 
+BGLView::DetachedFromWindow()
+{
+}
+
+void 
+BGLView::AllDetached()
+{
+}
+
+void 
+BGLView::FrameResized(float w, float h)
+{
+  delete this->bitmaps[0];
+  delete this->bitmaps[1];
+#ifdef __INTEL__
+  color_space cs = B_RGB16_LITTLE;
+#else
+  color_space cs = B_RGB16_BIG;
+#endif
+  this->bitmaps[0] = new BBitmap(BRect(0,0, w-1, h-1), 
+                                 cs, false, true);
+  this->bitmaps[1] = new BBitmap(BRect(0,0, w-1, h-1), 
+                                 cs, false, true);
+  int w2 = this->bitmaps[0]->BytesPerRow() / 2;
+  void *buffers[2];
+  buffers[0] = this->bitmaps[0]->Bits();
+  buffers[1] = this->bitmaps[1]->Bits();
+  ostgl_resize(this->context, w2, h, buffers);
+}
+
+/*
+status_t 
+BGLView::Perform(perform_code d, void *arg)
+{
+  
+}
+*/
+
+//
+// the rest are pass-through functions
+//
+
+status_t 
+BGLView::Archive(BMessage *data, bool deep) const
+{
+  return BView::Archive(data, deep);
+}
+
+void 
+BGLView::MessageReceived(BMessage *msg)
+{
+  BView::MessageReceived(msg);
+}
+
+void 
+BGLView::SetResizingMode(uint32 mode)
+{
+  BView::SetResizingMode(mode);
+}
+
+void 
+BGLView::Show()
+{
+  BView::Show();
+}
+
+void 
+BGLView::Hide()
+{
+  BView::Hide();
+}
+
+BHandler *
+BGLView::ResolveSpecifier(BMessage *msg, int32 index,
+                          BMessage *specifier, int32 form,
+					      const char *property)
+{
+  return BView::ResolveSpecifier(msg, index, specifier, form, property);
+}
+
+status_t 
+BGLView::GetSupportedSuites(BMessage *data)
+{
+  return BView::GetSupportedSuites(data);
+}
+
+/*
+void 
+BGLView::DirectConnected( direct_buffer_info *info )
+{
+  BView::DirectConnected(info);
+}
+*/
+
+/*
+void 
+BGLView::EnableDirectMode( bool enabled )
+{
+  BView::EnableDirectMode(enabled);
+}
+*/

3rdparty/tinygl-0.4-ugfx/BeOS/GLView.h

@@ -0,0 +1,72 @@
+#ifndef _glview_h_
+#define _glview_h_
+
+#define BGL_RGB           0
+#define BGL_INDEX         1
+#define BGL_SINGLE        0
+#define BGL_DOUBLE        2
+#define BGL_DIRECT        0
+#define BGL_INDIRECT      4
+#define BGL_ACCUM         8
+#define BGL_ALPHA        16
+#define BGL_DEPTH        32
+#define BGL_OVERLAY      64
+#define BGL_UNDERLAY    128
+#define BGL_STENCIL     512
+
+#include <interface/View.h>
+#include <support/Locker.h>
+#include <GL/gl.h>
+#include <GL/oscontext.h>
+#include <game/WindowScreen.h>
+#include <game/DirectWindow.h>
+
+class BGLView : public BView {
+public:
+  BGLView(BRect rect, char *name,
+          ulong resizingMode, ulong mode,
+          ulong options);
+  virtual ~BGLView();
+
+  void LockGL();
+  void UnlockGL();
+  void SwapBuffers();
+//  BView *EmbeddedView();
+//  status_t CopyPixelsOut(BPoint source, BBitmap *dest);
+//  status_t CopyPixelsIn(BBitmap *source, BPoint dest);
+
+  virtual void ErrorCallback(GLenum errorCode);
+  virtual void Draw(BRect updateRect);
+  virtual void AttachedToWindow();
+  virtual void AllAttached();
+  virtual void DetachedFromWindow();
+  virtual void AllDetached();
+  virtual void FrameResized(float width, float height);
+//  virtual status_t Perform(perform_code d, void *arg);
+
+  //
+  // Methods below are pass-throughs to BView for the moment.
+  //
+  
+  virtual status_t Archive(BMessage *data, bool deep = true) const;
+  virtual void MessageReceived(BMessage *msg);
+  virtual void SetResizingMode(uint32 mode);
+
+  virtual void Show();
+  virtual void Hide();
+
+  virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index,
+							         BMessage *specifier, int32 form,
+							         const char *property);
+  virtual status_t GetSupportedSuites(BMessage *data);
+  //void DirectConnected( direct_buffer_info *info );
+  //void EnableDirectMode( bool enabled );
+
+private:
+  ostgl_context *context;
+  BBitmap *bitmaps[2];
+  int currBitmap;
+  static BLocker locker;
+};
+
+#endif // _glview_h_

3rdparty/tinygl-0.4-ugfx/BeOS/Makefile

@@ -0,0 +1,16 @@
+OBJS=GLView.o 
+INCLUDES = -I../include
+LIB = libGLView.a
+
+all: $(LIB)
+
+$(LIB): $(OBJS)
+	rm -f $(LIB)
+	ar rcs $(LIB) $(OBJS)
+	cp $(LIB) ../lib
+
+clean:
+	rm -f *~ *.o *.a
+
+GLView.o: GLView.cpp GLView.h
+	$(CC) $(CFLAGS) $(INCLUDES) -c GLView.cpp

3rdparty/tinygl-0.4-ugfx/Changelog

@@ -0,0 +1,38 @@
+version 0.4: 
+ - added 24/32 bit rendering support (Olivier Landemarre - F. Bellard)
+ - fixed GL_TRIANGLE_STRIP (Olivier Landemarre)
+ - added gl_malloc, gl_free, gl_zalloc wrappers (Olivier Landemarre)
+
+version 0.3:
+ - added NanoX API (nglx) (F. Bellard)
+ - added gears example and unified GUI in examples (F. Bellard)
+ - added TGL_FEATURE_RENDER_BITS so that it will be possible to render
+   natively in 15/16/24 or 32 bits. (F. Bellard)
+ - interpolated lines (Olivier Landemarre)
+ - fast no shading case (Olivier Landemarre)
+ - fast no projection case (Olivier Landemarre)
+
+version 0.2: Fabrice Bellard
+ - added 24/32 bpp support. Added some features.h ifdefs.
+ - fixed some error reporting cases in the examples
+ - endianness is deduced from the glibc (BYTE_ORDER macro)
+
+version 0.19: Peder Blekken 
+ - new files BeOS/* src/msghandling.*, src/arrays.*, src/oscontext.c
+     include/GL/oscontext.h src/features.h
+ - added support for BeOS, see README.BEOS
+ - added support for drawing convex polygons with unlimited # of vertices
+ - added support for GL_LIGHT_MODEL_TWO_SIDE
+ - added generic rotation code for glopRotate
+ - added support for opengl 1.1 arrays
+ - added support for glPolygonOffset, not implemented.
+ - added glGetFloatv, limited support.
+ - added some pnames for glGetIntegerv
+ - added some empty functions in include/GL/gl.h to compile VRMLView
+ - added GL_VERSION_1_1 define in include/GL/gl.h    
+ - fixed "bug" when context->gl_resize_viewport is not set.
+ - fixed bug in glBindTexture (didn't accept texture object 0)
+
+version 0.1:
+ - Initial revision, Fabrice Bellard
+

3rdparty/tinygl-0.4-ugfx/INSTALL

@@ -0,0 +1,10 @@
+Installation:
+
+- Edit config.mk and change what is needed. You can also look at
+src/zfeatures.h to change very specific details (only useful to tune
+TinyGL to your needs). You can link the examples with either OpenGL,
+Mesa or TinyGL.
+
+- Type 'make'. The library 'libTinyGL.a' is copied into './lib'. The
+examples are build in './examples'. Only the directories './lib' and
+'./include' are needed to use TinyGL from another program.

3rdparty/tinygl-0.4-ugfx/LICENCE

@@ -0,0 +1,22 @@
+Copyright notice:
+
+ (C) 1997-1998 Fabrice Bellard
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product and its documentation 
+     *is* required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+If you redistribute modified sources, I would appreciate that you
+include in the files history information documenting your changes.

3rdparty/tinygl-0.4-ugfx/LIMITATIONS

@@ -0,0 +1,206 @@
+
+Here are listed the functions that TinyGL understands with the known
+limitations. The non mentionned functions are *not* implemented and
+must not be used.
+
+
+************ glEnable / glDisable
+
+- The following flags are handled:
+
+GL_CULL_FACE, GL_LIGHTING, GL_COLOR_MATERIAL, GL_TEXTURE_2D, GL_NORMALIZE,
+GL_LIGHTx, GL_POLYGON_OFFSET_FILL, GL_POLYGON_OFFSET_POINT,
+GL_POLYGON_OFFSET_LINE
+
+
+- GL_DEPTH_TEST is accepted, but it is only used for lines. For all
+  other primitives, Z buffer use is assumed.  The DepthMode is
+  hardcoded as GL_LESS (OpenGL default).
+
+************ glShadeModel
+
+OK.
+
+************ glCullFace
+
+OK.
+
+************ glPolygonMode
+
+OK.
+
+************ glBegin
+
+No tests are performed to prevent some functions of being executed
+between glBegin/glEnd.
+
+************ glEnd
+
+OK.
+
+************ glVertex
+
+Some prototypes are not implemented.
+
+
+************ glColor
+
+Some prototypes are not implemented.
+
+************ glNormal
+
+Some prototypes are not implemented.
+
+************ glTexCoord
+
+- Some prototypes are not implemented.
+
+- The Matrix transformation is not applied yet.
+
+************ glEdgeFlag
+
+OK. The edge handling has to be tested, although it is not much useful
+in TinyGL.
+
+************ glMatrixMode / glLoadMatrixf / glLoadIdentity / glMultMatrixf /
+             glPushMatrix / glPopMatrix / glRotatef / glTranslatef / glScalef /
+             glFrustum
+
+- The prototypes with doubles are not implemented.
+
+************ glViewport
+
+GlViewport calls a function pointers to tell glx (or another display
+system) to resize the Z buffer and the ximage. Made optional in
+version 0.2.
+
+************ glGenLists / glIsList / glNewList / glEndList / glCallList
+
+OK.
+
+************ glClear / glClearColor / glClearDepth
+
+The whole zbuffer and the colors are cleared in any case. The clear color
+can be redefined, by *not* the initial z value.
+
+************ glRenderMode
+
+Only the modes GL_RENDER and GL_SELECT are implemented.
+
+************ glSelectBuffer / glInitNames / glPushName / glPopName / glLoadName
+
+OK.
+
+************ glGenTextures / glDeleteTextures / glBindTexture 
+
+OK. These functions should be used to get the maximum performance with
+TinyGL. 
+
+************ glTexImage2D
+
+The function accepts only RGB UNSIGNED_BYTES bitmaps. They are
+internally resized to 256x256 so you'd better use that size. No
+mipmapping is implemented although it will come if asked. No borders
+are implemented.
+
+************ glTexEnvi
+
+The only supported mode is GL_DECAL, although others are planned if
+asked.
+
+
+************ glTexParameteri
+
+The other prototypes are not implemented. Only the follwing mode are
+implemented:
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+************ glPixelStorei
+
+The pixels are alware byte aligned.
+
+************ glMaterialfv / glMaterialf / glColorMaterial
+
+OK.
+
+
+************ glLightfv / glLightf / glLightModeli / glLightModelfv
+
+OK. The OpenGL lightening is implemented but not optimized.
+
+
+************ glFlush
+
+Ignored.
+
+************ glHint
+
+Ignored.
+
+************ glGetIntegerv
+
+- only GL_VIEWPORT, GL_MAX_MODELVIEW_STACK_DEPTH, 
+GL_MAX_PROJECTION_STACK_DEPTH, GL_MAX_LIGHTS, GL_MAX_TEXTURE_SIZE,
+GL_MAX_TEXTURE_STACK_DEPTH
+
+************ glGetIntegerv
+
+- only GL_TEXTURE_MATRIX, GL_PROJECTION_MATRIX, GL_MODELVIEW_MATRIX,
+GL_LINE_WIDTH, GL_LINE_WIDTH_RANGE, GL_POINT_SIZE, GL_POINT_SIZE_RANGE
+
+************ glPolygonOffset
+
+- only API implemented.
+
+************ glEnableClientState, glDisableClientState,
+             
+- No support for GL_INDEX_ARRAY_POINTER or GL_EDGE_FLAG_ARRAY_POINTER
+
+************ glVertexPointer, glNormalPointer, 
+             glColorPointer, glTexureCoordPointer
+
+- OK
+
+------------------------------------------------------------------------------
+
+TinyGL GLX emulation:
+
+
+************ glXQueryExtension
+
+Returns always True
+
+************ glXChooseVisual
+
+Only 8 bit Pseudocolor or 16 bit Truecolor Visual are accepted. The
+attribute list is ignored.
+
+************ glXCreateContext
+
+The sharing is not implemented although the code could handle it.
+
+************ glXDestroyContext
+
+OK.
+
+************ glXMakeCurrent
+
+Not all the syntax is supported yet, in particular with the 'NULL' or
+'None' parameters.
+
+
+************ glXSwapBuffers
+
+OK.
+
+************ glXWaitGL / glXWaitX
+
+Ignored.
+
+
+See README.BEOS for BeOS limitations.
+

3rdparty/tinygl-0.4-ugfx/Makefile

@@ -0,0 +1,15 @@
+include config.mk
+
+all:
+	( for f in $(DIRS); do ( cd $$f ; make all ) || exit 1 ; done )
+
+clean:
+	rm -f *~ lib/libTinyGL.a include/GL/*~ TAGS
+	( for f in $(DIRS); do ( cd $$f ; make clean ; ) done )
+
+install:
+	( for f in $(DIRS); do ( cd $$f ; make install ; ) done )
+
+
+tar:
+	( cd .. ; tar zcvf TinyGL-0.4.tar.gz TinyGL --exclude CVS --exclude TAGS )

3rdparty/tinygl-0.4-ugfx/README

@@ -0,0 +1,150 @@
+TinyGL 0.4 (c) 1997-2002 Fabrice Bellard.
+
+General Description:
+--------------------
+
+TinyGL is intended to be a very small implementation of a subset of
+OpenGL* for embedded systems or games. It is a software only
+implementation. Only the main OpenGL calls are implemented. All the
+calls I considered not important are simply *not implemented*.
+
+The main strength of TinyGL is that it is fast and simple because it
+has not to be exactly compatible with OpenGL. In particular, the
+texture mapping and the geometrical transformations are very fast.
+
+The main features of TinyGL are:
+
+- Header compatible with OpenGL (the headers are adapted from the very good
+Mesa by Brian Paul et al.)
+
+- Zlib-like licence for easy integration in commercial designs (read
+the LICENCE file).
+
+- Subset of GLX for easy testing with X Window. 
+
+- GLX like API (NGLX) to use it with NanoX in MicroWindows/NanoX.
+
+- Subset of BGLView under BeOS.
+
+- OpenGL like lightening.
+
+- Complete OpenGL selection mode handling for object picking.
+
+- 16 bit Z buffer. 16/24/32 bit RGB rendering. High speed dithering to
+paletted 8 bits if needed. High speed conversion to 24 bit packed
+pixel or 32 bit RGBA if needed.
+
+- Fast Gouraud shadding optimized for 16 bit RGB.
+
+- Fast texture mapping capabilities, with perspective correction and
+texture objects.
+
+- 32 bit float only arithmetic.
+
+- Very small: compiled code size of about 40 kB on x86. The file
+  src/zfeatures.h can be used to remove some unused features from
+  TinyGL.
+
+- C sources for GCC on 32/64 bit architectures. It has been tested
+succesfully on x86-Linux and sparc-Solaris.
+
+Examples:
+---------
+
+I took three simple examples from the Mesa package to test the main
+functions of TinyGL. You can link them to either TinyGL, Mesa or any
+other OpenGL/GLX implementation. You can also compile them with
+Microwindows.
+
+- texobj illustrates the use of texture objects. Its shows the speed
+of TinyGL in this case.
+
+- glutmech comes from the GLUT packages. It is much bigger and slower
+because it uses the lightening. I have just included some GLU
+functions and suppressed the GLUT related code to make it work. It
+shows the display list handling of TinyGL in particular. You can look
+at the source code to learn the keys to move the robot. The key 't'
+toggles between shaded rendering and wire frame.
+
+- You can download and compile the VReng project to see that TinyGL
+has been successfully used in a big project
+(http://www-inf.enst.fr/vreng).
+
+Architecture:
+-------------
+
+TinyGL is made up four main modules:
+
+- Mathematical routines (zmath).
+
+- OpenGL-like emulation (zgl).
+
+- Z buffer and rasterisation (zbuffer).
+
+- GLX interface (zglx).
+
+To use TinyGL in an embedded system, you should look at the GLX layer
+and modify it to suit your need. Adding a more user friendly
+developper layer (as in Mesa) may be useful.
+
+Notes - limitations:
+--------------------
+
+- See the file 'LIMITATIONS' to see the current functions supported by the API.
+
+- The multithreading could be easily implemented since no global state
+is maintainted. The library gets the current context with a function
+which can be modified.
+
+- The lightening is not very fast. I supposed that in most games the
+lightening is computed by the 3D engine.
+
+- Some changes are needed for 64 bit pointers for the handling of
+arrays of float with the GLParam union.
+
+- List sharing is partialy supported in the source, but not by the
+current TinyGLX implementation (is it really useful ?).
+
+- No user clipping planes are supported.
+
+- No color index mode (no longer useful !)
+
+- The mipmapping is not implemented.
+
+- The perspecture correction in the mapping code does not use W but
+1/Z. In any 'normal scene' it should work.
+
+- The resizing of the viewport in TinyGLX ensures that the width and
+the height are multiples of 4. This is not optimal because some pixels
+of the window may not be refreshed.
+
+Why ?
+-----
+
+TinyGL was developped as a student project for a Virtual Reality
+network system called VReng (see the VReng home page at
+http://www-inf.enst.fr/vreng).
+
+At that time (January 1997), my initial project was to write my own 3D
+rasterizer based on some old sources I wrote. But I realized that it
+would be better to use OpenGL to work on any platform. My problem was
+that I wanted to use texture mapping which was (and is still) quite
+slower on many software OpenGL implementation. I could have modified
+Mesa to suit my needs, but I really wanted to use my old sources for
+that project. 
+
+I finally decided to use the same syntax as OpenGL but with my own
+libraries, thinking that later it could ease the porting of VReng to
+OpenGL.
+
+Now VReng is at last compatible with OpenGL, and I managed to patch
+TinyGL so that VReng can still work with it without any modifications.
+
+Since TinyGL may be useful for some people, especially in the world of
+embedded designs, I decided to release it 'as is', otherwise, it would
+have been lost on my hard disk !
+
+------------------------------------------------------------------------------
+* OpenGL(R) is a registered trademark of Silicon Graphics, Inc.
+------------------------------------------------------------------------------
+Fabrice Bellard.

3rdparty/tinygl-0.4-ugfx/README.BEOS

@@ -0,0 +1,20 @@
+BeOS support for TinyGL, 1998 Peder Blekken
+
+I implemented (a limited version of) the BGLView class. There is 
+no DirectWindow support, and some other funtions are missing too,
+but it should work ok for most uses. Feel free to use and modify 
+GLView.cpp and GLView.h in any way you desire.
+
+You will need to take a look in Makefile to compile the library
+under BeOS. For those of you not familiar with using makefiles: too bad :)
+
+Also, you will probably need to remove  /boot/develop/headers/be/opengl 
+from the BEINCLUDES environment variable. Unfortunately, this means 
+editing the /boot/beos/system/boot/SetupEnvironment. It might be possible 
+to just make sure the TinyGL path is before Be's  OpenGL in the include-paths 
+though. But I prefer to remove /boot/develop/headers/be/opengl, since I 
+often use Mesa as well. It is a better to add the OpenGL include path in your 
+makefile; or BeIDE project if that is what you use.
+
+Contact me for any reason: <pederb@sim.no>
+

3rdparty/tinygl-0.4-ugfx/README.uGFX

@@ -0,0 +1,4 @@
+uGFX support for TinyGL, 2014 Andrew Hannam
+
+Some files have been modified to remove references to non-embedded
+functions such as fprintf, exit and assert.

3rdparty/tinygl-0.4-ugfx/config.mk

@@ -0,0 +1,82 @@
+#####################################################################
+# C compiler
+
+# linux
+CC= gcc
+CFLAGS= -g -Wall -O2
+LFLAGS=
+
+# for BeOS PPC
+#CC= mwcc
+#CFLAGS= -I. -i-
+#LFLAGS=
+
+#####################################################################
+# TinyGL configuration 
+
+#####################################################################
+# Select window API for TinyGL: 
+
+# standard X11 GLX like API 
+TINYGL_USE_GLX=y
+
+# BEOS API
+#TINYGL_USE_BEOS=y
+
+# Micro Windows NanoX API
+#TINYGL_USE_NANOX=y
+
+#####################################################################
+# X11 configuration (for the examples only)
+
+ifdef TINYGL_USE_GLX
+# Linux
+UI_LIBS= -L/usr/X11R6/lib -lX11 -lXext
+UI_INCLUDES= 
+# Solaris
+#UI_LIBS= -L/usr/X11/lib -lX11 -lXext -lsocket -lnsl
+#UI_INCLUDES= 
+
+UI_OBJS=x11.o
+endif
+
+#####################################################################
+# Micro windowX11 configuration (for the examples only)
+
+ifdef TINYGL_USE_NANOX
+UI_LIBS= -lnano-X -lmwengine -lmwdrivers -lmwfonts
+UI_INCLUDES=
+
+# X11 target for nanoX
+UI_LIBS+= -L/usr/X11R6/lib -lX11 -lXext
+
+UI_OBJS=nanox.o
+endif
+
+#####################################################################
+# OpenGL configuration (for the examples only)
+
+# use TinyGL 
+GL_LIBS= -L../lib -lTinyGL 
+GL_INCLUDES= -I../include
+GL_DEPS= ../lib/libTinyGL.a
+
+# use Mesa
+#GL_LIBS= -lMesaGL 
+#GL_INCLUDES= 
+#GL_DEPS=
+
+# use OpenGL
+#GL_LIBS= -lGL 
+#GL_INCLUDES= 
+#GL_DEPS=
+
+####################################################################
+# Compile and link control
+
+# UNIX systems
+DIRS= src examples
+
+# BeOS
+# DIRS= src BeOS
+

3rdparty/tinygl-0.4-ugfx/examples/Makefile

@@ -0,0 +1,29 @@
+include ../config.mk
+
+PROGS = mech texobj gears spin
+
+all: $(PROGS)
+
+clean:
+	rm -f core *.o *~ $(PROGS)
+
+mech: mech.o glu.o $(UI_OBJS) $(GL_DEPS)
+	$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+
+texobj: texobj.o $(UI_OBJS) $(GL_DEPS)
+	$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+
+gears: gears.o $(UI_OBJS) $(GL_DEPS)
+	$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+
+spin: spin.o $(UI_OBJS) $(GL_DEPS)
+	$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm
+
+.c.o:
+	$(CC)	$(CFLAGS) $(GL_INCLUDES) $(UI_INCLUDES) -c $*.c
+
+mech.o: glu.h 
+
+glu.o: glu.h
+
+ui.o: ui.h

3rdparty/tinygl-0.4-ugfx/examples/gears.c

@@ -0,0 +1,300 @@
+/* gears.c */
+
+/*
+ * 3-D gear wheels.  This program is in the public domain.
+ *
+ * Brian Paul
+ */
+
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <GL/glx.h> 
+#include <GL/gl.h> 
+#include "ui.h"
+
+#ifndef M_PI
+#  define M_PI 3.14159265
+#endif
+
+
+/*
+ * Draw a gear wheel.  You'll probably want to call this function when
+ * building a display list since we do a lot of trig here.
+ *
+ * Input:  inner_radius - radius of hole at center
+ *         outer_radius - radius at center of teeth
+ *         width - width of gear
+ *         teeth - number of teeth
+ *         tooth_depth - depth of tooth
+ */
+static void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
+		  GLint teeth, GLfloat tooth_depth )
+{
+   GLint i;
+   GLfloat r0, r1, r2;
+   GLfloat angle, da;
+   GLfloat u, v, len;
+
+   r0 = inner_radius;
+   r1 = outer_radius - tooth_depth/2.0;
+   r2 = outer_radius + tooth_depth/2.0;
+
+   da = 2.0*M_PI / teeth / 4.0;
+
+   glShadeModel( GL_FLAT );
+
+   glNormal3f( 0.0, 0.0, 1.0 );
+
+   /* draw front face */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+      glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 );
+   }
+   glEnd();
+
+   /* draw front sides of teeth */
+   glBegin( GL_QUADS );
+   da = 2.0*M_PI / teeth / 4.0;
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 );
+   }
+   glEnd();
+
+
+   glNormal3f( 0.0, 0.0, -1.0 );
+
+   /* draw back face */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glVertex3f( r1*cos(angle), r1*sin(angle), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+   }
+   glEnd();
+
+   /* draw back sides of teeth */
+   glBegin( GL_QUADS );
+   da = 2.0*M_PI / teeth / 4.0;
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   -width*0.5 );
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      -width*0.5 );
+   }
+   glEnd();
+
+
+   /* draw outward faces of teeth */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+
+      glVertex3f( r1*cos(angle),      r1*sin(angle),       width*0.5 );
+      glVertex3f( r1*cos(angle),      r1*sin(angle),      -width*0.5 );
+      u = r2*cos(angle+da) - r1*cos(angle);
+      v = r2*sin(angle+da) - r1*sin(angle);
+      len = sqrt( u*u + v*v );
+      u /= len;
+      v /= len;
+      glNormal3f( v, -u, 0.0 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),    width*0.5 );
+      glVertex3f( r2*cos(angle+da),   r2*sin(angle+da),   -width*0.5 );
+      glNormal3f( cos(angle), sin(angle), 0.0 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da),  width*0.5 );
+      glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 );
+      u = r1*cos(angle+3*da) - r2*cos(angle+2*da);
+      v = r1*sin(angle+3*da) - r2*sin(angle+2*da);
+      glNormal3f( v, -u, 0.0 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da),  width*0.5 );
+      glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
+      glNormal3f( cos(angle), sin(angle), 0.0 );
+   }
+
+   glVertex3f( r1*cos(0), r1*sin(0), width*0.5 );
+   glVertex3f( r1*cos(0), r1*sin(0), -width*0.5 );
+
+   glEnd();
+
+
+   glShadeModel( GL_SMOOTH );
+
+   /* draw inside radius cylinder */
+   glBegin( GL_QUAD_STRIP );
+   for (i=0;i<=teeth;i++) {
+      angle = i * 2.0*M_PI / teeth;
+      glNormal3f( -cos(angle), -sin(angle), 0.0 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
+      glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
+   }
+   glEnd();
+      
+}
+
+
+static GLfloat view_rotx=20.0, view_roty=30.0, view_rotz=0.0;
+static GLint gear1, gear2, gear3;
+static GLfloat angle = 0.0;
+
+static GLuint limit;
+static GLuint count = 1;
+
+
+void draw( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+   glPushMatrix();
+   glRotatef( view_rotx, 1.0, 0.0, 0.0 );
+   glRotatef( view_roty, 0.0, 1.0, 0.0 );
+   glRotatef( view_rotz, 0.0, 0.0, 1.0 );
+
+   glPushMatrix();
+   glTranslatef( -3.0, -2.0, 0.0 );
+   glRotatef( angle, 0.0, 0.0, 1.0 );
+   glCallList(gear1);
+   glPopMatrix();
+
+   glPushMatrix();
+   glTranslatef( 3.1, -2.0, 0.0 );
+   glRotatef( -2.0*angle-9.0, 0.0, 0.0, 1.0 );
+   glCallList(gear2);
+   glPopMatrix();
+
+   glPushMatrix();
+   glTranslatef( -3.1, 4.2, 0.0 );
+   glRotatef( -2.0*angle-25.0, 0.0, 0.0, 1.0 );
+   glCallList(gear3);
+   glPopMatrix();
+
+   glPopMatrix();
+
+   tkSwapBuffers();
+
+   count++;
+   if (count==limit) {
+       exit(0);
+   }
+}
+
+
+
+void idle( void )
+{
+   angle += 2.0;
+   draw();
+}
+
+
+
+/* change view angle, exit upon ESC */
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+      case KEY_UP:
+         view_rotx += 5.0;
+	 return GL_TRUE;
+      case KEY_DOWN:
+         view_rotx -= 5.0;
+	 return GL_TRUE;
+      case KEY_LEFT:
+         view_roty += 5.0;
+	 return GL_TRUE;
+      case KEY_RIGHT:
+         view_roty -= 5.0;
+	 return GL_TRUE;
+      case 'z':
+	 view_rotz += 5.0;
+	 return GL_TRUE;
+      case 'Z':
+	 view_rotz -= 5.0;
+	 return GL_TRUE;
+      case KEY_ESCAPE:
+          exit(0);
+   }
+   return GL_FALSE;
+}
+
+
+
+/* new window size or exposure */
+void reshape( int width, int height )
+{
+   GLfloat  h = (GLfloat) height / (GLfloat) width;
+
+   glViewport(0, 0, (GLint)width, (GLint)height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum( -1.0, 1.0, -h, h, 5.0, 60.0 );
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+   glTranslatef( 0.0, 0.0, -40.0 );
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+}
+
+
+void init( void )
+{
+   static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0 };
+   static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0 };
+   static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0 };
+   static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0 };
+
+   glLightfv( GL_LIGHT0, GL_POSITION, pos );
+   glEnable( GL_CULL_FACE );
+   glEnable( GL_LIGHTING );
+   glEnable( GL_LIGHT0 );
+   glEnable( GL_DEPTH_TEST );
+
+   /* make the gears */
+   gear1 = glGenLists(1);
+   glNewList(gear1, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red );
+   gear( 1.0, 4.0, 1.0, 20, 0.7 );
+   glEndList();
+
+   gear2 = glGenLists(1);
+   glNewList(gear2, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green );
+   gear( 0.5, 2.0, 2.0, 10, 0.7 );
+   glEndList();
+
+   gear3 = glGenLists(1);
+   glNewList(gear3, GL_COMPILE);
+   glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue );
+   gear( 1.3, 2.0, 0.5, 10, 0.7 );
+   glEndList();
+
+   glEnable( GL_NORMALIZE );
+}
+
+int main(int argc, char **argv) 
+{
+   if (argc>1) {
+      /* do 'n' frames then exit */
+      limit = atoi( argv[1] ) + 1;
+   }
+   else {
+      limit = 0;
+   }
+
+   return ui_loop(argc, argv, "gears");
+}
+
+

3rdparty/tinygl-0.4-ugfx/examples/glu.c

@@ -0,0 +1,261 @@
+#include <stdlib.h>
+#include <math.h>
+#include <GL/gl.h>
+#include "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 );
+}
+
+GLUquadricObj *gluNewQuadric(void)
+{
+  return NULL;
+}
+
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style)
+{
+}
+
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks )
+{
+   GLdouble da, r, dr, dz;
+   GLfloat z, nz, nsign;
+   GLint i, j;
+   GLfloat du = 1.0 / slices;
+   GLfloat dv = 1.0 / stacks;
+   GLfloat tcx = 0.0, tcy = 0.0;
+   
+   nsign = 1.0;
+
+   da = 2.0*M_PI / slices;
+   dr = (topRadius-baseRadius) / stacks;
+   dz = height / stacks;
+   nz = (baseRadius-topRadius) / height;  /* Z component of normal vectors */
+
+   for (i=0;i<slices;i++) {
+	 GLfloat x1 = -sin(i*da);
+	 GLfloat y1 = cos(i*da);
+	 GLfloat x2 = -sin((i+1)*da);
+	 GLfloat y2 = cos((i+1)*da);
+	 z = 0.0;
+	 r = baseRadius;
+	 tcy = 0.0;
+	 glBegin( GL_QUAD_STRIP );
+	 for (j=0;j<=stacks;j++) {
+	    if (nsign==1.0) {
+	       normal3f( x1*nsign, y1*nsign, nz*nsign );
+	       glTexCoord2f(tcx, tcy);
+	       glVertex3f( x1*r, y1*r, z );
+	       normal3f( x2*nsign, y2*nsign, nz*nsign );
+	       glTexCoord2f(tcx+du, tcy);
+	       glVertex3f( x2*r, y2*r, z );
+	    }
+	    else {
+	       normal3f( x2*nsign, y2*nsign, nz*nsign );
+	       glTexCoord2f(tcx, tcy);
+	       glVertex3f( x2*r, y2*r, z );
+	       normal3f( x1*nsign, y1*nsign, nz*nsign );
+	       glTexCoord2f(tcx+du, tcy);
+	       glVertex3f( x1*r, y1*r, z );
+	    }
+	    z += dz;
+	    r += dr;
+	    tcy += dv;
+	 }
+	 glEnd();
+	 tcx += du;
+      }
+}
+
+/* Disk (adapted from Mesa) */
+
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops )
+{
+   GLdouble a, da;
+   GLfloat dr;
+   GLfloat r1, r2, dtc;
+   GLint s, l;
+   GLfloat sa,ca;
+
+   /* Normal vectors */
+	 glNormal3f( 0.0, 0.0, +1.0 );
+
+   da = 2.0*M_PI / slices;
+   dr = (outerRadius-innerRadius) / (GLfloat) loops;
+
+   /* texture of a gluDisk is a cut out of the texture unit square */
+   /* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
+   dtc = 2.0f * outerRadius;
+
+   r1 = innerRadius;
+   for (l=0;l<loops;l++) {
+	    r2 = r1 + dr;
+	       glBegin( GL_QUAD_STRIP );
+	       for (s=0;s<=slices;s++) {
+		  if (s==slices) a = 0.0;
+		  else  a = s * da;
+		  sa = sin(a); ca = cos(a);
+                  glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc);
+                  glVertex2f( r2*sa, r2*ca );
+                  glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc);
+                  glVertex2f( r1*sa, r1*ca );
+	       }
+	       glEnd();
+	    r1 = r2;
+	 }
+
+}
+
+/*
+ * Sphère (adapted from Mesa)
+ */
+
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks)
+{
+   float rho, drho, theta, dtheta;
+   float x, y, z;
+   float s, t, ds, dt;
+   int i, j, imin, imax;
+   int normals;
+   float nsign;
+  
+   normals=1;
+   nsign=1;
+
+   drho = M_PI / (float) stacks;
+   dtheta = 2.0 * M_PI / (float) slices;
+
+  /* draw +Z end as a triangle fan */
+  glBegin( GL_TRIANGLE_FAN );
+  glNormal3f( 0.0, 0.0, 1.0 );
+  glTexCoord2f(0.5,0.0);
+  glVertex3f( 0.0, 0.0, nsign * radius );
+  for (j=0;j<=slices;j++) {
+	 theta = (j==slices) ? 0.0 : j * dtheta;
+	 x = -sin(theta) * sin(drho);
+	 y = cos(theta) * sin(drho);
+	 z = nsign * cos(drho);
+	 if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	 glVertex3f( x*radius, y*radius, z*radius );
+      }
+   glEnd();
+
+
+      ds = 1.0 / slices;
+      dt = 1.0 / stacks;
+      t = 1.0;  /* because loop now runs from 0 */
+      if (1) {
+        imin = 0;
+        imax = stacks;
+      }
+      else {
+        imin = 1;
+        imax = stacks-1;
+      }
+
+      /* draw intermediate stacks as quad strips */
+      for (i=imin;i<imax;i++) {
+	 rho = i * drho;
+	 glBegin( GL_QUAD_STRIP );
+         s = 0.0;
+	 for (j=0;j<=slices;j++) {
+	    theta = (j==slices) ? 0.0 : j * dtheta;
+	    x = -sin(theta) * sin(rho);
+	    y = cos(theta) * sin(rho);
+	    z = nsign * cos(rho);
+	    if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	    glTexCoord2f(s,1-t);
+	    glVertex3f( x*radius, y*radius, z*radius );
+	    x = -sin(theta) * sin(rho+drho);
+	    y = cos(theta) * sin(rho+drho);
+	    z = nsign * cos(rho+drho);
+	    if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	    glTexCoord2f(s,1-(t-dt));
+            s += ds;
+	    glVertex3f( x*radius, y*radius, z*radius );
+	 }
+	 glEnd();
+	 t -= dt;
+      }
+
+/* draw -Z end as a triangle fan */
+    glBegin( GL_TRIANGLE_FAN );
+    glNormal3f( 0.0, 0.0, -1.0 );
+      glTexCoord2f(0.5,1.0);
+      glVertex3f( 0.0, 0.0, -radius*nsign );
+      rho = M_PI - drho;
+      s = 1.0;
+      t = dt;
+      for (j=slices;j>=0;j--) {
+	 theta = (j==slices) ? 0.0 : j * dtheta;
+	 x = -sin(theta) * sin(rho);
+	 y = cos(theta) * sin(rho);
+	 z = nsign * cos(rho);
+	 if (normals)  glNormal3f( x*nsign, y*nsign, z*nsign );
+	 glTexCoord2f(s,1-t);
+         s -= ds;
+	 glVertex3f( x*radius, y*radius, z*radius );
+      }
+      glEnd();
+}

3rdparty/tinygl-0.4-ugfx/examples/glu.h

@@ -0,0 +1,23 @@
+
+void gluPerspective( GLdouble fovy, GLdouble aspect,
+		     GLdouble zNear, GLdouble zFar );
+
+typedef struct {
+  int draw_style;
+} GLUquadricObj;
+
+#define GLU_LINE 0
+
+GLUquadricObj *gluNewQuadric(void);
+void gluQuadricDrawStyle(GLUquadricObj *obj, int style);
+
+void gluSphere(GLUquadricObj *qobj,
+               float radius,int slices,int stacks);
+void gluCylinder( GLUquadricObj *qobj,
+                  GLdouble baseRadius, GLdouble topRadius, GLdouble height,
+                  GLint slices, GLint stacks );
+void gluDisk( GLUquadricObj *qobj,
+              GLdouble innerRadius, GLdouble outerRadius,
+              GLint slices, GLint loops );
+
+void drawTorus(float rc, int numc, float rt, int numt);

3rdparty/tinygl-0.4-ugfx/examples/nanox.c

@@ -0,0 +1,113 @@
+/*
+ * Demonstration program for Nano-X graphics.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define MWINCLUDECOLORS
+#include <microwin/nano-X.h>
+#include <GL/gl.h> 
+#include <GL/nglx.h> 
+#include "ui.h"
+
+static	GR_WINDOW_ID	w1;		/* id for large window */
+static	GR_GC_ID	gc1;		/* graphics context for text */
+
+void errorcatcher();			/* routine to handle errors */
+
+void tkSwapBuffers(void)
+{
+    nglXSwapBuffers(w1);
+}
+
+int
+ui_loop(int argc,char **argv, const char *name)
+{
+	GR_EVENT	event;		/* current event */
+	GR_IMAGE_ID	id = 0;
+        NGLXContext cx;
+        int width, height, k;
+
+	if (GrOpen() < 0) {
+		fprintf(stderr, "cannot open graphics\n");
+		exit(1);
+	}
+	
+        width = 400;
+        height = 300;
+
+	GrSetErrorHandler(errorcatcher);
+
+	w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, width, height, 4, BLACK, WHITE);
+
+	GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN);
+
+	GrMapWindow(w1);
+
+	gc1 = GrNewGC();
+
+	GrSetGCForeground(gc1, WHITE);
+
+        cx = nglXCreateContext(NULL, 0);
+        nglXMakeCurrent(w1, cx);
+        
+        init();
+        reshape(width, height);
+
+	while (1) {
+            GrCheckNextEvent(&event);
+            switch(event.type) {
+            case GR_EVENT_TYPE_CLOSE_REQ:
+                GrFreeImage(id);
+                GrClose();
+                exit(0);
+            case GR_EVENT_TYPE_EXPOSURE:
+                break;
+            case GR_EVENT_TYPE_KEY_DOWN:
+                {
+                    GR_EVENT_KEYSTROKE *kp = &event.keystroke;
+                    /* XXX: nanoX special keys are totally bugged ! */
+                    switch(kp->ch) {
+                    case 81:
+                        k = KEY_LEFT;
+                        break;
+                    case 83:
+                        k = KEY_RIGHT;
+                        break;
+                    case 82:
+                        k = KEY_UP;
+                        break;
+                    case 84:
+                        k = KEY_DOWN;
+                        break;
+                    default:
+                        k = kp->ch;
+                        break;
+                    }
+                    key(k, 0);
+                }
+                break;
+            default:
+                idle();
+                break;
+            }
+        }
+
+	return 0;
+}
+
+
+/*
+ * Here on an unrecoverable error.
+ */
+void
+errorcatcher(code, name, id)
+	GR_ERROR	code;		/* error code */
+	GR_FUNC_NAME	name;		/* function name which failed */
+	GR_ID		id;		/* resource id */
+{
+	GrClose();
+	fprintf(stderr, "DEMO ERROR: code %d, function %s, resource id %d\n",
+		code, name, id);
+	exit(1);
+}

3rdparty/tinygl-0.4-ugfx/examples/spin.c

@@ -0,0 +1,160 @@
+/* spin.c */
+
+
+/*
+ * Spinning box.  This program is in the public domain.
+ *
+ * Brian Paul
+ */
+
+
+#include <math.h>
+#include <stdio.h>
+
+#include <GL/glx.h> 
+#include <GL/gl.h> 
+#include "ui.h"
+
+
+
+
+static GLfloat Xrot, Xstep;
+static GLfloat Yrot, Ystep;
+static GLfloat Zrot, Zstep;
+static GLfloat Step = 5.0;
+static GLfloat Scale = 1.0;
+static GLuint Object;
+
+
+
+
+static GLuint make_object( void )
+{
+   GLuint list;
+
+   list = glGenLists( 1 );
+
+   glNewList( list, GL_COMPILE );
+
+   glBegin( GL_LINE_LOOP );
+   glColor3f( 1.0, 1.0, 1.0 );
+   glVertex3f(  1.0,  0.5, -0.4 );
+   glColor3f( 1.0, 0.0, 0.0 );
+   glVertex3f(  1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 1.0, 0.0 );
+   glVertex3f( -1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 0.0, 1.0 );
+   glVertex3f( -1.0,  0.5, -0.4 );
+   glEnd();
+
+   glColor3f( 1.0, 1.0, 1.0 );
+
+   glBegin( GL_LINE_LOOP );
+   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+
+   glBegin( GL_LINES );
+   glVertex3f(  1.0,  0.5, -0.4 );   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, -0.4 );   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, -0.4 );   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, -0.4 );   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+
+
+   glEndList();
+
+   return list;
+}
+
+
+
+void reshape( int width, int height )
+{
+   glViewport(0, 0, (GLint)width, (GLint)height);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
+   glMatrixMode(GL_MODELVIEW);
+}
+
+
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+   case KEY_ESCAPE:
+       exit(0);
+   }
+   return GL_FALSE;
+}
+
+
+void draw( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT );
+
+   glPushMatrix();
+
+   glTranslatef( 0.0, 0.0, -10.0 );
+   glScalef( Scale, Scale, Scale );
+   if (Xstep) {
+      glRotatef( Xrot, 1.0, 0.0, 0.0 );
+   }
+   else if (Ystep) {
+      glRotatef( Yrot, 0.0, 1.0, 0.0 );
+   }
+   else {
+      glRotatef( Zrot, 0.0, 0.0, 1.0 );
+   }
+
+   glCallList( Object );
+
+   glPopMatrix();
+
+   glFlush();
+   tkSwapBuffers();
+}
+
+
+void idle( void )
+{
+   Xrot += Xstep;
+   Yrot += Ystep;
+   Zrot += Zstep;
+
+   if (Xrot>=360.0) {
+      Xrot = Xstep = 0.0;
+      Ystep = Step;
+   }
+   else if (Yrot>=360.0) {
+      Yrot = Ystep = 0.0;
+      Zstep = Step;
+   }
+   else if (Zrot>=360.0) {
+      Zrot = Zstep = 0.0;
+      Xstep = Step;
+   }
+   draw();
+}
+
+void init(void)
+{
+   Object = make_object();
+   glCullFace( GL_BACK );
+/*   glEnable( GL_CULL_FACE );*/
+   glDisable( GL_DITHER );
+   glShadeModel( GL_FLAT );
+/*   glEnable( GL_DEPTH_TEST ); */
+
+   Xrot = Yrot = Zrot = 0.0;
+   Xstep = Step;
+   Ystep = Zstep = 0.0;
+}
+
+
+int main( int argc, char *argv[] )
+{
+    return ui_loop(argc, argv, "spin");
+}

3rdparty/tinygl-0.4-ugfx/examples/texobj.c

@@ -0,0 +1,193 @@
+/*
+ * Example of using the 1.1 texture object functions.
+ * Also, this demo utilizes Mesa's fast texture map path.
+ *
+ * Brian Paul   June 1996
+ */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <GL/glx.h> 
+#include <GL/gl.h> 
+#include "ui.h"
+
+static GLuint TexObj[2];
+static GLfloat Angle = 0.0f;
+
+static int cnt=0,v=0;
+
+void 
+draw(void)
+{
+  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+  glColor3f(1.0, 1.0, 1.0);
+
+  /* draw first polygon */
+  glPushMatrix();
+  glTranslatef(-1.0, 0.0, 0.0);
+  glRotatef(Angle, 0.0, 0.0, 1.0);
+  glBindTexture(GL_TEXTURE_2D, TexObj[v]);
+
+  glEnable(GL_TEXTURE_2D);
+  glBegin(GL_QUADS);
+  glTexCoord2f(0.0, 0.0);
+  glVertex2f(-1.0, -1.0);
+  glTexCoord2f(1.0, 0.0);
+  glVertex2f(1.0, -1.0);
+  glTexCoord2f(1.0, 1.0);
+  glVertex2f(1.0, 1.0);
+  glTexCoord2f(0.0, 1.0);
+  glVertex2f(-1.0, 1.0);
+  glEnd();
+  glDisable(GL_TEXTURE_2D);
+  glPopMatrix();
+
+  /* draw second polygon */
+  glPushMatrix();
+  glTranslatef(1.0, 0.0, 0.0);
+  glRotatef(Angle - 90.0, 0.0, 1.0, 0.0);
+
+  glBindTexture(GL_TEXTURE_2D, TexObj[1-v]);
+
+  glEnable(GL_TEXTURE_2D);
+  glBegin(GL_QUADS);
+  glTexCoord2f(0.0, 0.0);
+  glVertex2f(-1.0, -1.0);
+  glTexCoord2f(1.0, 0.0);
+  glVertex2f(1.0, -1.0);
+  glTexCoord2f(1.0, 1.0);
+  glVertex2f(1.0, 1.0);
+  glTexCoord2f(0.0, 1.0);
+  glVertex2f(-1.0, 1.0);
+  glEnd();
+  glDisable(GL_TEXTURE_2D);
+
+  glPopMatrix();
+
+  tkSwapBuffers();
+}
+
+
+/* new window size or exposure */
+void 
+reshape(int width, int height)
+{
+  glViewport(0, 0, (GLint) width, (GLint) height);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  /* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 ); */
+  glFrustum(-2.0, 2.0, -2.0, 2.0, 6.0, 20.0);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glTranslatef(0.0, 0.0, -8.0);
+}
+
+
+void bind_texture(int texobj,int image)
+{
+  static int width = 8, height = 8;
+  static int color[2][3]={
+    {255,0,0},
+    {0,255,0},
+  };
+  GLubyte tex[64][3];
+  static GLubyte texchar[2][8*8] = {
+  {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 1, 1, 0, 0, 0,
+    0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 1, 1, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0},
+  {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 2, 2, 0, 0, 0,
+    0, 0, 2, 0, 0, 2, 0, 0,
+    0, 0, 0, 0, 0, 2, 0, 0,
+    0, 0, 0, 0, 2, 0, 0, 0,
+    0, 0, 0, 2, 0, 0, 0, 0,
+    0, 0, 2, 2, 2, 2, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0}};
+
+  int i,j;
+  
+  glBindTexture(GL_TEXTURE_2D, texobj);
+
+  /* red on white */
+  for (i = 0; i < height; i++) {
+    for (j = 0; j < width; j++) {
+      int p = i * width + j;
+      if (texchar[image][(height - i - 1) * width + j]) {
+        tex[p][0] = color[image][0];
+        tex[p][1] = color[image][1];
+        tex[p][2] = color[image][2];
+      } else {
+        tex[p][0] = 255;
+        tex[p][1] = 255;
+        tex[p][2] = 255;
+      }
+    }
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0,
+    GL_RGB, GL_UNSIGNED_BYTE, tex);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  /* end of texture object */
+}
+
+
+
+void 
+init(void)
+{
+  glEnable(GL_DEPTH_TEST);
+
+  /* Setup texturing */
+  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+
+  /* generate texture object IDs */
+  glGenTextures(2, TexObj);
+  bind_texture(TexObj[0],0);
+  bind_texture(TexObj[1],1);
+  
+}
+
+void 
+idle(void)
+{
+  
+  Angle += 2.0;
+
+  if (++cnt==5) {
+    cnt=0;
+    v=!v;
+  }
+  draw();
+}
+
+/* change view angle, exit upon ESC */
+GLenum key(int k, GLenum mask)
+{
+   switch (k) {
+      case 'q':
+      case KEY_ESCAPE:
+          exit(0);
+   }
+   return GL_FALSE;
+}
+
+int main(int argc, char **argv) 
+{
+    return ui_loop(argc, argv, "texobj");
+}
+
+

3rdparty/tinygl-0.4-ugfx/examples/ui.h

@@ -0,0 +1,17 @@
+/*
+ * tk like ui
+ */
+void draw( void );
+void idle( void );
+GLenum key(int k, GLenum mask);
+void reshape( int width, int height );
+void init( void );
+int ui_loop(int argc, char **argv, const char *name);
+void tkSwapBuffers(void);
+
+#define KEY_UP     0xe000
+#define KEY_DOWN   0xe001
+#define KEY_LEFT   0xe002
+#define KEY_RIGHT  0xe003
+#define KEY_ESCAPE 0xe004
+

3rdparty/tinygl-0.4-ugfx/examples/x11.c

@@ -0,0 +1,139 @@
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+
+#include <GL/glx.h> 
+#include <GL/gl.h> 
+#include "ui.h"
+
+
+#ifndef M_PI
+#  define M_PI 3.14159265
+#endif
+
+static int attributeList[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
+
+static Bool WaitForNotify(Display *d, XEvent *e, char *arg) 
+{
+  return (e->type == MapNotify) && (e->xmap.window == (Window)arg); 
+}
+
+Display *dpy;
+Window win;
+
+void tkSwapBuffers(void)
+{
+    glXSwapBuffers(dpy,win);
+}
+
+int ui_loop(int argc, char **argv, const char *name)
+{
+  XVisualInfo *vi;
+  Colormap cmap;
+  XSetWindowAttributes swa;
+  XSizeHints hint;
+  GLXContext cx;
+  XEvent event;
+  int k, width, height;
+  char buf[80];
+  XEvent xev;
+  KeySym keysym;
+  XComposeStatus status;
+  
+  /* get a connection */
+  dpy = XOpenDisplay(NULL);
+  if (dpy == NULL) {
+      fprintf(stderr,"Could not open X display\n");
+      exit(1);
+  }
+  
+  /* get an appropriate visual */
+  vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeList);
+  if (vi == NULL) {
+      fprintf(stderr, "No suitable visual for glx\n");
+      exit(1);
+  }
+      
+  /* create a GLX context */
+  cx = glXCreateContext(dpy, vi, 0, GL_TRUE);
+
+  /* create a color map */
+  cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
+			 vi->visual, AllocNone);
+
+  /* create a window */
+  width = 400;
+  height = 300;
+  hint.x = 0;
+  hint.y = 0;
+  hint.width = width;
+  hint.height = height;
+  hint.flags = PPosition | PSize;
+  swa.colormap = cmap;
+  swa.border_pixel = 0;
+  swa.event_mask = StructureNotifyMask;
+  win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, width, height,
+		      0, vi->depth, InputOutput, vi->visual,
+		      CWBorderPixel|CWColormap|CWEventMask, &swa);
+  XSetStandardProperties (dpy, win, name, name, None, NULL, 0, &hint);
+
+  XMapWindow(dpy, win);
+  XIfEvent(dpy, &event, WaitForNotify, (char*)win);
+  XSelectInput(dpy, win, KeyPressMask | StructureNotifyMask | ExposureMask);
+
+  /* connect the context to the window */
+  glXMakeCurrent(dpy, win, cx);
+
+  init();
+  reshape(width, height);
+
+  while (1) {
+    if (XPending(dpy) > 0) {
+      XNextEvent(dpy,&xev);
+      switch(xev.type) {
+      case KeyPress:
+	XLookupString((XKeyEvent *)&xev,buf,80,&keysym,&status);
+        switch(keysym) {
+        case XK_Up:
+            k = KEY_UP;
+            break;
+        case XK_Down:
+            k = KEY_DOWN;
+            break;
+        case XK_Left:
+            k = KEY_LEFT;
+            break;
+        case XK_Right:
+            k = KEY_RIGHT;
+            break;
+        case XK_Escape:
+            k = KEY_ESCAPE;
+            break;
+        default:
+            k = keysym;
+        }
+        key(k, 0);
+	break;
+      case ConfigureNotify:
+	{
+	  int width,height;
+	  width = xev.xconfigure.width;
+	  height = xev.xconfigure.height;
+	  glXWaitX();
+          reshape(width, height);
+	}
+	break;
+      }
+    } else {
+      idle();
+    }
+  }
+  return 0;
+}
+
+

3rdparty/tinygl-0.4-ugfx/include/GL/gl.h

@@ -0,0 +1,838 @@
+/*
+ * The following constants come from Mesa
+ */
+#ifndef GL_H
+#define GL_H
+
+#define GL_VERSION_1_1 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+	/* Boolean values */
+	GL_FALSE			= 0,
+	GL_TRUE				= 1,
+
+	/* Data types */
+	GL_BYTE				= 0x1400,
+	GL_UNSIGNED_BYTE		= 0x1401,
+	GL_SHORT			= 0x1402,
+	GL_UNSIGNED_SHORT		= 0x1403,
+	GL_INT				= 0x1404,
+	GL_UNSIGNED_INT			= 0x1405,
+	GL_FLOAT			= 0x1406,
+	GL_DOUBLE			= 0x140A,
+	GL_2_BYTES			= 0x1407,
+	GL_3_BYTES			= 0x1408,
+	GL_4_BYTES			= 0x1409,
+
+	/* Primitives */
+	GL_LINES			= 0x0001,
+	GL_POINTS			= 0x0000,
+	GL_LINE_STRIP			= 0x0003,
+	GL_LINE_LOOP			= 0x0002,
+	GL_TRIANGLES			= 0x0004,
+	GL_TRIANGLE_STRIP		= 0x0005,
+	GL_TRIANGLE_FAN			= 0x0006,
+	GL_QUADS			= 0x0007,
+	GL_QUAD_STRIP			= 0x0008,
+	GL_POLYGON			= 0x0009,
+	GL_EDGE_FLAG			= 0x0B43,
+
+	/* Vertex Arrays */
+	GL_VERTEX_ARRAY			= 0x8074,
+	GL_NORMAL_ARRAY			= 0x8075,
+	GL_COLOR_ARRAY			= 0x8076,
+	GL_INDEX_ARRAY			= 0x8077,
+	GL_TEXTURE_COORD_ARRAY		= 0x8078,
+	GL_EDGE_FLAG_ARRAY		= 0x8079,
+	GL_VERTEX_ARRAY_SIZE		= 0x807A,
+	GL_VERTEX_ARRAY_TYPE		= 0x807B,
+	GL_VERTEX_ARRAY_STRIDE		= 0x807C,
+	GL_VERTEX_ARRAY_COUNT		= 0x807D,
+	GL_NORMAL_ARRAY_TYPE		= 0x807E,
+	GL_NORMAL_ARRAY_STRIDE		= 0x807F,
+	GL_NORMAL_ARRAY_COUNT		= 0x8080,
+	GL_COLOR_ARRAY_SIZE		= 0x8081,
+	GL_COLOR_ARRAY_TYPE		= 0x8082,
+	GL_COLOR_ARRAY_STRIDE		= 0x8083,
+	GL_COLOR_ARRAY_COUNT		= 0x8084,
+	GL_INDEX_ARRAY_TYPE		= 0x8085,
+	GL_INDEX_ARRAY_STRIDE		= 0x8086,
+	GL_INDEX_ARRAY_COUNT		= 0x8087,
+	GL_TEXTURE_COORD_ARRAY_SIZE	= 0x8088,
+	GL_TEXTURE_COORD_ARRAY_TYPE	= 0x8089,
+	GL_TEXTURE_COORD_ARRAY_STRIDE	= 0x808A,
+	GL_TEXTURE_COORD_ARRAY_COUNT	= 0x808B,
+	GL_EDGE_FLAG_ARRAY_STRIDE	= 0x808C,
+	GL_EDGE_FLAG_ARRAY_COUNT	= 0x808D,
+	GL_VERTEX_ARRAY_POINTER		= 0x808E,
+	GL_NORMAL_ARRAY_POINTER		= 0x808F,
+	GL_COLOR_ARRAY_POINTER		= 0x8090,
+	GL_INDEX_ARRAY_POINTER		= 0x8091,
+	GL_TEXTURE_COORD_ARRAY_POINTER	= 0x8092,
+	GL_EDGE_FLAG_ARRAY_POINTER	= 0x8093,
+        GL_V2F				= 0x2A20,
+	GL_V3F				= 0x2A21,
+	GL_C4UB_V2F			= 0x2A22,
+	GL_C4UB_V3F			= 0x2A23,
+	GL_C3F_V3F			= 0x2A24,
+	GL_N3F_V3F			= 0x2A25,
+	GL_C4F_N3F_V3F			= 0x2A26,
+	GL_T2F_V3F			= 0x2A27,
+	GL_T4F_V4F			= 0x2A28,
+	GL_T2F_C4UB_V3F			= 0x2A29,
+	GL_T2F_C3F_V3F			= 0x2A2A,
+	GL_T2F_N3F_V3F			= 0x2A2B,
+	GL_T2F_C4F_N3F_V3F		= 0x2A2C,
+	GL_T4F_C4F_N3F_V4F		= 0x2A2D,
+
+	/* Matrix Mode */
+	GL_MATRIX_MODE			= 0x0BA0,
+	GL_MODELVIEW			= 0x1700,
+	GL_PROJECTION			= 0x1701,
+	GL_TEXTURE			= 0x1702,
+
+	/* Points */
+	GL_POINT_SMOOTH			= 0x0B10,
+	GL_POINT_SIZE			= 0x0B11,
+	GL_POINT_SIZE_GRANULARITY 	= 0x0B13,
+	GL_POINT_SIZE_RANGE		= 0x0B12,
+
+	/* Lines */
+	GL_LINE_SMOOTH			= 0x0B20,
+	GL_LINE_STIPPLE			= 0x0B24,
+	GL_LINE_STIPPLE_PATTERN		= 0x0B25,
+	GL_LINE_STIPPLE_REPEAT		= 0x0B26,
+	GL_LINE_WIDTH			= 0x0B21,
+	GL_LINE_WIDTH_GRANULARITY	= 0x0B23,
+	GL_LINE_WIDTH_RANGE		= 0x0B22,
+
+	/* Polygons */
+	GL_POINT			= 0x1B00,
+	GL_LINE				= 0x1B01,
+	GL_FILL				= 0x1B02,
+	GL_CCW				= 0x0901,
+	GL_CW				= 0x0900,
+	GL_FRONT			= 0x0404,
+	GL_BACK				= 0x0405,
+	GL_CULL_FACE			= 0x0B44,
+	GL_CULL_FACE_MODE		= 0x0B45,
+	GL_POLYGON_SMOOTH		= 0x0B41,
+	GL_POLYGON_STIPPLE		= 0x0B42,
+	GL_FRONT_FACE			= 0x0B46,
+	GL_POLYGON_MODE			= 0x0B40,
+	GL_POLYGON_OFFSET_FACTOR	= 0x3038,
+	GL_POLYGON_OFFSET_UNITS		= 0x2A00,
+	GL_POLYGON_OFFSET_POINT		= 0x2A01,
+	GL_POLYGON_OFFSET_LINE		= 0x2A02,
+	GL_POLYGON_OFFSET_FILL		= 0x8037,
+
+	/* Display Lists */
+	GL_COMPILE			= 0x1300,
+	GL_COMPILE_AND_EXECUTE		= 0x1301,
+	GL_LIST_BASE			= 0x0B32,
+	GL_LIST_INDEX			= 0x0B33,
+	GL_LIST_MODE			= 0x0B30,
+
+	/* Depth buffer */
+	GL_NEVER			= 0x0200,
+	GL_LESS				= 0x0201,
+	GL_GEQUAL			= 0x0206,
+	GL_LEQUAL			= 0x0203,
+	GL_GREATER			= 0x0204,
+	GL_NOTEQUAL			= 0x0205,
+	GL_EQUAL			= 0x0202,
+	GL_ALWAYS			= 0x0207,
+	GL_DEPTH_TEST			= 0x0B71,
+	GL_DEPTH_BITS			= 0x0D56,
+	GL_DEPTH_CLEAR_VALUE		= 0x0B73,
+	GL_DEPTH_FUNC			= 0x0B74,
+	GL_DEPTH_RANGE			= 0x0B70,
+	GL_DEPTH_WRITEMASK		= 0x0B72,
+	GL_DEPTH_COMPONENT		= 0x1902,
+
+	/* Lighting */
+	GL_LIGHTING			= 0x0B50,
+	GL_LIGHT0			= 0x4000,
+	GL_LIGHT1			= 0x4001,
+	GL_LIGHT2			= 0x4002,
+	GL_LIGHT3			= 0x4003,
+	GL_LIGHT4			= 0x4004,
+	GL_LIGHT5			= 0x4005,
+	GL_LIGHT6			= 0x4006,
+	GL_LIGHT7			= 0x4007,
+	GL_SPOT_EXPONENT		= 0x1205,
+	GL_SPOT_CUTOFF			= 0x1206,
+	GL_CONSTANT_ATTENUATION		= 0x1207,
+	GL_LINEAR_ATTENUATION		= 0x1208,
+	GL_QUADRATIC_ATTENUATION	= 0x1209,
+	GL_AMBIENT			= 0x1200,
+	GL_DIFFUSE			= 0x1201,
+	GL_SPECULAR			= 0x1202,
+	GL_SHININESS			= 0x1601,
+	GL_EMISSION			= 0x1600,
+	GL_POSITION			= 0x1203,
+	GL_SPOT_DIRECTION		= 0x1204,
+	GL_AMBIENT_AND_DIFFUSE		= 0x1602,
+	GL_COLOR_INDEXES		= 0x1603,
+	GL_LIGHT_MODEL_TWO_SIDE		= 0x0B52,
+	GL_LIGHT_MODEL_LOCAL_VIEWER	= 0x0B51,
+	GL_LIGHT_MODEL_AMBIENT		= 0x0B53,
+	GL_FRONT_AND_BACK		= 0x0408,
+	GL_SHADE_MODEL			= 0x0B54,
+	GL_FLAT				= 0x1D00,
+	GL_SMOOTH			= 0x1D01,
+	GL_COLOR_MATERIAL		= 0x0B57,
+	GL_COLOR_MATERIAL_FACE		= 0x0B55,
+	GL_COLOR_MATERIAL_PARAMETER	= 0x0B56,
+	GL_NORMALIZE			= 0x0BA1,
+
+	/* User clipping planes */
+	GL_CLIP_PLANE0			= 0x3000,
+	GL_CLIP_PLANE1			= 0x3001,
+	GL_CLIP_PLANE2			= 0x3002,
+	GL_CLIP_PLANE3			= 0x3003,
+	GL_CLIP_PLANE4			= 0x3004,
+	GL_CLIP_PLANE5			= 0x3005,
+
+	/* Accumulation buffer */
+	GL_ACCUM_RED_BITS		= 0x0D58,
+	GL_ACCUM_GREEN_BITS		= 0x0D59,
+	GL_ACCUM_BLUE_BITS		= 0x0D5A,
+	GL_ACCUM_ALPHA_BITS		= 0x0D5B,
+	GL_ACCUM_CLEAR_VALUE		= 0x0B80,
+	GL_ACCUM			= 0x0100,
+	GL_ADD				= 0x0104,
+	GL_LOAD				= 0x0101,
+	GL_MULT				= 0x0103,
+	GL_RETURN			= 0x0102,
+
+	/* Alpha testing */
+	GL_ALPHA_TEST			= 0x0BC0,
+	GL_ALPHA_TEST_REF		= 0x0BC2,
+	GL_ALPHA_TEST_FUNC		= 0x0BC1,
+
+	/* Blending */
+	GL_BLEND			= 0x0BE2,
+	GL_BLEND_SRC			= 0x0BE1,
+	GL_BLEND_DST			= 0x0BE0,
+	GL_ZERO				= 0,
+	GL_ONE				= 1,
+	GL_SRC_COLOR			= 0x0300,
+	GL_ONE_MINUS_SRC_COLOR		= 0x0301,
+	GL_DST_COLOR			= 0x0306,
+	GL_ONE_MINUS_DST_COLOR		= 0x0307,
+	GL_SRC_ALPHA			= 0x0302,
+	GL_ONE_MINUS_SRC_ALPHA		= 0x0303,
+	GL_DST_ALPHA			= 0x0304,
+	GL_ONE_MINUS_DST_ALPHA		= 0x0305,
+	GL_SRC_ALPHA_SATURATE		= 0x0308,
+	GL_CONSTANT_COLOR		= 0x8001,
+	GL_ONE_MINUS_CONSTANT_COLOR	= 0x8002,
+	GL_CONSTANT_ALPHA		= 0x8003,
+	GL_ONE_MINUS_CONSTANT_ALPHA	= 0x8004,
+
+	/* Render Mode */
+	GL_FEEDBACK			= 0x1C01,
+	GL_RENDER			= 0x1C00,
+	GL_SELECT			= 0x1C02,
+
+	/* Feedback */
+	GL_2D				= 0x0600,
+	GL_3D				= 0x0601,
+	GL_3D_COLOR			= 0x0602,
+	GL_3D_COLOR_TEXTURE		= 0x0603,
+	GL_4D_COLOR_TEXTURE		= 0x0604,
+	GL_POINT_TOKEN			= 0x0701,
+	GL_LINE_TOKEN			= 0x0702,
+	GL_LINE_RESET_TOKEN		= 0x0707,
+	GL_POLYGON_TOKEN		= 0x0703,
+	GL_BITMAP_TOKEN			= 0x0704,
+	GL_DRAW_PIXEL_TOKEN		= 0x0705,
+	GL_COPY_PIXEL_TOKEN		= 0x0706,
+	GL_PASS_THROUGH_TOKEN		= 0x0700,
+
+	/* Fog */
+	GL_FOG				= 0x0B60,
+	GL_FOG_MODE			= 0x0B65,
+	GL_FOG_DENSITY			= 0x0B62,
+	GL_FOG_COLOR			= 0x0B66,
+	GL_FOG_INDEX			= 0x0B61,
+	GL_FOG_START			= 0x0B63,
+	GL_FOG_END			= 0x0B64,
+	GL_LINEAR			= 0x2601,
+	GL_EXP				= 0x0800,
+	GL_EXP2				= 0x0801,
+
+	/* Logic Ops */
+	GL_LOGIC_OP			= 0x0BF1,
+	GL_LOGIC_OP_MODE		= 0x0BF0,
+	GL_CLEAR			= 0x1500,
+	GL_SET				= 0x150F,
+	GL_COPY				= 0x1503,
+	GL_COPY_INVERTED		= 0x150C,
+	GL_NOOP				= 0x1505,
+	GL_INVERT			= 0x150A,
+	GL_AND				= 0x1501,
+	GL_NAND				= 0x150E,
+	GL_OR				= 0x1507,
+	GL_NOR				= 0x1508,
+	GL_XOR				= 0x1506,
+	GL_EQUIV			= 0x1509,
+	GL_AND_REVERSE			= 0x1502,
+	GL_AND_INVERTED			= 0x1504,
+	GL_OR_REVERSE			= 0x150B,
+	GL_OR_INVERTED			= 0x150D,
+
+	/* Stencil */
+	GL_STENCIL_TEST			= 0x0B90,
+	GL_STENCIL_WRITEMASK		= 0x0B98,
+	GL_STENCIL_BITS			= 0x0D57,
+	GL_STENCIL_FUNC			= 0x0B92,
+	GL_STENCIL_VALUE_MASK		= 0x0B93,
+	GL_STENCIL_REF			= 0x0B97,
+	GL_STENCIL_FAIL			= 0x0B94,
+	GL_STENCIL_PASS_DEPTH_PASS	= 0x0B96,
+	GL_STENCIL_PASS_DEPTH_FAIL	= 0x0B95,
+	GL_STENCIL_CLEAR_VALUE		= 0x0B91,
+	GL_STENCIL_INDEX		= 0x1901,
+	GL_KEEP				= 0x1E00,
+	GL_REPLACE			= 0x1E01,
+	GL_INCR				= 0x1E02,
+	GL_DECR				= 0x1E03,
+
+	/* Buffers, Pixel Drawing/Reading */
+	GL_NONE				= 0,
+	GL_LEFT				= 0x0406,
+	GL_RIGHT			= 0x0407,
+	/*GL_FRONT			= 0x0404, */
+	/*GL_BACK			= 0x0405, */
+	/*GL_FRONT_AND_BACK		= 0x0408, */
+	GL_FRONT_LEFT			= 0x0400,
+	GL_FRONT_RIGHT			= 0x0401,
+	GL_BACK_LEFT			= 0x0402,
+	GL_BACK_RIGHT			= 0x0403,
+	GL_AUX0				= 0x0409,
+	GL_AUX1				= 0x040A,
+	GL_AUX2				= 0x040B,
+	GL_AUX3				= 0x040C,
+	GL_COLOR_INDEX			= 0x1900,
+	GL_RED				= 0x1903,
+	GL_GREEN			= 0x1904,
+	GL_BLUE				= 0x1905,
+	GL_ALPHA			= 0x1906,
+	GL_LUMINANCE			= 0x1909,
+	GL_LUMINANCE_ALPHA		= 0x190A,
+	GL_ALPHA_BITS			= 0x0D55,
+	GL_RED_BITS			= 0x0D52,
+	GL_GREEN_BITS			= 0x0D53,
+	GL_BLUE_BITS			= 0x0D54,
+	GL_INDEX_BITS			= 0x0D51,
+	GL_SUBPIXEL_BITS		= 0x0D50,
+	GL_AUX_BUFFERS			= 0x0C00,
+	GL_READ_BUFFER			= 0x0C02,
+	GL_DRAW_BUFFER			= 0x0C01,
+	GL_DOUBLEBUFFER			= 0x0C32,
+	GL_STEREO			= 0x0C33,
+	GL_BITMAP			= 0x1A00,
+	GL_COLOR			= 0x1800,
+	GL_DEPTH			= 0x1801,
+	GL_STENCIL			= 0x1802,
+	GL_DITHER			= 0x0BD0,
+	GL_RGB				= 0x1907,
+	GL_RGBA				= 0x1908,
+
+	/* Implementation limits */
+	GL_MAX_LIST_NESTING		= 0x0B31,
+	GL_MAX_ATTRIB_STACK_DEPTH	= 0x0D35,
+	GL_MAX_MODELVIEW_STACK_DEPTH	= 0x0D36,
+	GL_MAX_NAME_STACK_DEPTH		= 0x0D37,
+	GL_MAX_PROJECTION_STACK_DEPTH	= 0x0D38,
+	GL_MAX_TEXTURE_STACK_DEPTH	= 0x0D39,
+	GL_MAX_EVAL_ORDER		= 0x0D30,
+	GL_MAX_LIGHTS			= 0x0D31,
+	GL_MAX_CLIP_PLANES		= 0x0D32,
+	GL_MAX_TEXTURE_SIZE		= 0x0D33,
+	GL_MAX_PIXEL_MAP_TABLE		= 0x0D34,
+	GL_MAX_VIEWPORT_DIMS		= 0x0D3A,
+	GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,
+
+	/* Gets */
+	GL_ATTRIB_STACK_DEPTH		= 0x0BB0,
+	GL_COLOR_CLEAR_VALUE		= 0x0C22,
+	GL_COLOR_WRITEMASK		= 0x0C23,
+	GL_CURRENT_INDEX		= 0x0B01,
+	GL_CURRENT_COLOR		= 0x0B00,
+	GL_CURRENT_NORMAL		= 0x0B02,
+	GL_CURRENT_RASTER_COLOR		= 0x0B04,
+	GL_CURRENT_RASTER_DISTANCE	= 0x0B09,
+	GL_CURRENT_RASTER_INDEX		= 0x0B05,
+	GL_CURRENT_RASTER_POSITION	= 0x0B07,
+	GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
+	GL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
+	GL_CURRENT_TEXTURE_COORDS	= 0x0B03,
+	GL_INDEX_CLEAR_VALUE		= 0x0C20,
+	GL_INDEX_MODE			= 0x0C30,
+	GL_INDEX_WRITEMASK		= 0x0C21,
+	GL_MODELVIEW_MATRIX		= 0x0BA6,
+	GL_MODELVIEW_STACK_DEPTH	= 0x0BA3,
+	GL_NAME_STACK_DEPTH		= 0x0D70,
+	GL_PROJECTION_MATRIX		= 0x0BA7,
+	GL_PROJECTION_STACK_DEPTH	= 0x0BA4,
+	GL_RENDER_MODE			= 0x0C40,
+	GL_RGBA_MODE			= 0x0C31,
+	GL_TEXTURE_MATRIX		= 0x0BA8,
+	GL_TEXTURE_STACK_DEPTH		= 0x0BA5,
+	GL_VIEWPORT			= 0x0BA2,
+
+
+	/* Evaluators */
+	GL_AUTO_NORMAL			= 0x0D80,
+	GL_MAP1_COLOR_4			= 0x0D90,
+	GL_MAP1_GRID_DOMAIN		= 0x0DD0,
+	GL_MAP1_GRID_SEGMENTS		= 0x0DD1,
+	GL_MAP1_INDEX			= 0x0D91,
+	GL_MAP1_NORMAL			= 0x0D92,
+	GL_MAP1_TEXTURE_COORD_1		= 0x0D93,
+	GL_MAP1_TEXTURE_COORD_2		= 0x0D94,
+	GL_MAP1_TEXTURE_COORD_3		= 0x0D95,
+	GL_MAP1_TEXTURE_COORD_4		= 0x0D96,
+	GL_MAP1_VERTEX_3		= 0x0D97,
+	GL_MAP1_VERTEX_4		= 0x0D98,
+	GL_MAP2_COLOR_4			= 0x0DB0,
+	GL_MAP2_GRID_DOMAIN		= 0x0DD2,
+	GL_MAP2_GRID_SEGMENTS		= 0x0DD3,
+	GL_MAP2_INDEX			= 0x0DB1,
+	GL_MAP2_NORMAL			= 0x0DB2,
+	GL_MAP2_TEXTURE_COORD_1		= 0x0DB3,
+	GL_MAP2_TEXTURE_COORD_2		= 0x0DB4,
+	GL_MAP2_TEXTURE_COORD_3		= 0x0DB5,
+	GL_MAP2_TEXTURE_COORD_4		= 0x0DB6,
+	GL_MAP2_VERTEX_3		= 0x0DB7,
+	GL_MAP2_VERTEX_4		= 0x0DB8,
+	GL_COEFF			= 0x0A00,
+	GL_DOMAIN			= 0x0A02,
+	GL_ORDER			= 0x0A01,
+
+	/* Hints */
+	GL_FOG_HINT			= 0x0C54,
+	GL_LINE_SMOOTH_HINT		= 0x0C52,
+	GL_PERSPECTIVE_CORRECTION_HINT	= 0x0C50,
+	GL_POINT_SMOOTH_HINT		= 0x0C51,
+	GL_POLYGON_SMOOTH_HINT		= 0x0C53,
+	GL_DONT_CARE			= 0x1100,
+	GL_FASTEST			= 0x1101,
+	GL_NICEST			= 0x1102,
+
+	/* Scissor box */
+	GL_SCISSOR_TEST			= 0x0C11,
+	GL_SCISSOR_BOX			= 0x0C10,
+
+	/* Pixel Mode / Transfer */
+	GL_MAP_COLOR			= 0x0D10,
+	GL_MAP_STENCIL			= 0x0D11,
+	GL_INDEX_SHIFT			= 0x0D12,
+	GL_INDEX_OFFSET			= 0x0D13,
+	GL_RED_SCALE			= 0x0D14,
+	GL_RED_BIAS			= 0x0D15,
+	GL_GREEN_SCALE			= 0x0D18,
+	GL_GREEN_BIAS			= 0x0D19,
+	GL_BLUE_SCALE			= 0x0D1A,
+	GL_BLUE_BIAS			= 0x0D1B,
+	GL_ALPHA_SCALE			= 0x0D1C,
+	GL_ALPHA_BIAS			= 0x0D1D,
+	GL_DEPTH_SCALE			= 0x0D1E,
+	GL_DEPTH_BIAS			= 0x0D1F,
+	GL_PIXEL_MAP_S_TO_S_SIZE	= 0x0CB1,
+	GL_PIXEL_MAP_I_TO_I_SIZE	= 0x0CB0,
+	GL_PIXEL_MAP_I_TO_R_SIZE	= 0x0CB2,
+	GL_PIXEL_MAP_I_TO_G_SIZE	= 0x0CB3,
+	GL_PIXEL_MAP_I_TO_B_SIZE	= 0x0CB4,
+	GL_PIXEL_MAP_I_TO_A_SIZE	= 0x0CB5,
+	GL_PIXEL_MAP_R_TO_R_SIZE	= 0x0CB6,
+	GL_PIXEL_MAP_G_TO_G_SIZE	= 0x0CB7,
+	GL_PIXEL_MAP_B_TO_B_SIZE	= 0x0CB8,
+	GL_PIXEL_MAP_A_TO_A_SIZE	= 0x0CB9,
+	GL_PIXEL_MAP_S_TO_S		= 0x0C71,
+	GL_PIXEL_MAP_I_TO_I		= 0x0C70,
+	GL_PIXEL_MAP_I_TO_R		= 0x0C72,
+	GL_PIXEL_MAP_I_TO_G		= 0x0C73,
+	GL_PIXEL_MAP_I_TO_B		= 0x0C74,
+	GL_PIXEL_MAP_I_TO_A		= 0x0C75,
+	GL_PIXEL_MAP_R_TO_R		= 0x0C76,
+	GL_PIXEL_MAP_G_TO_G		= 0x0C77,
+	GL_PIXEL_MAP_B_TO_B		= 0x0C78,
+	GL_PIXEL_MAP_A_TO_A		= 0x0C79,
+	GL_PACK_ALIGNMENT		= 0x0D05,
+	GL_PACK_LSB_FIRST		= 0x0D01,
+	GL_PACK_ROW_LENGTH		= 0x0D02,
+	GL_PACK_SKIP_PIXELS		= 0x0D04,
+	GL_PACK_SKIP_ROWS		= 0x0D03,
+	GL_PACK_SWAP_BYTES		= 0x0D00,
+	GL_UNPACK_ALIGNMENT		= 0x0CF5,
+	GL_UNPACK_LSB_FIRST		= 0x0CF1,
+	GL_UNPACK_ROW_LENGTH		= 0x0CF2,
+	GL_UNPACK_SKIP_PIXELS		= 0x0CF4,
+	GL_UNPACK_SKIP_ROWS		= 0x0CF3,
+	GL_UNPACK_SWAP_BYTES		= 0x0CF0,
+	GL_ZOOM_X			= 0x0D16,
+	GL_ZOOM_Y			= 0x0D17,
+
+	/* Texture mapping */
+	GL_TEXTURE_ENV			= 0x2300,
+	GL_TEXTURE_ENV_MODE		= 0x2200,
+	GL_TEXTURE_1D			= 0x0DE0,
+	GL_TEXTURE_2D			= 0x0DE1,
+	GL_TEXTURE_WRAP_S		= 0x2802,
+	GL_TEXTURE_WRAP_T		= 0x2803,
+	GL_TEXTURE_MAG_FILTER		= 0x2800,
+	GL_TEXTURE_MIN_FILTER		= 0x2801,
+	GL_TEXTURE_ENV_COLOR		= 0x2201,
+	GL_TEXTURE_GEN_S		= 0x0C60,
+	GL_TEXTURE_GEN_T		= 0x0C61,
+	GL_TEXTURE_GEN_MODE		= 0x2500,
+	GL_TEXTURE_BORDER_COLOR		= 0x1004,
+	GL_TEXTURE_WIDTH		= 0x1000,
+	GL_TEXTURE_HEIGHT		= 0x1001,
+	GL_TEXTURE_BORDER		= 0x1005,
+	GL_TEXTURE_COMPONENTS		= 0x1003,
+	GL_NEAREST_MIPMAP_NEAREST	= 0x2700,
+	GL_NEAREST_MIPMAP_LINEAR	= 0x2702,
+	GL_LINEAR_MIPMAP_NEAREST	= 0x2701,
+	GL_LINEAR_MIPMAP_LINEAR		= 0x2703,
+	GL_OBJECT_LINEAR		= 0x2401,
+	GL_OBJECT_PLANE			= 0x2501,
+	GL_EYE_LINEAR			= 0x2400,
+	GL_EYE_PLANE			= 0x2502,
+	GL_SPHERE_MAP			= 0x2402,
+	GL_DECAL			= 0x2101,
+	GL_MODULATE			= 0x2100,
+	GL_NEAREST			= 0x2600,
+	GL_REPEAT			= 0x2901,
+	GL_CLAMP			= 0x2900,
+	GL_S				= 0x2000,
+	GL_T				= 0x2001,
+	GL_R				= 0x2002,
+	GL_Q				= 0x2003,
+	GL_TEXTURE_GEN_R		= 0x0C62,
+	GL_TEXTURE_GEN_Q		= 0x0C63,
+
+	GL_PROXY_TEXTURE_1D		= 0x8063,
+	GL_PROXY_TEXTURE_2D		= 0x8064,
+	GL_TEXTURE_PRIORITY		= 0x8066,
+	GL_TEXTURE_RESIDENT		= 0x8067,
+	GL_TEXTURE_1D_BINDING		= 0x8068,
+	GL_TEXTURE_2D_BINDING		= 0x8069,
+
+	/* Internal texture formats */
+	GL_ALPHA4			= 0x803B,
+	GL_ALPHA8			= 0x803C,
+	GL_ALPHA12			= 0x803D,
+	GL_ALPHA16			= 0x803E,
+	GL_LUMINANCE4			= 0x803F,
+	GL_LUMINANCE8			= 0x8040,
+	GL_LUMINANCE12			= 0x8041,
+	GL_LUMINANCE16			= 0x8042,
+	GL_LUMINANCE4_ALPHA4		= 0x8043,
+	GL_LUMINANCE6_ALPHA2		= 0x8044,
+	GL_LUMINANCE8_ALPHA8		= 0x8045,
+	GL_LUMINANCE12_ALPHA4		= 0x8046,
+	GL_LUMINANCE12_ALPHA12		= 0x8047,
+	GL_LUMINANCE16_ALPHA16		= 0x8048,
+	GL_INTENSITY			= 0x8049,
+	GL_INTENSITY4			= 0x804A,
+	GL_INTENSITY8			= 0x804B,
+	GL_INTENSITY12			= 0x804C,
+	GL_INTENSITY16			= 0x804D,
+	GL_R3_G3_B2			= 0x2A10,
+	GL_RGB4				= 0x804F,
+	GL_RGB5				= 0x8050,
+	GL_RGB8				= 0x8051,
+	GL_RGB10			= 0x8052,
+	GL_RGB12			= 0x8053,
+	GL_RGB16			= 0x8054,
+	GL_RGBA2			= 0x8055,
+	GL_RGBA4			= 0x8056,
+	GL_RGB5_A1			= 0x8057,
+	GL_RGBA8			= 0x8058,
+	GL_RGB10_A2			= 0x8059,
+	GL_RGBA12			= 0x805A,
+	GL_RGBA16			= 0x805B,
+
+	/* Utility */
+	GL_VENDOR			= 0x1F00,
+	GL_RENDERER			= 0x1F01,
+	GL_VERSION			= 0x1F02,
+	GL_EXTENSIONS			= 0x1F03,
+
+	/* Errors */
+	GL_INVALID_VALUE		= 0x0501,
+	GL_INVALID_ENUM			= 0x0500,
+	GL_INVALID_OPERATION		= 0x0502,
+	GL_STACK_OVERFLOW		= 0x0503,
+	GL_STACK_UNDERFLOW		= 0x0504,
+	GL_OUT_OF_MEMORY		= 0x0505,
+
+	/*
+	 * 1.0 Extensions
+	 */
+        /* GL_EXT_blend_minmax and GL_EXT_blend_color */
+	GL_CONSTANT_COLOR_EXT		= 0x8001,
+	GL_ONE_MINUS_CONSTANT_COLOR_EXT	= 0x8002,
+	GL_CONSTANT_ALPHA_EXT		= 0x8003,
+	GL_ONE_MINUS_CONSTANT_ALPHA_EXT	= 0x8004,
+	GL_BLEND_EQUATION_EXT		= 0x8009,
+	GL_MIN_EXT			= 0x8007,
+	GL_MAX_EXT			= 0x8008,
+	GL_FUNC_ADD_EXT			= 0x8006,
+	GL_FUNC_SUBTRACT_EXT		= 0x800A,
+	GL_FUNC_REVERSE_SUBTRACT_EXT	= 0x800B,
+	GL_BLEND_COLOR_EXT		= 0x8005,
+
+	/* GL_EXT_polygon_offset */
+        GL_POLYGON_OFFSET_EXT           = 0x8037,
+        GL_POLYGON_OFFSET_FACTOR_EXT    = 0x8038,
+        GL_POLYGON_OFFSET_BIAS_EXT      = 0x8039,
+
+	/* GL_EXT_vertex_array */
+	GL_VERTEX_ARRAY_EXT		= 0x8074,
+	GL_NORMAL_ARRAY_EXT		= 0x8075,
+	GL_COLOR_ARRAY_EXT		= 0x8076,
+	GL_INDEX_ARRAY_EXT		= 0x8077,
+	GL_TEXTURE_COORD_ARRAY_EXT	= 0x8078,
+	GL_EDGE_FLAG_ARRAY_EXT		= 0x8079,
+	GL_VERTEX_ARRAY_SIZE_EXT	= 0x807A,
+	GL_VERTEX_ARRAY_TYPE_EXT	= 0x807B,
+	GL_VERTEX_ARRAY_STRIDE_EXT	= 0x807C,
+	GL_VERTEX_ARRAY_COUNT_EXT	= 0x807D,
+	GL_NORMAL_ARRAY_TYPE_EXT	= 0x807E,
+	GL_NORMAL_ARRAY_STRIDE_EXT	= 0x807F,
+	GL_NORMAL_ARRAY_COUNT_EXT	= 0x8080,
+	GL_COLOR_ARRAY_SIZE_EXT		= 0x8081,
+	GL_COLOR_ARRAY_TYPE_EXT		= 0x8082,
+	GL_COLOR_ARRAY_STRIDE_EXT	= 0x8083,
+	GL_COLOR_ARRAY_COUNT_EXT	= 0x8084,
+	GL_INDEX_ARRAY_TYPE_EXT		= 0x8085,
+	GL_INDEX_ARRAY_STRIDE_EXT	= 0x8086,
+	GL_INDEX_ARRAY_COUNT_EXT	= 0x8087,
+	GL_TEXTURE_COORD_ARRAY_SIZE_EXT	= 0x8088,
+	GL_TEXTURE_COORD_ARRAY_TYPE_EXT	= 0x8089,
+	GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A,
+	GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B,
+	GL_EDGE_FLAG_ARRAY_STRIDE_EXT	= 0x808C,
+	GL_EDGE_FLAG_ARRAY_COUNT_EXT	= 0x808D,
+	GL_VERTEX_ARRAY_POINTER_EXT	= 0x808E,
+	GL_NORMAL_ARRAY_POINTER_EXT	= 0x808F,
+	GL_COLOR_ARRAY_POINTER_EXT	= 0x8090,
+	GL_INDEX_ARRAY_POINTER_EXT	= 0x8091,
+	GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092,
+	GL_EDGE_FLAG_ARRAY_POINTER_EXT	= 0x8093
+
+};
+
+enum {
+	GL_CURRENT_BIT		= 0x00000001,
+	GL_POINT_BIT		= 0x00000002,
+	GL_LINE_BIT		= 0x00000004,
+	GL_POLYGON_BIT		= 0x00000008,
+	GL_POLYGON_STIPPLE_BIT	= 0x00000010,
+	GL_PIXEL_MODE_BIT	= 0x00000020,
+	GL_LIGHTING_BIT		= 0x00000040,
+	GL_FOG_BIT		= 0x00000080,
+	GL_DEPTH_BUFFER_BIT	= 0x00000100,
+	GL_ACCUM_BUFFER_BIT	= 0x00000200,
+	GL_STENCIL_BUFFER_BIT	= 0x00000400,
+	GL_VIEWPORT_BIT		= 0x00000800,
+	GL_TRANSFORM_BIT	= 0x00001000,
+	GL_ENABLE_BIT		= 0x00002000,
+	GL_COLOR_BUFFER_BIT	= 0x00004000,
+	GL_HINT_BIT		= 0x00008000,
+	GL_EVAL_BIT		= 0x00010000,
+	GL_LIST_BIT		= 0x00020000,
+	GL_TEXTURE_BIT		= 0x00040000,
+	GL_SCISSOR_BIT		= 0x00080000,
+	GL_ALL_ATTRIB_BITS	= 0x000fffff
+};
+
+/* some types */
+
+typedef int		GLenum;
+typedef void		GLvoid;
+typedef unsigned char	GLboolean;
+typedef signed char	GLbyte;		/* 1-byte signed */
+typedef short		GLshort;	/* 2-byte signed */
+typedef int		GLint;		/* 4-byte signed */
+typedef unsigned char	GLubyte;	/* 1-byte unsigned */
+typedef unsigned short	GLushort;	/* 2-byte unsigned */
+typedef unsigned int	GLuint;		/* 4-byte unsigned */
+typedef float		GLfloat;	/* single precision float */
+typedef double		GLdouble;	/* double precision float */
+typedef int GLsizei;
+
+/* functions */
+
+void glEnable(int code);
+void glDisable(int code);
+
+void glShadeModel(int mode);
+void glCullFace(int mode);
+void glPolygonMode(int face,int mode);
+
+void glBegin(int type);
+void glEnd(void);
+
+#define PROTO_GL1(name)				\
+void gl ## name ## 1f(float);	\
+void gl ## name ## 1d(double);	\
+void gl ## name ## 1fv(float *);		\
+void gl ## name ## 1dv(double *);
+
+#define PROTO_GL2(name)				\
+void gl ## name ## 2f(float ,float);	\
+void gl ## name ## 2d(double ,double);	\
+void gl ## name ## 2fv(float *);		\
+void gl ## name ## 2dv(double *);
+
+#define PROTO_GL3(name)				\
+void gl ## name ## 3f(float ,float ,float);	\
+void gl ## name ## 3d(double ,double ,double);	\
+void gl ## name ## 3fv(float *);		\
+void gl ## name ## 3dv(double *);
+
+#define PROTO_GL4(name)				\
+void gl ## name ## 4f(float ,float ,float, float );	\
+void gl ## name ## 4d(double ,double ,double, double );	\
+void gl ## name ## 4fv(float *);		\
+void gl ## name ## 4dv(double *);
+
+PROTO_GL2(Vertex)
+PROTO_GL3(Vertex)
+PROTO_GL4(Vertex)
+
+PROTO_GL3(Color)
+PROTO_GL4(Color)
+
+PROTO_GL3(Normal)
+
+PROTO_GL1(TexCoord)
+PROTO_GL2(TexCoord)
+PROTO_GL3(TexCoord)
+PROTO_GL4(TexCoord)
+
+void glEdgeFlag(int flag);
+
+/* matrix */
+void glMatrixMode(int mode);
+void glLoadMatrixf(const float *m);
+void glLoadIdentity(void);
+void glMultMatrixf(const float *m);
+void glPushMatrix(void);
+void glPopMatrix(void);
+void glRotatef(float angle,float x,float y,float z);
+void glTranslatef(float x,float y,float z);
+void glScalef(float x,float y,float z);
+
+void glViewport(int x,int y,int width,int height);
+void glFrustum(double left,double right,double bottom,double top,
+               double near,double far);
+
+/* lists */
+unsigned int glGenLists(int range);
+int glIsList(unsigned int list);
+void glNewList(unsigned int list,int mode);
+void glEndList(void);
+void glCallList(unsigned int list);
+
+/* clear */
+void glClear(int mask);
+void glClearColor(float r,float g,float b,float a);
+void glClearDepth(double depth);
+
+/* selection */
+int glRenderMode(int mode);
+void glSelectBuffer(int size,unsigned int *buf);
+
+void glInitNames(void);
+void glPushName(unsigned int name);
+void glPopName(void);
+void glLoadName(unsigned int name);
+
+/* textures */
+void glGenTextures(int n, unsigned int *textures);
+void glDeleteTextures(int n, const unsigned int *textures);
+void glBindTexture(int target,int texture);
+void glTexImage2D( int target, int level, int components,
+		    int width, int height, int border,
+                    int format, int type, void *pixels);
+void glTexEnvi(int target,int pname,int param);
+void glTexParameteri(int target,int pname,int param);
+void glPixelStorei(int pname,int param);
+
+/* lighting */
+
+void glMaterialfv(int mode,int type,float *v);
+void glMaterialf(int mode,int type,float v);
+void glColorMaterial(int mode,int type);
+
+void glLightfv(int light,int type,float *v);
+void glLightf(int light,int type,float v);
+void glLightModeli(int pname,int param);
+void glLightModelfv(int pname,float *param);
+
+/* misc */
+
+void glFlush(void);
+void glHint(int target,int mode);
+void glGetIntegerv(int pname,int *params);
+void glGetFloatv(int pname, float *v);
+void glFrontFace(int mode);
+
+/* opengl 1.2 arrays */
+void glEnableClientState(GLenum array);
+void glDisableClientState(GLenum array);
+void glArrayElement(GLint i);
+void glVertexPointer(GLint size, GLenum type, GLsizei stride, 
+                     const GLvoid *pointer);
+void glColorPointer(GLint size, GLenum type, GLsizei stride, 
+                     const GLvoid *pointer);
+void glNormalPointer(GLenum type, GLsizei stride, 
+                      const GLvoid *pointer);
+void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, 
+                       const GLvoid *pointer);
+
+/* opengl 1.2 polygon offset */
+void glPolygonOffset(GLfloat factor, GLfloat units);
+
+/* not implemented, just added to compile  */
+  /*
+inline void glPointSize(float) {}
+inline void glLineWidth(float) {}
+inline void glDeleteLists(int, int) {}
+inline void glDepthFunc(int) {}
+inline void glBlendFunc(int, int) {}
+inline void glTexEnvf(int, int, int) {}
+inline void glOrtho(float,float,float,float,float,float){}
+inline void glVertex2i(int,int) {}
+inline void glDepthMask(int) {}
+inline void glFogi(int, int) {}
+inline void glFogfv(int, const float*) {}
+inline void glFogf(int, float) {}
+inline void glRasterPos2f(float, float) {}
+inline void glPolygonStipple(void*) {}
+inline void glTexParameterf(int, int, int) {};
+  */
+/* non compatible functions */
+
+void glDebug(int mode);
+
+void glInit(void *zbuffer);
+void glClose(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/tinygl-0.4-ugfx/include/GL/glx.h

@@ -0,0 +1,144 @@
+#ifndef GLX_H
+#define GLX_H
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/gl.h>
+
+
+/* the following comes from Mesa */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define GLX_VERSION_1_1		1
+
+
+/*
+ * Tokens for glXChooseVisual and glXGetConfig:
+ */
+enum _GLX_CONFIGS {
+	GLX_USE_GL		= 1,
+	GLX_BUFFER_SIZE		= 2,
+	GLX_LEVEL		= 3,
+	GLX_RGBA		= 4,
+	GLX_DOUBLEBUFFER	= 5, 
+	GLX_STEREO		= 6,
+	GLX_AUX_BUFFERS		= 7,
+	GLX_RED_SIZE		= 8,
+	GLX_GREEN_SIZE		= 9,
+	GLX_BLUE_SIZE		= 10,
+	GLX_ALPHA_SIZE		= 11,
+	GLX_DEPTH_SIZE		= 12,
+	GLX_STENCIL_SIZE	= 13,
+	GLX_ACCUM_RED_SIZE	= 14,
+	GLX_ACCUM_GREEN_SIZE	= 15,
+	GLX_ACCUM_BLUE_SIZE	= 16,
+	GLX_ACCUM_ALPHA_SIZE	= 17,
+
+	/* GLX_EXT_visual_info extension */
+	GLX_X_VISUAL_TYPE_EXT		= 0x22,
+	GLX_TRANSPARENT_TYPE_EXT	= 0x23,
+	GLX_TRANSPARENT_INDEX_VALUE_EXT	= 0x24,
+	GLX_TRANSPARENT_RED_VALUE_EXT	= 0x25,
+	GLX_TRANSPARENT_GREEN_VALUE_EXT	= 0x26,
+	GLX_TRANSPARENT_BLUE_VALUE_EXT	= 0x27,
+	GLX_TRANSPARENT_ALPHA_VALUE_EXT	= 0x28
+};
+
+
+/*
+ * Error codes returned by glXGetConfig:
+ */
+#define GLX_BAD_SCREEN		1
+#define GLX_BAD_ATTRIBUTE	2
+#define GLX_NO_EXTENSION	3
+#define GLX_BAD_VISUAL		4
+#define GLX_BAD_CONTEXT		5
+#define GLX_BAD_VALUE       	6
+#define GLX_BAD_ENUM		7
+
+
+/*
+ * GLX 1.1 and later:
+ */
+#define GLX_VENDOR		1
+#define GLX_VERSION		2
+#define GLX_EXTENSIONS 		3
+
+
+/*
+ * GLX_visual_info extension
+ */
+#define GLX_TRUE_COLOR_EXT		0x8002
+#define GLX_DIRECT_COLOR_EXT		0x8003
+#define GLX_PSEUDO_COLOR_EXT		0x8004
+#define GLX_STATIC_COLOR_EXT		0x8005
+#define GLX_GRAY_SCALE_EXT		0x8006
+#define GLX_STATIC_GRAY_EXT		0x8007
+#define GLX_NONE_EXT			0x8000
+#define GLX_TRANSPARENT_RGB_EXT		0x8008
+#define GLX_TRANSPARENT_INDEX_EXT	0x8009
+
+
+typedef void *GLXContext;
+typedef Pixmap GLXPixmap;
+typedef Drawable GLXDrawable;
+typedef XID GLXContextID;
+
+
+extern XVisualInfo* glXChooseVisual( Display *dpy, int screen,
+				     int *attribList );
+
+extern GLXContext glXCreateContext( Display *dpy, XVisualInfo *vis,
+				    GLXContext shareList, Bool direct );
+
+extern void glXDestroyContext( Display *dpy, GLXContext ctx );
+
+extern Bool glXMakeCurrent( Display *dpy, GLXDrawable drawable,
+			    GLXContext ctx);
+
+extern void glXCopyContext( Display *dpy, GLXContext src, GLXContext dst,
+			    GLuint mask );
+
+extern void glXSwapBuffers( Display *dpy, GLXDrawable drawable );
+
+extern GLXPixmap glXCreateGLXPixmap( Display *dpy, XVisualInfo *visual,
+				     Pixmap pixmap );
+
+extern void glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap );
+
+extern Bool glXQueryExtension( Display *dpy, int *errorb, int *event );
+
+extern Bool glXQueryVersion( Display *dpy, int *maj, int *min );
+
+extern Bool glXIsDirect( Display *dpy, GLXContext ctx );
+
+extern int glXGetConfig( Display *dpy, XVisualInfo *visual,
+			 int attrib, int *value );
+
+extern GLXContext glXGetCurrentContext( void );
+
+extern GLXDrawable glXGetCurrentDrawable( void );
+
+extern void glXWaitGL( void );
+
+extern void glXWaitX( void );
+
+extern void glXUseXFont( Font font, int first, int count, int list );
+
+
+/* GLX 1.1 and later */
+extern const char *glXQueryExtensionsString( Display *dpy, int screen );
+
+extern const char *glXQueryServerString( Display *dpy, int screen, int name );
+
+extern const char *glXGetClientString( Display *dpy, int name );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/tinygl-0.4-ugfx/include/GL/nglx.h

@@ -0,0 +1,27 @@
+#ifndef NGLX_H
+#define NGLX_H
+
+#include <microwin/nano-X.h>
+#include <GL/gl.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *NGLXContext;
+typedef GR_DRAW_ID NGLXDrawable;
+
+extern NGLXContext nglXCreateContext( NGLXContext shareList, int flags );
+
+extern void nglXDestroyContext( NGLXContext ctx );
+
+extern int nglXMakeCurrent( NGLXDrawable drawable,
+			    NGLXContext ctx);
+
+extern void nglXSwapBuffers( NGLXDrawable drawable );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/tinygl-0.4-ugfx/include/GL/oscontext.h

@@ -0,0 +1,37 @@
+#ifndef _tgl_osbuffer_h_
+#define _tgl_osbuffer_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  void **zbs;
+  void **framebuffers;
+  int numbuffers;
+  int xsize, ysize;
+} ostgl_context;
+
+ostgl_context *
+ostgl_create_context(const int xsize,
+                     const int ysize,
+                     const int depth,
+                     void **framebuffers,
+                     const int numbuffers);
+void
+ostgl_delete_context(ostgl_context *context);
+
+void
+ostgl_make_current(ostgl_context *context, const int index);
+
+void
+ostgl_resize(ostgl_context * context,
+             const int xsize,
+             const int ysize,
+             void **framebuffers);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _tgl_osbuffer_h_ */

3rdparty/tinygl-0.4-ugfx/include/GLView.h

@@ -0,0 +1,72 @@
+#ifndef _glview_h_
+#define _glview_h_
+
+#define BGL_RGB           0
+#define BGL_INDEX         1
+#define BGL_SINGLE        0
+#define BGL_DOUBLE        2
+#define BGL_DIRECT        0
+#define BGL_INDIRECT      4
+#define BGL_ACCUM         8
+#define BGL_ALPHA        16
+#define BGL_DEPTH        32
+#define BGL_OVERLAY      64
+#define BGL_UNDERLAY    128
+#define BGL_STENCIL     512
+
+#include <interface/View.h>
+#include <support/Locker.h>
+#include <GL/gl.h>
+#include <GL/oscontext.h>
+#include <game/WindowScreen.h>
+#include <game/DirectWindow.h>
+
+class BGLView : public BView {
+public:
+  BGLView(BRect rect, char *name,
+          ulong resizingMode, ulong mode,
+          ulong options);
+  virtual ~BGLView();
+
+  void LockGL();
+  void UnlockGL();
+  void SwapBuffers();
+//  BView *EmbeddedView();
+//  status_t CopyPixelsOut(BPoint source, BBitmap *dest);
+//  status_t CopyPixelsIn(BBitmap *source, BPoint dest);
+
+  virtual void ErrorCallback(GLenum errorCode);
+  virtual void Draw(BRect updateRect);
+  virtual void AttachedToWindow();
+  virtual void AllAttached();
+  virtual void DetachedFromWindow();
+  virtual void AllDetached();
+  virtual void FrameResized(float width, float height);
+//  virtual status_t Perform(perform_code d, void *arg);
+
+  //
+  // Methods below are pass-throughs to BView for the moment.
+  //
+  
+  virtual status_t Archive(BMessage *data, bool deep = true) const;
+  virtual void MessageReceived(BMessage *msg);
+  virtual void SetResizingMode(uint32 mode);
+
+  virtual void Show();
+  virtual void Hide();
+
+  virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index,
+							         BMessage *specifier, int32 form,
+							         const char *property);
+  virtual status_t GetSupportedSuites(BMessage *data);
+  //void DirectConnected( direct_buffer_info *info );
+  //void EnableDirectMode( bool enabled );
+
+private:
+  ostgl_context *context;
+  BBitmap *bitmaps[2];
+  int currBitmap;
+  static BLocker locker;
+};
+
+#endif // _glview_h_

3rdparty/tinygl-0.4-ugfx/src/Makefile

@@ -0,0 +1,43 @@
+include ../config.mk
+
+OBJS= api.o list.o vertex.o init.o matrix.o texture.o \
+      misc.o clear.o light.o clip.o select.o get.o error.o \
+      zbuffer.o zline.o zdither.o ztriangle.o \
+      zmath.o image_util.o oscontext.o msghandling.o \
+      arrays.o specbuf.o memory.o
+ifdef TINYGL_USE_GLX
+OBJS += glx.o
+endif
+ifdef TINYGL_USE_NANOX
+OBJS += nglx.o
+endif
+
+INCLUDES = -I../include
+LIB = libTinyGL.a
+
+all: $(LIB)
+
+$(LIB): $(OBJS)
+	rm -f $(LIB)
+	ar rcs $(LIB) $(OBJS)
+	cp $(LIB) ../lib
+
+clean:
+	rm -f *~ *.o *.a
+
+.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) -Wno-uninitialized $(INCLUDES) -c $*.c

3rdparty/tinygl-0.4-ugfx/src/api.c

@@ -0,0 +1,667 @@
+#include "zgl.h"
+#include <stdio.h>
+/* glVertex */
+
+void glVertex4f(float x,float y,float z,float w)
+{
+  GLParam p[5];
+
+  p[0].op=OP_Vertex;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+  p[4].f=w;
+
+  gl_add_op(p);
+}
+
+void glVertex2f(float x,float y) 
+{
+  glVertex4f(x,y,0,1);
+}
+
+void glVertex3f(float x,float y,float z) 
+{
+  glVertex4f(x,y,z,1);
+}
+
+void glVertex3fv(float *v) 
+{
+  glVertex4f(v[0],v[1],v[2],1);
+}
+
+/* glNormal */
+
+void glNormal3f(float x,float y,float z)
+{
+  GLParam p[4];
+
+  p[0].op=OP_Normal;
+  p[1].f=x;
+  p[2].f=y;
+  p[3].f=z;
+
+  gl_add_op(p);
+}
+
+void glNormal3fv(float *v) 
+{
+  glNormal3f(v[0],v[1],v[2]);
+}
+
+/* glColor */
+
+void glColor4f(float r,float g,float b,float a)
+{
+  GLParam p[8];
+
+  p[0].op=OP_Color;
+  p[1].f=r;
+  p[2].f=g;
+  p[3].f=b;
+  p[4].f=a;
+  /* direct convertion to integer to go faster if no shading */
+  p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + 
+                            ZB_POINT_RED_MIN);
+  p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + 
+                            ZB_POINT_GREEN_MIN);
+  p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + 
+                            ZB_POINT_BLUE_MIN);
+  gl_add_op(p);
+}
+
+void glColor4fv(float *v)
+{
+  GLParam p[8];
+
+  p[0].op=OP_Color;
+  p[1].f=v[0];
+  p[2].f=v[1];
+  p[3].f=v[2];
+  p[4].f=v[3];
+  /* direct convertion to integer to go faster if no shading */
+  p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + 
+                            ZB_POINT_RED_MIN);
+  p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + 
+                            ZB_POINT_GREEN_MIN);
+  p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + 
+                            ZB_POINT_BLUE_MIN);
+  gl_add_op(p);
+}
+
+void glColor3f(float x,float y,float z) 
+{
+  glColor4f(x,y,z,1);
+}
+
+void glColor3fv(float *v) 
+{
+  glColor4f(v[0],v[1],v[2],1);
+}
+
+
+/* TexCoord */
+
+void glTexCoord4f(float s,float t,float r,float q)
+{
+  GLParam p[5];
+
+  p[0].op=OP_TexCoord;
+  p[1].f=s;
+  p[2].f=t;
+  p[3].f=r;
+  p[4].f=q;
+
+  gl_add_op(p);
+}
+
+void glTexCoord2f(float s,float t)
+{
+  glTexCoord4f(s,t,0,1);
+}
+
+void glTexCoord2fv(float *v)
+{
+  glTexCoord4f(v[0],v[1],0,1);
+}
+
+void glEdgeFlag(int flag)
+{
+  GLParam p[2];
+
+  p[0].op=OP_EdgeFlag;
+  p[1].i=flag;
+
+  gl_add_op(p);
+}
+
+/* misc */
+
+void glShadeModel(int mode)
+{
+  GLParam p[2];
+
+  gl_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];
+
+  gl_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];
+
+  gl_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];
+
+  gl_assert(face == GL_BACK ||
+         face == GL_FRONT || 
+         face == GL_FRONT_AND_BACK);
+  gl_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 xnear,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=xnear;
+  p[6].f=farv;
+
+  gl_add_op(p);
+}
+
+/* lightening */
+
+void glMaterialfv(int mode,int type,float *v)
+{
+  GLParam p[7];
+  int i,n;
+
+  gl_assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
+
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  n=4;
+  if (type == GL_SHININESS) n=1;
+  for(i=0;i<4;i++) p[3+i].f=v[i];
+  for(i=n;i<4;i++) p[3+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glMaterialf(int mode,int type,float v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Material;
+  p[1].i=mode;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glColorMaterial(int mode,int type)
+{
+  GLParam p[3];
+
+  p[0].op=OP_ColorMaterial;
+  p[1].i=mode;
+  p[2].i=type;
+
+  gl_add_op(p);
+}
+
+void glLightfv(int light,int type,float *v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  /* TODO: 3 composants ? */
+  for(i=0;i<4;i++) p[3+i].f=v[i];
+
+  gl_add_op(p);
+}
+
+
+void glLightf(int light,int type,float v)
+{
+  GLParam p[7];
+  int i;
+
+  p[0].op=OP_Light;
+  p[1].i=light;
+  p[2].i=type;
+  p[3].f=v;
+  for(i=0;i<3;i++) p[4+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glLightModeli(int pname,int param)
+{
+  GLParam p[6];
+  int i;
+
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  p[2].f=(float)param;
+  for(i=0;i<4;i++) p[3+i].f=0;
+
+  gl_add_op(p);
+}
+
+void glLightModelfv(int pname,float *param)
+{
+  GLParam p[6];
+  int i;
+
+  p[0].op=OP_LightModel;
+  p[1].i=pname;
+  for(i=0;i<4;i++) p[2+i].f=param[i];
+
+  gl_add_op(p);
+}
+
+/* clear */
+
+void glClear(int mask)
+{
+  GLParam p[2];
+
+  p[0].op=OP_Clear;
+  p[1].i=mask;
+
+  gl_add_op(p);
+}
+
+void glClearColor(float r,float g,float b,float a)
+{
+  GLParam p[5];
+
+  p[0].op=OP_ClearColor;
+  p[1].f=r;
+  p[2].f=g;
+  p[3].f=b;
+  p[4].f=a;
+
+  gl_add_op(p);
+}
+
+void glClearDepth(double depth)
+{
+  GLParam p[2];
+
+  p[0].op=OP_ClearDepth;
+  p[1].f=depth;
+
+  gl_add_op(p);
+}
+
+
+/* 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;
+  gl_add_op(p);
+}
+
+/* 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;
+}
+

3rdparty/tinygl-0.4-ugfx/src/arrays.c

@@ -0,0 +1,207 @@
+#include "zgl.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:
+    gl_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:
+    gl_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];
+  gl_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];
+  gl_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];
+  gl_assert(type == GL_FLOAT);
+  p[0].op = OP_NormalPointer;
+  p[1].i = stride;
+  p[2].p = (void*)pointer;
+  gl_add_op(p);
+}
+
+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];
+  gl_assert(type == GL_FLOAT);
+  p[0].op = OP_TexCoordPointer;
+  p[1].i = size;
+  p[2].i = stride;
+  p[3].p = (void*)pointer;
+  gl_add_op(p);
+}

3rdparty/tinygl-0.4-ugfx/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);
+}
+

3rdparty/tinygl-0.4-ugfx/src/clip.c

@@ -0,0 +1,445 @@
+#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 ((unsigned int)z2<min) min=z2;
+  if ((unsigned int)z3<min) min=z3;
+  if ((unsigned int)z2>max) max=z2;
+  if ((unsigned int)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 line_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)) {
+
+      line_interpolate(&q1,p1,p2,tmin);
+      line_interpolate(&q2,p1,p2,tmax);
+      gl_transform_to_viewport(c,&q1);
+      gl_transform_to_viewport(c,&q2);
+
+      if (c->depth_test)
+          ZB_line_z(c->zb,&q1.zp,&q2.zp);
+      else
+          ZB_line(c->zb,&q1.zp,&q2.zp);
+    }
+  }
+}
+
+	 
+/* 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);
+}
+
+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=1;
+      tmp1.edge_flag=0;
+      q[2]->edge_flag=edge_flag_tmp;
+      gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1);
+    } else {
+      /* two points outside */
+
+      if ((cc[0] & clip_mask)==0) { q[0]=p0; q[1]=p1; q[2]=p2; }
+      else if ((cc[1] & clip_mask)==0) { q[0]=p1; q[1]=p2; q[2]=p0; } 
+      else { q[0]=p2; q[1]=p0; q[2]=p1; }
+      
+      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;
+    gl_assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize);
+    gl_assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize);
+    gl_assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize);
+    gl_assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize);
+    gl_assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize);
+    gl_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);
+}
+
+
+
+

3rdparty/tinygl-0.4-ugfx/src/error.c

@@ -0,0 +1,22 @@
+#include <stdarg.h>
+#include <assert.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);
+}
+
+void gl_assert(int test)
+{
+  assert(test);
+}

3rdparty/tinygl-0.4-ugfx/src/get.c

@@ -0,0 +1,74 @@
+#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:
+#ifndef NO_CLIBRARY
+    fprintf(stderr,"warning: unknown pname in glGetFloatv()\n");
+#endif
+    break;
+  }
+}

3rdparty/tinygl-0.4-ugfx/src/glx.c

@@ -0,0 +1,413 @@
+/* simple glx driver for TinyGL */
+#include <GL/glx.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/extensions/XShm.h>
+#include "zgl.h"
+
+typedef struct {
+  GLContext *gl_context;
+  Display *display;
+  XVisualInfo visual_info;
+  int xsize,ysize;
+  XImage *ximage;
+  GC gc;
+  Colormap cmap;
+  Drawable drawable;
+  int do_convert; /* true if must do convertion to X11 format */
+  /* shared memory */
+  int shm_use;
+  XShmSegmentInfo *shm_info;
+  int CompletionType;
+} TinyGLXContext;
+
+Bool glXQueryExtension( Display *dpy, int *errorb, int *event )
+{
+    return True;
+}
+
+
+XVisualInfo* glXChooseVisual( Display *dpy, int screen,
+                              int *attribList )
+{
+    XVisualInfo vinfo;
+    int n;
+    
+    /* the attribList is ignored : we consider only RGBA rendering (no
+       direct color) */
+    
+    if (XMatchVisualInfo (dpy, screen, 16, TrueColor, &vinfo)) {
+        /* 16 bit visual (fastest with TinyGL) */
+    } else if (XMatchVisualInfo (dpy, screen, 24, TrueColor, &vinfo)) {
+        /* 24 bit visual */
+    } else if (XMatchVisualInfo (dpy, screen, 32, TrueColor, &vinfo)) {
+        /* 32 bit visual */
+    } else if (XMatchVisualInfo (dpy, screen, 8, PseudoColor, &vinfo)) {
+        /* 8 bit visual */
+    } else {
+        /* no suitable visual */
+        return NULL;
+    }
+    
+    return XGetVisualInfo(dpy,VisualAllMask,&vinfo,&n);
+}
+
+
+
+GLXContext glXCreateContext( Display *dpy, XVisualInfo *vis,
+                             GLXContext shareList, Bool direct )
+{
+  TinyGLXContext *ctx;
+
+  if (shareList != NULL) {
+    gl_fatal_error("No sharing available in TinyGL");
+  }
+  ctx=gl_malloc(sizeof(TinyGLXContext));
+  ctx->gl_context=NULL;
+  ctx->visual_info=*vis;
+  return (GLXContext) ctx;
+}
+
+
+void glXDestroyContext( Display *dpy, GLXContext ctx1 )
+{
+  TinyGLXContext *ctx = (TinyGLXContext *) ctx1;
+  if (ctx->gl_context != NULL) {
+    glClose();
+  }
+  gl_free(ctx);
+}
+
+
+static int glxXErrorFlag=0;
+
+static int glxHandleXError(Display *dpy,XErrorEvent *event)
+{
+  glxXErrorFlag=1;
+  return 0;
+}
+
+static int bits_per_pixel(Display *dpy, XVisualInfo *visinfo)
+{
+   XImage *img;
+   int bpp;
+   char *data;
+
+   data = gl_malloc(8);
+   if (data == NULL) 
+       return visinfo->depth;
+
+   img = XCreateImage(dpy, visinfo->visual, visinfo->depth,
+                      ZPixmap, 0, data, 1, 1, 32, 0);
+   if (img == NULL) {
+       gl_free(data);
+       return visinfo->depth;
+   }
+   bpp = img->bits_per_pixel;
+   gl_free(data);
+   img->data = NULL;
+   XDestroyImage(img);
+   return bpp;
+}
+
+static int create_ximage(TinyGLXContext *ctx,
+                         int xsize,int ysize,int depth)
+{
+  int major,minor;
+  Bool pixmaps;
+  unsigned char *framebuffer;
+  int (*old_handler)(Display *,XErrorEvent *);
+
+  if (XShmQueryVersion(ctx->display,&major,&minor,&pixmaps))
+    ctx->shm_use=1;
+  else
+    ctx->shm_use=0;
+
+  if (!ctx->shm_use) goto no_shm;
+
+  ctx->shm_info=gl_malloc(sizeof(XShmSegmentInfo));
+  ctx->ximage=XShmCreateImage(ctx->display,None,depth,ZPixmap,NULL,
+                              ctx->shm_info,xsize,ysize);
+  if (ctx->ximage == NULL) {
+    fprintf(stderr,"XShm: error: XShmCreateImage\n");
+    ctx->shm_use=0;
+    gl_free(ctx->shm_info);
+    goto no_shm;
+  }
+  ctx->shm_info->shmid=shmget(IPC_PRIVATE,
+                              ctx->ysize*ctx->ximage->bytes_per_line,
+                              IPC_CREAT | 0777);
+  if (ctx->shm_info->shmid < 0) {
+    fprintf(stderr,"XShm: error: shmget\n");
+  no_shm1:
+    ctx->shm_use=0;
+    XDestroyImage(ctx->ximage);
+    goto no_shm;
+  }
+  ctx->ximage->data=shmat(ctx->shm_info->shmid,0,0);
+  if (ctx->ximage->data == (char *) -1) {
+    fprintf(stderr,"XShm: error: shmat\n");
+  no_shm2:
+    shmctl(ctx->shm_info->shmid,IPC_RMID,0);
+    goto no_shm1;
+  }
+  ctx->shm_info->shmaddr=ctx->ximage->data;
+  
+  ctx->shm_info->readOnly=False;
+
+  /* attach & test X errors */
+
+  glxXErrorFlag=0;
+  old_handler=XSetErrorHandler(glxHandleXError);
+  XShmAttach(ctx->display,ctx->shm_info);
+  XSync(ctx->display, False);
+  
+  if (glxXErrorFlag) {
+    XFlush(ctx->display);
+    shmdt(ctx->shm_info->shmaddr);
+    XSetErrorHandler(old_handler);
+    goto no_shm2;
+  }
+
+  /* the shared memory will be automatically deleted */
+  shmctl(ctx->shm_info->shmid,IPC_RMID,0);
+
+  /* test with a dummy XShmPutImage */
+  XShmPutImage(ctx->display,ctx->drawable,ctx->gc,
+               ctx->ximage,0,0,0,0,1,1,
+               False);
+
+  XSync(ctx->display, False);
+  XSetErrorHandler(old_handler);
+  
+  if (glxXErrorFlag) {
+    fprintf(stderr,"XShm: error: XShmPutImage\n");
+    XFlush(ctx->display);
+    shmdt(ctx->shm_info->shmaddr);
+    goto no_shm2;
+  }
+  
+  ctx->CompletionType=XShmGetEventBase(ctx->display) + ShmCompletion;
+  /* shared memory is OK !! */
+
+  return 0;
+
+  no_shm:
+    ctx->ximage=XCreateImage(ctx->display, None, depth, ZPixmap, 0, 
+                             NULL,xsize,ysize, 8, 0);
+    framebuffer=gl_malloc(ysize * ctx->ximage->bytes_per_line);
+    ctx->ximage->data = framebuffer;
+    return 0;
+}
+
+static void free_ximage(TinyGLXContext *ctx)
+{
+  if (ctx->shm_use)
+  {
+    XShmDetach(ctx->display, ctx->shm_info);
+    XDestroyImage(ctx->ximage);
+    shmdt(ctx->shm_info->shmaddr);
+    gl_free(ctx->shm_info);
+  } else {
+    gl_free(ctx->ximage->data);
+    XDestroyImage(ctx->ximage);
+  }
+}
+
+/* resize the glx viewport : we try to use the xsize and ysize
+   given. We return the effective size which is guaranted to be smaller */
+
+int glX_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr)
+{
+  TinyGLXContext *ctx;
+  int xsize,ysize;
+
+  ctx=(TinyGLXContext *)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;
+  *ysize_ptr=ysize;
+
+  if (ctx->ximage != NULL) free_ximage(ctx);
+  
+  ctx->xsize=xsize;
+  ctx->ysize=ysize;
+
+  if (create_ximage(ctx,ctx->xsize,ctx->ysize,ctx->visual_info.depth) != 0) 
+    return -1;
+
+  /* resize the Z buffer */
+  if (ctx->do_convert) {
+    ZB_resize(c->zb,NULL,xsize,ysize);
+  } else {
+    ZB_resize(c->zb,ctx->ximage->data,xsize,ysize);
+  }
+  return 0;
+}
+
+/* we assume here that drawable is a window */
+Bool glXMakeCurrent( Display *dpy, GLXDrawable drawable,
+                     GLXContext ctx1)
+{
+  TinyGLXContext *ctx = (TinyGLXContext *) ctx1;
+  XWindowAttributes attr;
+  int i,xsize,ysize;
+  unsigned int palette[ZB_NB_COLORS];
+  unsigned char color_indexes[ZB_NB_COLORS];
+  ZBuffer *zb;
+  XColor xcolor;
+  unsigned long pixel[ZB_NB_COLORS],tmp_plane;
+  
+  if (ctx->gl_context == NULL) {
+    /* create the TinyGL context */
+
+    ctx->display=dpy;
+    ctx->drawable=drawable;
+
+    XGetWindowAttributes(ctx->display,drawable,&attr);
+
+    xsize=attr.width;
+    ysize=attr.height;
+
+    if (attr.depth != ctx->visual_info.depth) return False;
+
+    /* ximage structure */
+    ctx->ximage=NULL;
+    ctx->shm_use=1; /* use shm */
+
+    if (attr.depth == 8) {
+      /* get the colormap from the window */
+      ctx->cmap = attr.colormap;
+
+      if ( XAllocColorCells(ctx->display,ctx->cmap,True,&tmp_plane,0,
+                            pixel,ZB_NB_COLORS) == 0) {
+        /* private cmap */
+        ctx->cmap = XCreateColormap(ctx->display, drawable,  
+                                    ctx->visual_info.visual, AllocAll);
+        XSetWindowColormap(ctx->display, drawable, ctx->cmap);
+        for(i=0;i<ZB_NB_COLORS;i++) pixel[i]=i;
+      }
+
+      for(i=0;i<ZB_NB_COLORS;i++) color_indexes[i]=pixel[i];
+
+      /* Open the Z Buffer - 256 colors */
+      zb=ZB_open(xsize,ysize,ZB_MODE_INDEX,ZB_NB_COLORS,
+                 color_indexes,palette,NULL);
+      if (zb == NULL) {
+        fprintf(stderr, "Error while initializing Z buffer\n");
+        exit(1);
+      }
+
+      for (i=0; i<ZB_NB_COLORS; i++) {
+        xcolor.flags = DoRed | DoGreen | DoBlue;
+        
+        xcolor.red = (palette[i]>>8) & 0xFF00;
+        xcolor.green = (palette[i] & 0xFF00);
+        xcolor.blue = (palette[i] << 8) & 0xFF00;
+        xcolor.pixel = pixel[i];
+        XStoreColor(ctx->display,ctx->cmap,&xcolor);
+      }
+      ctx->do_convert = 1;
+    } else {
+        int mode,bpp;
+        /* RGB 16/24/32 */
+        bpp = bits_per_pixel(ctx->display,&ctx->visual_info);
+        switch(bpp) {
+        case 24:
+            mode = ZB_MODE_RGB24;
+            ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16);
+            break;
+        case 32:
+            mode = ZB_MODE_RGBA;
+            ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16);
+            break;
+        default:
+            mode = ZB_MODE_5R6G5B;
+            ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16);
+            break;
+        }
+        zb=ZB_open(xsize,ysize,mode,0,NULL,NULL,NULL);
+        if (zb == NULL) {
+            fprintf(stderr, "Error while initializing Z buffer\n");
+            exit(1);
+        }
+    }
+
+    /* create a gc */
+    ctx->gc = XCreateGC(ctx->display, drawable, 0, 0);
+
+    /* 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=glX_resize_viewport;
+
+    /* set the viewport : we force a call to glX_resize_viewport */
+    ctx->gl_context->viewport.xsize=-1;
+    ctx->gl_context->viewport.ysize=-1;
+
+    glViewport(0, 0, xsize, ysize);
+  }
+
+  return True;
+}
+
+static Bool WaitForShmCompletion(Display *dpy, XEvent *event, char *arg) 
+{
+    TinyGLXContext *ctx=(TinyGLXContext *) arg;
+
+    return (event->type == ctx->CompletionType) && 
+        ( ((XShmCompletionEvent *)event)->drawable == (Window)ctx->drawable); 
+}
+
+void glXSwapBuffers( Display *dpy, GLXDrawable drawable )
+{
+  GLContext *gl_context;
+  TinyGLXContext *ctx;
+
+  /* retrieve the current GLXContext */
+  gl_context=gl_get_context();
+  ctx=(TinyGLXContext *)gl_context->opaque;
+
+  /* for non 16 bits visuals, a conversion is required */
+  
+
+  if (ctx->do_convert) {
+    ZB_copyFrameBuffer(ctx->gl_context->zb,
+                       ctx->ximage->data,
+                       ctx->ximage->bytes_per_line);
+
+  }
+
+  /* draw the ximage */
+  if (ctx->shm_use) {
+      XEvent event;
+
+      XShmPutImage(dpy,drawable,ctx->gc,
+                   ctx->ximage,0,0,0,0,ctx->ximage->width, ctx->ximage->height,
+                   True);
+      XIfEvent(dpy, &event, WaitForShmCompletion, (char*)ctx);
+  } else {
+    XPutImage(dpy, drawable, ctx->gc, 
+              ctx->ximage, 0, 0, 0, 0, ctx->ximage->width, ctx->ximage->height);
+  }
+  XFlush(dpy);
+}
+
+
+void glXWaitGL( void )
+{
+}
+
+void glXWaitX( void )
+{
+}

3rdparty/tinygl-0.4-ugfx/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;
+  }
+}
+

3rdparty/tinygl-0.4-ugfx/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);
+}

3rdparty/tinygl-0.4-ugfx/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:
+    gl_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;
+  
+  gl_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];
+      gl_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:
+    gl_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);
+    //gl_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;
+}
+

3rdparty/tinygl-0.4-ugfx/src/list.c

@@ -0,0 +1,263 @@
+#include "zgl.h"
+
+static char *op_table_str[]=
+{
+#define ADD_OP(a,b,c) "gl" #a " " #c,
+
+#include "opinfo.h"
+};
+
+static void (*op_table_func[])(GLContext *,GLParam *)=
+{
+#define ADD_OP(a,b,c) glop ## a ,
+
+#include "opinfo.h"
+};
+
+static int op_table_size[]=
+{
+#define ADD_OP(a,b,c) b + 1 ,
+
+#include "opinfo.h"
+};
+
+
+GLContext *gl_get_context(void)
+{
+  return gl_ctx;
+}
+
+static GLList *find_list(GLContext *c,unsigned int list)
+{
+  return c->shared_state.lists[list];
+}
+
+static void delete_list(GLContext *c,int list)
+{
+  GLParamBuffer *pb,*pb1;
+  GLList *l;
+
+  l=find_list(c,list);
+  gl_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;
+}
+
+
+#ifndef NO_STDIO
+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");
+}
+#endif
+
+
+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);
+  }
+#ifndef NO_CLIBRARY
+  if (c->print_flag) {
+    gl_print_op(stderr,p);
+  }
+#endif
+}
+
+/* this opcode is never called directly */
+void glopEndList(GLContext *c,GLParam *p)
+{
+	(void) c;
+	(void) p;
+  gl_assert(0);
+}
+
+/* this opcode is never called directly */
+void glopNextBuffer(GLContext *c,GLParam *p)
+{
+	(void) c;
+	(void) p;
+  gl_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();
+
+  gl_assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE);
+  gl_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];
+
+  gl_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;
+}
+

3rdparty/tinygl-0.4-ugfx/src/matrix.c

@@ -0,0 +1,247 @@
+#include "zgl.h"
+
+void gl_print_matrix( const float *m)
+{
+#ifndef NO_CLIBRARY
+   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] );
+   }
+#else
+   (void) m;
+#endif
+}
+
+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:
+    gl_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)
+{
+  (void)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;
+  (void)p;
+
+  gl_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;
+  (void)p;
+
+  gl_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 xnear=p[5].f;
+  float farp=p[6].f;
+  float x,y,A,B,C,D;
+
+  x = (2.0*xnear) / (right-left);
+  y = (2.0*xnear) / (top-bottom);
+  A = (right+left) / (right-left);
+  B = (top+bottom) / (top-bottom);
+  C = -(farp+xnear) / ( farp-xnear);
+  D = -(2.0*farp*xnear) / (farp-xnear);
+
+  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);
+}
+  

3rdparty/tinygl-0.4-ugfx/src/memory.c

@@ -0,0 +1,21 @@
+/*
+ * Memory allocator for TinyGL
+ */
+#include "zgl.h"
+
+/* modify these functions so that they suit your needs */
+
+void gl_free(void *p)
+{
+    free(p);
+}
+
+void *gl_malloc(int size)
+{
+    return malloc(size);
+}
+
+void *gl_zalloc(int size)
+{
+    return calloc(1, size);
+}

3rdparty/tinygl-0.4-ugfx/src/misc.c

@@ -0,0 +1,149 @@
+#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:
+    gl_assert(0);
+  }
+}
+
+void glopHint(GLContext *c,GLParam *p)
+{
+	  (void)c;
+	  (void)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;
+}

3rdparty/tinygl-0.4-ugfx/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 */
+}

3rdparty/tinygl-0.4-ugfx/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_ */

3rdparty/tinygl-0.4-ugfx/src/nglx.c

@@ -0,0 +1,128 @@
+/* simple glx like driver for TinyGL and Nano X */
+#include <GL/gl.h>
+#include <GL/nglx.h>
+#include <microwin/nano-X.h>
+#include "zgl.h"
+
+typedef struct {
+    GLContext *gl_context;
+    int xsize,ysize;
+    GR_DRAW_ID drawable;
+    GR_GC_ID gc;
+    int pixtype; /* pixel type in TinyGL */
+} TinyNGLXContext;
+
+NGLXContext nglXCreateContext(NGLXContext shareList, int flags)
+{
+  TinyNGLXContext *ctx;
+
+  if (shareList != NULL) {
+    gl_fatal_error("No sharing available in TinyGL");
+  }
+  ctx=gl_malloc(sizeof(TinyNGLXContext));
+  if (!ctx)
+      return NULL;
+  ctx->gl_context=NULL;
+  return (NGLXContext) ctx;
+}
+
+void glXDestroyContext( NGLXContext ctx1 )
+{
+  TinyNGLXContext *ctx = (TinyNGLXContext *) 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 glX_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr)
+{
+  TinyNGLXContext *ctx;
+  int xsize,ysize;
+  
+  ctx=(TinyNGLXContext *)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;
+  *ysize_ptr=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 nglXMakeCurrent( NGLXDrawable drawable,
+                     NGLXContext ctx1)
+{
+  TinyNGLXContext *ctx = (TinyNGLXContext *) ctx1;
+  int mode, xsize, ysize;
+  ZBuffer *zb;
+  GR_WINDOW_INFO win_info;
+
+  if (ctx->gl_context == NULL) {
+      /* create the TinyGL context */
+      GrGetWindowInfo(drawable, &win_info);
+
+      xsize = win_info.width;
+      ysize = win_info.height;
+
+      /* currently, we only support 16 bit rendering */
+      mode = ZB_MODE_5R6G5B;
+      zb=ZB_open(xsize,ysize,mode,0,NULL,NULL,NULL);
+      if (zb == NULL) {
+          fprintf(stderr, "Error while initializing Z buffer\n");
+          exit(1);
+      }
+
+      ctx->pixtype = MWPF_TRUECOLOR565;
+
+      /* create a gc */
+      ctx->gc = GrNewGC();
+      
+      /* 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=glX_resize_viewport;
+
+      /* set the viewport : we force a call to glX_resize_viewport */
+      ctx->gl_context->viewport.xsize=-1;
+      ctx->gl_context->viewport.ysize=-1;
+      
+      glViewport(0, 0, xsize, ysize);
+  }
+  
+  return 1;
+}
+
+void nglXSwapBuffers( NGLXDrawable drawable )
+{
+    GLContext *gl_context;
+    TinyNGLXContext *ctx;
+    
+    /* retrieve the current NGLXContext */
+    gl_context=gl_get_context();
+    ctx=(TinyNGLXContext *)gl_context->opaque;
+    
+    GrArea(drawable, ctx->gc, 0, 0, ctx->xsize, 
+           ctx->ysize, ctx->gl_context->zb->pbuf, ctx->pixtype);
+}
+
+

3rdparty/tinygl-0.4-ugfx/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

3rdparty/tinygl-0.4-ugfx/src/oscontext.c

@@ -0,0 +1,83 @@
+#include <GL/oscontext.h>
+#include "zbuffer.h"
+#include "zgl.h"
+#include <GL/gl.h>
+#include <stdlib.h>
+
+static int buffercnt = 0;
+
+ostgl_context *
+ostgl_create_context(const int xsize,
+                     const int ysize,
+                     const int depth,
+                     void **framebuffers,
+                     const int numbuffers)
+{
+  ostgl_context *context;
+  int i;
+  ZBuffer *zb;
+   
+  gl_assert(depth == 16); /* support for other depths must include bpp
+                          convertion */
+  gl_assert(numbuffers >= 1);
+  
+  context = gl_malloc(sizeof(ostgl_context));
+  gl_assert(context);
+  context->zbs = gl_malloc(sizeof(void*)*numbuffers);
+  context->framebuffers = gl_malloc(sizeof(void*)*numbuffers);
+  
+  gl_assert(context->zbs != NULL && context->framebuffers != NULL);
+  
+  for (i = 0; i < numbuffers; i++) {
+    context->framebuffers[i] = framebuffers[i];
+    zb = ZB_open(xsize, ysize, ZB_MODE_5R6G5B, 0, NULL, NULL, framebuffers[i]);
+    if (zb == NULL) {
+      fprintf(stderr, "Error while initializing Z buffer\n");
+      exit(1);
+    }
+    context->zbs[i] = zb;
+  }
+  if (++buffercnt == 1) {
+    glInit(context->zbs[0]);
+  }
+  context->xsize = xsize;
+  context->ysize = ysize;
+  context->numbuffers = numbuffers;
+  return context;
+}
+
+void
+ostgl_delete_context(ostgl_context *context)
+{
+  int i;
+  for (i = 0; i < context->numbuffers; i++) {
+    ZB_close(context->zbs[i]);
+  }
+  gl_free(context->zbs);
+  gl_free(context->framebuffers);
+  gl_free(context);
+  
+  if (--buffercnt == 0) {
+    glClose();
+  }
+}
+
+void
+ostgl_make_current(ostgl_context *oscontext, const int idx)
+{
+  GLContext *context = gl_get_context();
+  gl_assert(idx < oscontext->numbuffers);
+  context->zb = oscontext->zbs[idx];
+}
+
+void
+ostgl_resize(ostgl_context *context,
+             const int xsize,
+             const int ysize,
+             void **framebuffers)
+{
+  int i;
+  for (i = 0; i < context->numbuffers; i++) {
+    ZB_resize(context->zbs[i], framebuffers[i], xsize, ysize);
+  }
+}

3rdparty/tinygl-0.4-ugfx/src/select.c

@@ -0,0 +1,116 @@
+#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:
+    gl_assert(0);
+  }
+  switch(mode) {
+  case GL_RENDER:
+    c->render_mode=GL_RENDER;
+    break;
+  case GL_SELECT:
+    c->render_mode=GL_SELECT;
+    gl_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:
+    gl_assert(0);
+  }
+  return result;
+}
+
+void glSelectBuffer(int size,unsigned int *buf)
+{
+  GLContext *c=gl_get_context();
+
+  gl_assert(c->render_mode != GL_SELECT);
+  
+  c->select_buffer=buf;
+  c->select_size=size;
+}
+
+
+void glopInitNames(GLContext *c,GLParam *p)
+{
+	  (void)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) {
+    gl_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)
+{
+	  (void)p;
+  if (c->render_mode == GL_SELECT) {
+    gl_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) {
+   gl_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;
+    }
+  }
+}

3rdparty/tinygl-0.4-ugfx/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;
+}

3rdparty/tinygl-0.4-ugfx/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_ */

3rdparty/tinygl-0.4-ugfx/src/texture.c

@@ -0,0 +1,232 @@
+/*
+ * 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;
+
+  gl_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;
+  (void)c;
+
+  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;
+  (void)c;
+  
+  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;
+  (void)c;
+
+  if (pname != GL_UNPACK_ALIGNMENT ||
+      param != 1) {
+    gl_fatal_error("glPixelStore: unsupported option");
+  }
+}

3rdparty/tinygl-0.4-ugfx/src/vertex.c

@@ -0,0 +1,365 @@
+#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;
+
+    gl_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;
+
+    gl_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)
+{
+	(void) param;
+    gl_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;
+}

3rdparty/tinygl-0.4-ugfx/src/zbuffer.c

@@ -0,0 +1,517 @@
+/*
+
+ * Z buffer: 16 bits Z / 16 bits color
+ * 
+ */
+#include <stdlib.h>
+#include <stdio.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;
+
+    if (frame_buffer == NULL) {
+	zb->pbuf = gl_malloc(zb->ysize * zb->linesize);
+	if (zb->pbuf == NULL) {
+	    gl_free(zb->zbuf);
+	    goto error;
+	}
+	zb->frame_buffer_allocated = 1;
+    } else {
+	zb->frame_buffer_allocated = 0;
+	zb->pbuf = frame_buffer;
+    }
+
+    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 * 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);
+
+	p1 = (unsigned int *)(((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:
+	gl_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:
+	gl_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:
+	gl_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);
+	}
+    }
+}

3rdparty/tinygl-0.4-ugfx/src/zbuffer.h

@@ -0,0 +1,153 @@
+#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.c */
+void gl_free(void *p);
+void *gl_malloc(int size);
+void *gl_zalloc(int size);
+
+#endif /* _tgl_zbuffer_h_ */

3rdparty/tinygl-0.4-ugfx/src/zdither.c

@@ -0,0 +1,158 @@
+/* 
+ * 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)) {
+	gl_fatal_error("zdither: not enough colors\n");
+  }
+
+  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

3rdparty/tinygl-0.4-ugfx/src/zfeatures.h

@@ -0,0 +1,43 @@
+#ifndef _tgl_features_h_
+#define _tgl_features_h_
+
+/* 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_ */

3rdparty/tinygl-0.4-ugfx/src/zgl.h

@@ -0,0 +1,372 @@
+#ifndef _tgl_zgl_h_
+#define _tgl_zgl_h_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <GL/gl.h>
+#include "zbuffer.h"
+#include "zmath.h"
+#include "zfeatures.h"
+
+#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);
+
+GLContext *gl_get_context(void);
+
+void gl_fatal_error(char *format, ...);
+void gl_assert(int test);
+
+
+/* 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) ;
+}
+
+#endif /* _tgl_zgl_h_ */

3rdparty/tinygl-0.4-ugfx/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);
+    }
+}

3rdparty/tinygl-0.4-ugfx/src/zline.h

@@ -0,0 +1,122 @@
+{
+    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 = p2->r << 8;
+    g = p2->g << 8;
+    b = p2->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
+
+#undef RGB
+#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 

3rdparty/tinygl-0.4-ugfx/src/zmath.c

@@ -0,0 +1,275 @@
+/* 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é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));
+  /*tmp=*b;*/
+  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;
+}
+
+

3rdparty/tinygl-0.4-ugfx/src/zmath.h

@@ -0,0 +1,53 @@
+#ifndef __ZMATH__
+#define __ZMATH__
+
+/* 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__

3rdparty/tinygl-0.4-ugfx/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

3rdparty/tinygl-0.4-ugfx/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

demos/modules/gwin/gl3d/demo.mk

@@ -0,0 +1,3 @@
+DEMODIR = $(GFXLIB)/demos/modules/gwin/gl3d
+GFXINC +=   $(DEMODIR)
+GFXSRC +=	$(DEMODIR)/main.c

demos/modules/gwin/gl3d/gfxconf.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2012, 2013, Joel Bodenmann aka Tectu <joel@unormal.org>
+ * Copyright (c) 2012, 2013, Andrew Hannam aka inmarket
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *    * Neither the name of the <organization> nor the
+ *      names of its contributors may be used to endorse or promote products
+ *      derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _GFXCONF_H
+#define _GFXCONF_H
+
+/* The operating system to use. One of these must be defined - preferably in your Makefile */
+//#define GFX_USE_OS_CHIBIOS	FALSE
+//#define GFX_USE_OS_WIN32		FALSE
+//#define GFX_USE_OS_LINUX		FALSE
+//#define GFX_USE_OS_OSX		FALSE
+
+/* GFX sub-systems to turn on */
+#define GFX_USE_GDISP			TRUE
+#define GFX_USE_GWIN			TRUE
+
+/* Features for the GDISP sub-system. */
+#define GDISP_NEED_VALIDATION	TRUE
+#define GDISP_NEED_CLIP			TRUE
+
+/* Features for the GWIN subsystem. */
+#define GWIN_NEED_GL3D          TRUE
+
+#endif /* _GFXCONF_H */
+

demos/modules/gwin/gl3d/main.c

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2012, 2013, Joel Bodenmann aka Tectu <joel@unormal.org>
+ * Copyright (c) 2012, 2013, Andrew Hannam aka inmarket
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *    * Neither the name of the <organization> nor the
+ *      names of its contributors may be used to endorse or promote products
+ *      derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "gfx.h"
+
+/* The handles for our two Windows */
+GHandle gh;
+
+static GLfloat Xrot, Xstep;
+static GLfloat Yrot, Ystep;
+static GLfloat Zrot, Zstep;
+static GLfloat Step = 5.0;
+static GLfloat Scale = 1.0;
+static GLuint Object;
+
+static GLuint make_object( void )
+{
+   GLuint list;
+
+   list = glGenLists( 1 );
+
+   glNewList( list, GL_COMPILE );
+
+   glBegin( GL_LINE_LOOP );
+   glColor3f( 1.0, 1.0, 1.0 );
+   glVertex3f(  1.0,  0.5, -0.4 );
+   glColor3f( 1.0, 0.0, 0.0 );
+   glVertex3f(  1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 1.0, 0.0 );
+   glVertex3f( -1.0, -0.5, -0.4 );
+   glColor3f( 0.0, 0.0, 1.0 );
+   glVertex3f( -1.0,  0.5, -0.4 );
+   glEnd();
+
+   glColor3f( 1.0, 1.0, 1.0 );
+
+   glBegin( GL_LINE_LOOP );
+   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+
+   glBegin( GL_LINES );
+   glVertex3f(  1.0,  0.5, -0.4 );   glVertex3f(  1.0,  0.5, 0.4 );
+   glVertex3f(  1.0, -0.5, -0.4 );   glVertex3f(  1.0, -0.5, 0.4 );
+   glVertex3f( -1.0, -0.5, -0.4 );   glVertex3f( -1.0, -0.5, 0.4 );
+   glVertex3f( -1.0,  0.5, -0.4 );   glVertex3f( -1.0,  0.5, 0.4 );
+   glEnd();
+
+
+   glEndList();
+
+   return list;
+}
+
+static void draw( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT );
+
+   glPushMatrix();
+
+   glTranslatef( 0.0, 0.0, -10.0 );
+   glScalef( Scale, Scale, Scale );
+   if (Xstep) {
+      glRotatef( Xrot, 1.0, 0.0, 0.0 );
+   }
+   else if (Ystep) {
+      glRotatef( Yrot, 0.0, 1.0, 0.0 );
+   }
+   else {
+      glRotatef( Zrot, 0.0, 0.0, 1.0 );
+   }
+
+   glCallList( Object );
+
+   glPopMatrix();
+
+   glFlush();
+   gwinRedraw(gh);
+}
+
+
+static void idle( void )
+{
+   Xrot += Xstep;
+   Yrot += Ystep;
+   Zrot += Zstep;
+
+   if (Xrot>=360.0) {
+      Xrot = Xstep = 0.0;
+      Ystep = Step;
+   }
+   else if (Yrot>=360.0) {
+      Yrot = Ystep = 0.0;
+      Zstep = Step;
+   }
+   else if (Zrot>=360.0) {
+      Zrot = Zstep = 0.0;
+      Xstep = Step;
+   }
+   draw();
+}
+
+int main(void) {
+    /* Initialize and clear the display */
+    gfxInit();
+    gdispClear(White);
+
+    /* Create the 3D window */
+    {
+    	GWindowInit	wi;
+
+		gwinClearInit(&wi);
+    	wi.show = TRUE; wi.x = 20; wi.y = 10; wi.width = 200; wi.height = 150;
+        gh = gwinGL3DCreate(0, &wi);
+    }
+
+    /* Set fore- and background colors */
+    gwinSetColor(gh, White);
+    gwinSetBgColor(gh, Blue);
+
+    /* Clear the window */
+    gwinClear(gh);
+
+    /* Init the 3D stuff */
+    glViewport(0, 0, (GLint)gwinGetWidth(gh), (GLint)gwinGetHeight(gh));
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
+    glMatrixMode(GL_MODELVIEW);
+
+    Object = make_object();
+    glCullFace( GL_BACK );
+   	//   glEnable( GL_CULL_FACE );
+    glDisable( GL_DITHER );
+    glShadeModel( GL_FLAT );
+   	//   glEnable( GL_DEPTH_TEST );
+    Xrot = Yrot = Zrot = 0.0;
+    Xstep = Step;
+    Ystep = Zstep = 0.0;
+
+
+    while(TRUE) {
+
+    	// rate control
+    	gfxSleepMilliseconds(10);
+
+    	// move and redraw
+    	idle();
+    }   
+}
+

gfxconf.example.h

@@ -153,6 +153,7 @@
 //    #define GWIN_CONSOLE_USE_BASESTREAM              FALSE
 //    #define GWIN_CONSOLE_USE_FLOAT                   FALSE
 //#define GWIN_NEED_GRAPH                              FALSE
+//#define GWIN_NEED_GL3D                               FALSE
 
 //#define GWIN_NEED_WIDGET                             FALSE
 //    #define GWIN_NEED_LABEL                          FALSE

src/gwin/gwin_gl3d.c

@@ -0,0 +1,171 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ *              http://ugfx.org/license.html
+ */
+
+/**
+ * @file    src/gwin/gwin_gl3d.c
+ * @brief   GWIN sub-system button code
+ */
+
+#include "gfx.h"
+
+#if GFX_USE_GWIN && GWIN_NEED_GL3D
+
+#if GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB565
+	#error "GWIN: GL3D only support GDISP_PIXELFORMAT_RGB565 color format (TinyGL limitation)"
+#endif
+
+#include "src/gwin/class_gwin.h"
+
+#include "3rdparty/tinygl-0.4-ugfx/src/zgl.h"
+
+// Forward definitions
+static void gl3dDestroy(GWindowObject *gh);
+static void gl3dRedraw(GWindowObject *gh);
+static int gl3dResizeGLViewport(GLContext *c, int *xsize_ptr, int *ysize_ptr);
+
+static const gwinVMT gl3dVMT = {
+		"GL3D",					// The classname
+		sizeof(GGL3DObject),	// The object size
+		gl3dDestroy,			// The destroy routine
+		gl3dRedraw,				// The redraw routine
+		0,						// The after-clear routine
+};
+
+static bool_t	haveGLwindow = FALSE;
+
+GHandle gwinGGL3DCreate(GDisplay *g, GGL3DObject *gl, const GWindowInit *pInit) {
+	ZBuffer *	zb;
+	GLContext *	glcxt;
+
+	// Only one GL3D window allowed at a time (TinyGL limitation)
+	if (haveGLwindow)
+		return 0;
+
+	if (!(gl = (GGL3DObject *)_gwindowCreate(g, &gl->g, pInit, &gl3dVMT, 0)))
+		return 0;
+
+	// Must be a multiple of 4 bytes
+	gl->g.width &= ~3;
+	gl->g.height &= ~3;
+
+    zb = ZB_open(gl->g.width, gl->g.height, ZB_MODE_5R6G5B, 0, NULL, NULL, NULL);
+    if (!zb) {
+		if ((gl->g.flags & GWIN_FLG_DYNAMIC))
+			gfxFree(gl);
+		return 0;
+    }
+
+    /* initialisation of the TinyGL interpreter */
+    glInit(zb);
+    gl->glcxt = glcxt = gl_get_context();
+    glcxt->opaque = gl;
+    glcxt->gl_resize_viewport = gl3dResizeGLViewport;
+
+    /* set the viewport : we force a call to the viewport resize routine */
+    glcxt->viewport.xsize=-1;
+    glcxt->viewport.ysize=-1;
+
+    glViewport(0, 0, gl->g.width, gl->g.height);
+
+    haveGLwindow = TRUE;
+	gwinSetVisible((GHandle)gl, pInit->show);
+	return (GHandle)gl;
+}
+
+static void gl3dDestroy(GWindowObject *gh) {
+	(void) gh;
+    glClose();
+    haveGLwindow = FALSE;
+}
+
+static void gl3dRedraw(GWindowObject *gh) {
+	ZBuffer *	zb;
+
+	zb = ((GGL3DObject *)gh)->glcxt->zb;
+	gdispGBlitArea(gh->display, gh->x, gh->y, zb->xsize, zb->ysize, 0, 0, zb->linesize/sizeof(color_t), (const pixel_t *)zb->pbuf);
+}
+
+static int gl3dResizeGLViewport(GLContext *c, int *xsize_ptr, int *ysize_ptr) {
+	int		cx, cy;
+
+	cx = *xsize_ptr;
+	cy = *ysize_ptr;
+
+	// We ensure that cx and cy are multiples of 4 for the zbuffer. TODO: find a better solution
+	cx &= ~3;
+	cy &= ~3;
+
+	if (cx <= 0 || cy <= 0)
+		return -1;
+
+	*xsize_ptr = cx;
+	*ysize_ptr = cy;
+
+	// Resize the GWIN???
+
+	// Resize the Z buffer
+	ZB_resize(c->zb, NULL, cx, cy);
+	return 0;
+}
+
+/**
+ * TinyGL support routines
+ */
+
+#include <string.h>
+
+#define NO_CLIBRARY
+
+void tgl_warning(const char *format, ...)	{ (void)format; }
+void tgl_trace(const char *format, ...)		{ (void)format; }
+void tgl_fixme(const char *format, ...)		{ (void)format; }
+void gl_fatal_error(char *format, ...)		{ gfxHalt(format); }
+void gl_assert(int test)					{ if (!test) gfxHalt("TinyGL Assert"); }
+
+void gl_free(void *p)						{ gfxFree(p); }
+void *gl_malloc(int size)					{ return gfxAlloc(size); }
+
+void *gl_zalloc(int size) {
+	void	*p;
+
+	p = gfxAlloc(size);
+	if (p)
+		memset(p, 0, size);
+    return p;
+}
+
+
+/**
+ * Pre-load TinyGL headers
+ */
+
+/**
+ * TinyGL wrapper code
+ */
+
+#include "3rdparty/tinygl-0.4-ugfx/src/api.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/list.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/vertex.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/init.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/matrix.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/texture.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/misc.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/clear.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/light.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/clip.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/select.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/get.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/zbuffer.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/zline.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/zdither.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/ztriangle.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/zmath.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/image_util.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/arrays.c"
+#include "3rdparty/tinygl-0.4-ugfx/src/specbuf.c"
+
+#endif /* GFX_USE_GWIN && GWIN_NEED_GL3D */

src/gwin/gwin_gl3d.h

@@ -0,0 +1,70 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ *              http://ugfx.org/license.html
+ */
+
+/**
+ * @file	src/gwin/gwin_gl3d.h
+ * @brief	GWIN 3D module header file
+ *
+ * @defgroup 3D 3D
+ * @ingroup Windows
+ *
+ * @details	3D GWIN window based on OpenGL (or more exactly Tiny GL)
+ * @pre		GFX_USE_GWIN must be set to TRUE in your gfxconf.h
+ * @pre		GWIN_NEED_GL3D must be set to TRUE in your gfxconf.h
+ *
+ * @{
+ */
+
+#ifndef _GWIN_GL3D_H
+#define _GWIN_GL3D_H
+
+/* This file is included within "gwin/gwin.h" */
+
+
+// A gl3d window
+typedef struct GGL3DObject {
+	GWindowObject		g;
+	struct GLContext *	glcxt;
+	} GGL3DObject;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Create a gl3d window.
+ * @return  NULL if there is no resultant drawing area, otherwise a window handle.
+ *
+ * @param[in] g			The GDisplay to display this window on
+ * @param[in] gg		The GGL3DObject structure to initialise. If this is NULL the structure is dynamically allocated.
+ * @param[in] pInit		The initialization parameters to use
+ *
+ * @note				The drawing color and the background color get set to the current defaults. If you haven't called
+ * 						@p gwinSetDefaultColor() or @p gwinSetDefaultBgColor() then these are White and Black respectively.
+ * @note				The font gets set to the current default font. If you haven't called @p gwinSetDefaultFont() then there
+ * 						is no default font and text drawing operations will no nothing.
+ * @note				The dimensions and position may be changed to fit on the real screen.
+ *
+ * @api
+ */
+GHandle gwinGGL3DCreate(GDisplay *g, GGL3DObject *gg, const GWindowInit *pInit);
+#define gwinGL3DCreate(gg, pInit)			gwinGGL3DCreate(GDISP, gg, pInit)
+
+/* Include the gl interface */
+#include "3rdparty/tinygl-0.4-ugfx/include/GL/gl.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _GWIN_GL3D_H */
+/** @} */
+

src/gwin/sys_defs.h

@@ -962,14 +962,15 @@ extern "C" {
 	#if GWIN_NEED_CONSOLE || defined(__DOXYGEN__)
 		#include "src/gwin/console.h"
 	#endif
-
 	#if GWIN_NEED_GRAPH || defined(__DOXYGEN__)
 		#include "src/gwin/graph.h"
 	#endif
-
 	#if GWIN_NEED_IMAGE || defined(__DOXYGEN__)
 		#include "src/gwin/gimage.h"
 	#endif
+	#if GWIN_NEED_GL3D || defined(__DOXYGEN__)
+		#include "src/gwin/gwin_gl3d.h"
+	#endif
 
 #endif /* GFX_USE_GWIN */
 

src/gwin/sys_make.mk

@@ -13,4 +13,6 @@ GFXSRC +=   $(GFXLIB)/src/gwin/gwin.c \
 			$(GFXLIB)/src/gwin/progressbar.c \
 			$(GFXLIB)/src/gwin/gcontainer.c \
 			$(GFXLIB)/src/gwin/frame.c \
+			$(GFXLIB)/src/gwin/gwin_gl3d.c \
 
+GFXINC +=	$(GFXLIB)/3rdparty/tinygl-0.4-ugfx/include	

src/gwin/sys_options.h

@@ -72,6 +72,13 @@
 	#ifndef GWIN_NEED_GRAPH
 		#define GWIN_NEED_GRAPH		FALSE
 	#endif
+	/**
+	 * @brief   Should gl3d functions be included.
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GWIN_NEED_GL3D
+		#define GWIN_NEED_GL3D		FALSE
+	#endif
 	/**
 	 * @brief   Should button functions be included.
 	 * @details	Defaults to FALSE