* Test stuff for the Rubik's cube colour reduction.

git-svn-id: file:///srv/caca.zoy.org/var/lib/svn/research@2677 92316355-f0b4-4df1-b90c-862c8a59935f

2008-rubik/.gitignore

@@ -0,0 +1,2 @@
+*.o
+colorcube/visu

2008-rubik/colorcube/Makefile

@@ -0,0 +1,4 @@
+
+visu: visu.c tb.c trackball.c
+	$(CC) $^ -o $@ -lGL -lglut
+

2008-rubik/colorcube/tb.c

@@ -0,0 +1,123 @@
+/*
+ *  Simple trackball-like motion adapted (ripped off) from projtex.c
+ *  (written by David Yu and David Blythe).  See the SIGGRAPH '96
+ *  Advanced OpenGL course notes.
+ */
+
+#include <math.h>
+#include <assert.h>
+
+#include <GL/glut.h>
+
+#include "tb.h"
+#include "trackball.h"
+
+/* globals */
+static GLuint    tb_lasttime;
+
+float curquat[4];
+float lastquat[4];
+int beginx, beginy;
+
+static GLuint    tb_width;
+static GLuint    tb_height;
+
+static GLint     tb_button = -1;
+static GLboolean tb_tracking = GL_FALSE;
+static GLboolean tb_animate = GL_TRUE;
+
+static void
+_tbAnimate(void)
+{
+  add_quats(lastquat, curquat, curquat);
+  glutPostRedisplay();
+}
+
+static void
+_tbStartMotion(int x, int y, int time)
+{
+  assert(tb_button != -1);
+
+  glutIdleFunc(0);
+  tb_tracking = GL_TRUE;
+  tb_lasttime = time;
+  beginx = x;
+  beginy = y;
+}
+
+static void
+_tbStopMotion(unsigned time)
+{
+  assert(tb_button != -1);
+
+  tb_tracking = GL_FALSE;
+
+  if (time == tb_lasttime && tb_animate) {
+    glutIdleFunc(_tbAnimate);
+  } else {
+    if (tb_animate) {
+      glutIdleFunc(0);
+    }
+  }
+}
+
+void
+tbAnimate(GLboolean animate)
+{
+  tb_animate = animate;
+}
+
+void
+tbInit(GLuint button)
+{
+  tb_button = button;
+  trackball(curquat, 0.0, 0.0, 0.0, 0.0);
+}
+
+void
+tbMatrix(void)
+{
+  GLfloat m[4][4];
+
+  assert(tb_button != -1);
+  build_rotmatrix(m, curquat);
+  glMultMatrixf(&m[0][0]);
+}
+
+void
+tbReshape(int width, int height)
+{
+  assert(tb_button != -1);
+
+  tb_width  = width;
+  tb_height = height;
+}
+
+void
+tbMouse(int button, int state, int x, int y)
+{
+  assert(tb_button != -1);
+
+  if (state == GLUT_DOWN && button == tb_button)
+    _tbStartMotion(x, y, glutGet(GLUT_ELAPSED_TIME));
+  else if (state == GLUT_UP && button == tb_button)
+    _tbStopMotion(glutGet(GLUT_ELAPSED_TIME));
+}
+
+void
+tbMotion(int x, int y)
+{
+  if (tb_tracking) {
+    trackball(lastquat,
+      (2.0 * beginx - tb_width) / tb_width,
+      (tb_height - 2.0 * beginy) / tb_height,
+      (2.0 * x - tb_width) / tb_width,
+      (tb_height - 2.0 * y) / tb_height
+      );
+    beginx = x;
+    beginy = y;
+    tb_animate = 1;
+    tb_lasttime = glutGet(GLUT_ELAPSED_TIME);
+    _tbAnimate();
+  }
+}

2008-rubik/colorcube/tb.h

@@ -0,0 +1,103 @@
+/* 
+ *  Simple trackball-like motion adapted (ripped off) from projtex.c
+ *  (written by David Yu and David Blythe).  See the SIGGRAPH '96
+ *  Advanced OpenGL course notes.
+ *
+ *
+ *  Usage:
+ *  
+ *  o  call tbInit() in before any other tb call
+ *  o  call tbReshape() from the reshape callback
+ *  o  call tbMatrix() to get the trackball matrix rotation
+ *  o  call tbStartMotion() to begin trackball movememt
+ *  o  call tbStopMotion() to stop trackball movememt
+ *  o  call tbMotion() from the motion callback
+ *  o  call tbAnimate(GL_TRUE) if you want the trackball to continue 
+ *     spinning after the mouse button has been released
+ *  o  call tbAnimate(GL_FALSE) if you want the trackball to stop 
+ *     spinning after the mouse button has been released
+ *
+ *  Typical setup:
+ *
+ *
+    void
+    init(void)
+    {
+      tbInit(GLUT_MIDDLE_BUTTON);
+      tbAnimate(GL_TRUE);
+      . . .
+    }
+
+    void
+    reshape(int width, int height)
+    {
+      tbReshape(width, height);
+      . . .
+    }
+
+    void
+    display(void)
+    {
+      glPushMatrix();
+
+      tbMatrix();
+      . . . draw the scene . . .
+
+      glPopMatrix();
+    }
+
+    void
+    mouse(int button, int state, int x, int y)
+    {
+      tbMouse(button, state, x, y);
+      . . .
+    }
+
+    void
+    motion(int x, int y)
+    {
+      tbMotion(x, y);
+      . . .
+    }
+
+    int
+    main(int argc, char** argv)
+    {
+      . . .
+      init();
+      glutReshapeFunc(reshape);
+      glutDisplayFunc(display);
+      glutMouseFunc(mouse);
+      glutMotionFunc(motion);
+      . . .
+    }
+ *
+ * */
+
+
+/* functions */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+tbInit(GLuint button);
+
+void
+tbMatrix(void);
+
+void
+tbReshape(int width, int height);
+
+void
+tbMouse(int button, int state, int x, int y);
+
+void
+tbMotion(int x, int y);
+
+void
+tbAnimate(GLboolean animate);
+
+#ifdef __cplusplus
+}
+#endif

2008-rubik/colorcube/trackball.c

@@ -0,0 +1,325 @@
+/*
+ * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
+ * ALL RIGHTS RESERVED
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose and without fee is hereby granted, provided that the above
+ * copyright notice appear in all copies and that both the copyright notice
+ * and this permission notice appear in supporting documentation, and that
+ * the name of Silicon Graphics, Inc. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
+ * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
+ * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
+ * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
+ * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
+ * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
+ * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
+ * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
+ * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer Software
+ * clause at DFARS 252.227-7013 and/or in similar or successor
+ * clauses in the FAR or the DOD or NASA FAR Supplement.
+ * Unpublished-- rights reserved under the copyright laws of the
+ * United States.  Contractor/manufacturer is Silicon Graphics,
+ * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+
+/*
+ * Trackball code:
+ *
+ * Implementation of a virtual trackball.
+ * Implemented by Gavin Bell, lots of ideas from Thant Tessman and
+ *   the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.
+ *
+ * Vector manip code:
+ *
+ * Original code from:
+ * David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli
+ *
+ * Much mucking with by:
+ * Gavin Bell
+ */
+#include <math.h>
+#include "trackball.h"
+
+/*
+ * This size should really be based on the distance from the center of
+ * rotation to the point on the object underneath the mouse.  That
+ * point would then track the mouse as closely as possible.  This is a
+ * simple example, though, so that is left as an Exercise for the
+ * Programmer.
+ */
+#define TRACKBALLSIZE  (0.4f)
+
+/*
+ * Local function prototypes (not defined in trackball.h)
+ */
+static float tb_project_to_sphere(float, float, float);
+static void normalize_quat(float [4]);
+
+static void
+vzero(float *v)
+{
+    v[0] = 0.0;
+    v[1] = 0.0;
+    v[2] = 0.0;
+}
+
+static void
+vset(float *v, float x, float y, float z)
+{
+    v[0] = x;
+    v[1] = y;
+    v[2] = z;
+}
+
+static void
+vsub(const float *src1, const float *src2, float *dst)
+{
+    dst[0] = src1[0] - src2[0];
+    dst[1] = src1[1] - src2[1];
+    dst[2] = src1[2] - src2[2];
+}
+
+static void
+vcopy(const float *v1, float *v2)
+{
+    register int i;
+    for (i = 0 ; i < 3 ; i++)
+        v2[i] = v1[i];
+}
+
+static void
+vcross(const float *v1, const float *v2, float *cross)
+{
+    float temp[3];
+
+    temp[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]);
+    temp[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]);
+    temp[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]);
+    vcopy(temp, cross);
+}
+
+static float
+vlength(const float *v)
+{
+    return sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+
+static void
+vscale(float *v, float div)
+{
+    v[0] *= div;
+    v[1] *= div;
+    v[2] *= div;
+}
+
+static void
+vnormal(float *v)
+{
+    vscale(v,1.0f/vlength(v));
+}
+
+static float
+vdot(const float *v1, const float *v2)
+{
+    return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+}
+
+static void
+vadd(const float *src1, const float *src2, float *dst)
+{
+    dst[0] = src1[0] + src2[0];
+    dst[1] = src1[1] + src2[1];
+    dst[2] = src1[2] + src2[2];
+}
+
+/*
+ * Ok, simulate a track-ball.  Project the points onto the virtual
+ * trackball, then figure out the axis of rotation, which is the cross
+ * product of P1 P2 and O P1 (O is the center of the ball, 0,0,0)
+ * Note:  This is a deformed trackball-- is a trackball in the center,
+ * but is deformed into a hyperbolic sheet of rotation away from the
+ * center.  This particular function was chosen after trying out
+ * several variations.
+ *
+ * It is assumed that the arguments to this routine are in the range
+ * (-1.0 ... 1.0)
+ */
+void
+trackball(float q[4], float p1x, float p1y, float p2x, float p2y)
+{
+    float a[3]; /* Axis of rotation */
+    float phi;  /* how much to rotate about axis */
+    float p1[3], p2[3], d[3];
+    float t;
+
+    if (p1x == p2x && p1y == p2y) {
+        /* Zero rotation */
+        vzero(q);
+        q[3] = 1.0;
+        return;
+    }
+
+    /*
+     * First, figure out z-coordinates for projection of P1 and P2 to
+     * deformed sphere
+     */
+    vset(p1,p1x,p1y,tb_project_to_sphere(TRACKBALLSIZE,p1x,p1y));
+    vset(p2,p2x,p2y,tb_project_to_sphere(TRACKBALLSIZE,p2x,p2y));
+
+    /*
+     *  Now, we want the cross product of P1 and P2
+     */
+    vcross(p2,p1,a);
+
+    /*
+     *  Figure out how much to rotate around that axis.
+     */
+    vsub(p1,p2,d);
+    t = vlength(d) / (2.0f*TRACKBALLSIZE);
+
+    /*
+     * Avoid problems with out-of-control values...
+     */
+    if (t > 1.0f) t = 1.0f;
+    if (t < -1.0f) t = -1.0f;
+    phi = 2.0f * asin(t);
+
+    axis_to_quat(a,phi,q);
+}
+
+/*
+ *  Given an axis and angle, compute quaternion.
+ */
+void
+axis_to_quat(float a[3], float phi, float q[4])
+{
+    vnormal(a);
+    vcopy(a,q);
+    vscale(q,sin(phi/2.0f));
+    q[3] = cos(phi/2.0f);
+}
+
+/*
+ * Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
+ * if we are away from the center of the sphere.
+ */
+static float
+tb_project_to_sphere(float r, float x, float y)
+{
+    float d, t, z;
+
+    d = sqrt(x*x + y*y);
+    if (d < r * 0.70710678118654752440f) {    /* Inside sphere */
+        z = sqrt(r*r - d*d);
+    } else {           /* On hyperbola */
+        t = r / 1.41421356237309504880f;
+        z = t*t / d;
+    }
+    return z;
+}
+
+/*
+ * Given two rotations, e1 and e2, expressed as quaternion rotations,
+ * figure out the equivalent single rotation and stuff it into dest.
+ *
+ * This routine also normalizes the result every RENORMCOUNT times it is
+ * called, to keep error from creeping in.
+ *
+ * NOTE: This routine is written so that q1 or q2 may be the same
+ * as dest (or each other).
+ */
+
+#define RENORMCOUNT 97
+
+void
+add_quats(float q1[4], float q2[4], float dest[4])
+{
+    static int count=0;
+    float t1[4], t2[4], t3[4];
+    float tf[4];
+
+    vcopy(q1,t1);
+    vscale(t1,q2[3]);
+
+    vcopy(q2,t2);
+    vscale(t2,q1[3]);
+
+    vcross(q2,q1,t3);
+    vadd(t1,t2,tf);
+    vadd(t3,tf,tf);
+    tf[3] = q1[3] * q2[3] - vdot(q1,q2);
+
+    dest[0] = tf[0];
+    dest[1] = tf[1];
+    dest[2] = tf[2];
+    dest[3] = tf[3];
+
+    if (++count > RENORMCOUNT) {
+        count = 0;
+        normalize_quat(dest);
+    }
+}
+
+/*
+ * Quaternions always obey:  a^2 + b^2 + c^2 + d^2 = 1.0
+ * If they don't add up to 1.0, dividing by their magnitued will
+ * renormalize them.
+ *
+ * Note: See the following for more information on quaternions:
+ *
+ * - Shoemake, K., Animating rotation with quaternion curves, Computer
+ *   Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985.
+ * - Pletinckx, D., Quaternion calculus as a basic tool in computer
+ *   graphics, The Visual Computer 5, 2-13, 1989.
+ */
+static void
+normalize_quat(float q[4])
+{
+    int i;
+    float mag;
+
+    mag = (q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+    for (i = 0; i < 4; i++) q[i] /= mag;
+}
+
+/*
+ * Build a rotation matrix, given a quaternion rotation.
+ *
+ */
+void
+build_rotmatrix(float m[4][4], float q[4])
+{
+    m[0][0] = 1.0f - 2.0f * (q[1] * q[1] + q[2] * q[2]);
+    m[0][1] = 2.0f * (q[0] * q[1] - q[2] * q[3]);
+    m[0][2] = 2.0f * (q[2] * q[0] + q[1] * q[3]);
+    m[0][3] = 0.0f;
+
+    m[1][0] = 2.0f * (q[0] * q[1] + q[2] * q[3]);
+    m[1][1]= 1.0f - 2.0f * (q[2] * q[2] + q[0] * q[0]);
+    m[1][2] = 2.0f * (q[1] * q[2] - q[0] * q[3]);
+    m[1][3] = 0.0f;
+
+    m[2][0] = 2.0f * (q[2] * q[0] - q[1] * q[3]);
+    m[2][1] = 2.0f * (q[1] * q[2] + q[0] * q[3]);
+    m[2][2] = 1.0f - 2.0f * (q[1] * q[1] + q[0] * q[0]);
+    m[2][3] = 0.0f;
+
+    m[3][0] = 0.0f;
+    m[3][1] = 0.0f;
+    m[3][2] = 0.0f;
+    m[3][3] = 1.0f;
+}
+

2008-rubik/colorcube/trackball.h

@@ -0,0 +1,85 @@
+/*
+ * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
+ * ALL RIGHTS RESERVED
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose and without fee is hereby granted, provided that the above
+ * copyright notice appear in all copies and that both the copyright notice
+ * and this permission notice appear in supporting documentation, and that
+ * the name of Silicon Graphics, Inc. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.
+ *
+ * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
+ * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
+ * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
+ * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
+ * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
+ * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
+ * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
+ * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
+ * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
+ * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * US Government Users Restricted Rights
+ * Use, duplication, or disclosure by the Government is subject to
+ * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+ * (c)(1)(ii) of the Rights in Technical Data and Computer Software
+ * clause at DFARS 252.227-7013 and/or in similar or successor
+ * clauses in the FAR or the DOD or NASA FAR Supplement.
+ * Unpublished-- rights reserved under the copyright laws of the
+ * United States.  Contractor/manufacturer is Silicon Graphics,
+ * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
+ *
+ * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+ */
+/*
+ * trackball.h
+ * A virtual trackball implementation
+ * Written by Gavin Bell for Silicon Graphics, November 1988.
+ */
+
+#ifdef __cpluscplus
+extern "C" {
+#endif
+
+/*
+ * Pass the x and y coordinates of the last and current positions of
+ * the mouse, scaled so they are from (-1.0 ... 1.0).
+ *
+ * The resulting rotation is returned as a quaternion rotation in the
+ * first paramater.
+ */
+void
+trackball(float q[4], float p1x, float p1y, float p2x, float p2y);
+
+/*
+ * Given two quaternions, add them together to get a third quaternion.
+ * Adding quaternions to get a compound rotation is analagous to adding
+ * translations to get a compound translation.  When incrementally
+ * adding rotations, the first argument here should be the new
+ * rotation, the second and third the total rotation (which will be
+ * over-written with the resulting new total rotation).
+ */
+void
+add_quats(float *q1, float *q2, float *dest);
+
+/*
+ * A useful function, builds a rotation matrix in Matrix based on
+ * given quaternion.
+ */
+void
+build_rotmatrix(float m[4][4], float q[4]);
+
+/*
+ * This function computes a quaternion based on an axis (defined by
+ * the given vector) and an angle about which to rotate.  The angle is
+ * expressed in radians.  The result is put into the third argument.
+ */
+void
+axis_to_quat(float a[3], float phi, float q[4]);
+
+#ifdef __cpluscplus
+}
+#endif

2008-rubik/colorcube/visu.c

@@ -0,0 +1,153 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <GL/gl.h>
+#include <GL/glut.h>
+
+#include "tb.h"
+
+int w_win = 640;
+int h_win = 480;
+
+static void setcamera(void)
+{
+    glMatrixMode (GL_PROJECTION);
+    glLoadIdentity ();
+    gluPerspective(40, (float)w_win / (float)h_win, 1, 1000);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    gluLookAt(0.0, 0.0, (float)h_win / 200.0f, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+}
+
+static void myinit(void)
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glClearColor(0.5, 0.5, 0.7, 0.0);
+    glColor3f(1.0, 1.0, 1.0);
+
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_DEPTH_TEST);
+    glShadeModel(GL_SMOOTH);
+
+    setcamera();
+
+    tbInit(GLUT_LEFT_BUTTON);
+    tbAnimate(GL_FALSE);
+}
+
+static void parsekey(unsigned char key, int x, int y)
+{
+    switch (key)
+    {
+    case 27:
+        exit(0);
+        break;
+    }
+}
+
+static void motion(int x, int y)
+{
+    tbMotion(x, y);
+}
+
+static void mouse(int button, int state, int x, int y)
+{
+    tbMouse(button, state, x, y);
+}
+
+static void reshape(int w, int h)
+{
+    glMatrixMode (GL_MODELVIEW);
+    glViewport (0, 0, w, h);
+    glLoadIdentity();
+
+    w_win = w;
+    h_win = h;
+    setcamera();
+
+    tbReshape(w_win, h_win);
+}
+
+#define F(x) ((x)*1.01 - 0.005)
+#define CP       glColor4f(x0,y0,z0,0.5); glVertex3f(y0,x0,z0)
+#define BP       glColor3f(0.0,0.0,0.0); glVertex3f(F(y0),F(x0),F(z0))
+#define BLACK    x0 = y0 = z0 = 0.0
+#define RED      x0 = 1.0; y0 = z0 = 0.0
+//#define XRED     x0 = 0.8; y0 = z0 = 0.0
+#define XRED RED
+#define GREEN    y0 = 1.0; x0 = z0 = 0.0
+//#define XGREEN   y0 = 0.7; x0 = z0 = 0.0
+#define XGREEN GREEN
+#define BLUE     z0 = 1.0; x0 = y0 = 0.0
+//#define XBLUE    x0 = 0.0; y0 = 0.0; z0 = 0.5
+#define XBLUE BLUE
+#define YELLOW   x0 = y0 = 1.0; z0 = 0.0
+#define CYAN     y0 = z0 = 1.0; x0 = 0.0
+#define MAGENTA  x0 = z0 = 1.0; y0 = 0.0
+#define WHITE    x0 = y0 = z0 = 1.0
+
+static void display(void)
+{
+    float x0,y0,z0;
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    setcamera();
+
+    tbMatrix();
+
+    glPushMatrix();
+        glTranslatef(-.5, -.5, -.5);
+        // Bounding box
+        glBegin(GL_LINE_LOOP);
+            BLACK; CP; RED; CP; MAGENTA; CP; BLUE; CP;
+            CYAN; CP; WHITE; CP; YELLOW; CP; GREEN; CP;
+        glEnd();
+        glBegin(GL_LINES);
+            BLACK; CP; BLUE; CP;
+            GREEN; CP; CYAN; CP;
+            RED; CP; YELLOW; CP;
+            MAGENTA; CP; WHITE; CP;
+        glEnd();
+        // Our colour space
+        glBegin(GL_TRIANGLES); XRED; CP; XGREEN; CP; XBLUE; CP; glEnd();
+        glBegin(GL_TRIANGLES); XRED; CP; XGREEN; CP; YELLOW; CP; glEnd();
+        glBegin(GL_TRIANGLES); XRED; CP; XBLUE; CP; WHITE; CP; glEnd();
+        glBegin(GL_TRIANGLES); XRED; CP; YELLOW; CP; WHITE; CP; glEnd();
+        glBegin(GL_TRIANGLES); XBLUE; CP; XGREEN; CP; WHITE; CP; glEnd();
+        glBegin(GL_TRIANGLES); YELLOW; CP; XGREEN; CP; WHITE; CP; glEnd();
+        // Better edges
+        glBegin(GL_LINES);
+            XBLUE; BP; XRED; BP; YELLOW; BP; XRED; BP;
+            XBLUE; BP; XGREEN; BP; YELLOW; BP; XGREEN; BP;
+            XBLUE; BP; WHITE; BP; YELLOW; BP; WHITE; BP;
+            XRED; BP; XGREEN; BP;
+            XGREEN; BP; WHITE; BP;
+            WHITE; BP; XRED; BP;
+        glEnd();
+    glPopMatrix();
+
+    glutSwapBuffers();
+}
+
+int main(int argc, char *argv[])
+{
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE | GLUT_MULTISAMPLE);
+    glutInitWindowPosition(50, 50);
+    glutInitWindowSize(w_win, h_win);
+    glutCreateWindow("FTGL TEST");
+    glutDisplayFunc(display);
+    glutKeyboardFunc(parsekey);
+    glutMouseFunc(mouse);
+    glutMotionFunc(motion);
+    glutReshapeFunc(reshape);
+    glutIdleFunc(display);
+
+    myinit();
+    glutMainLoop();
+
+    return 0;
+}
+