libgender/util.C

/*
 * math support
 * most of the more complicated code is taken from mesa.
 */

#include <cstdio> // ugly
#include <cstring>
#include <cmath>

#include <sys/time.h>
#include <time.h>

#include "opengl.h"

#include "util.h"
#include "entity.h"

#define DEG2RAD (M_PI / 180.)

void renormalize (sector &s, point &p)
{
  float i;

  p.x = modff (p.x, &i); s.x += (soffs)i;
  p.y = modff (p.y, &i); s.y += (soffs)i;
  p.z = modff (p.z, &i); s.z += (soffs)i;
}

/////////////////////////////////////////////////////////////////////////////

const vec3 normalize (const vec3 &v)
{
  GLfloat s = length (v);

  if (!s)
    return v;

  s = 1. / s;
  return vec3 (v.x * s, v.y * s, v.z * s);
}

const vec3 cross (const vec3 &a, const vec3 &b)
{
  return vec3 (
     a.y * b.z - a.z * b.y,
     a.z * b.x - a.x * b.z,
     a.x * b.y - a.y * b.x
  );
}

/////////////////////////////////////////////////////////////////////////////

plane::plane (GLfloat a, GLfloat b, GLfloat c, GLfloat d)
: n (vec3 (a,b,c))
{
  GLfloat s = 1. / length (n);

  n = n * s;
  this->d = d * s;
}

/////////////////////////////////////////////////////////////////////////////

void box::add (const box &o)
{
  a.x = min (a.x, o.a.x);
  a.y = min (a.y, o.a.y);
  a.z = min (a.z, o.a.z);
  b.x = max (b.x, o.b.x);
  b.y = max (b.y, o.b.y);
  b.z = max (b.z, o.b.z);
}

void box::add (const point &p)
{
  a.x = min (a.x, p.x);
  a.y = min (a.y, p.y);
  a.z = min (a.z, p.z);
  b.x = max (b.x, p.x);
  b.y = max (b.y, p.y);
  b.z = max (b.z, p.z);
}

/////////////////////////////////////////////////////////////////////////////

struct timer timer;
static double base;
double timer::now = 0.;
double timer::diff;
double timer::fps = 1.;
//double min_frame = 1. / 85.;
double min_frame = 1. / 1000.;

void timer::frame ()
{
  struct timeval tv;
  double next;

  gettimeofday (&tv, 0);

  next = tv.tv_sec - base + tv.tv_usec / 1.e6;
  diff = next - now;

  fps = fps * 0.96 + (1. / diff) * 0.04;

  if (diff < min_frame)
    {
      SDL_Delay ((unsigned int)((min_frame - diff) * 1000.));

      gettimeofday (&tv, 0);

      next = tv.tv_sec - base + tv.tv_usec / 1.e6;
      diff = next - now;
    }

  now = next;
}

timer::timer ()
{
  struct timeval tv;
  gettimeofday (&tv, 0);
  base = tv.tv_sec + tv.tv_usec / 1.e6;
}

void render_text (GLint x, GLint y, const char *str)
{
  glRasterPos2i (x, y);

#if 0
  while (!*str)
    glutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, *str++);
#endif
}

namespace gl {

  void matrix::diagonal (GLfloat v)
  {
    for (int i = 4; i--; )
      for (int j = 4; j--; )
        data[i][j] = i == j ? v : 0.;
  }

  matrix operator *(const matrix &a, const matrix &b)
  {
    matrix r;

    // taken from mesa
    for (int i = 0; i < 4; i++)
      {
        const GLfloat ai0=a(i,0), ai1=a(i,1), ai2=a(i,2), ai3=a(i,3);

        r(i,0) = ai0 * b(0,0) + ai1 * b(1,0) + ai2 * b(2,0) + ai3 * b(3,0);
        r(i,1) = ai0 * b(0,1) + ai1 * b(1,1) + ai2 * b(2,1) + ai3 * b(3,1);
        r(i,2) = ai0 * b(0,2) + ai1 * b(1,2) + ai2 * b(2,2) + ai3 * b(3,2);
        r(i,3) = ai0 * b(0,3) + ai1 * b(1,3) + ai2 * b(2,3) + ai3 * b(3,3);
      }

    return r;
  }

  matrix matrix::rotation (GLfloat angle, const vec3 &axis)
  {
    GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;

    s = (GLfloat) sinf (angle * DEG2RAD);
    c = (GLfloat) cosf (angle * DEG2RAD);

    const GLfloat mag = length (axis);

    if (mag <= 1.0e-4)
      return matrix (1);

    matrix m;
    const vec3 n = axis * (1. / mag);

    xx = n.x * n.x;
    yy = n.y * n.y;
    zz = n.z * n.z;
    xy = n.x * n.y;
    yz = n.y * n.z;
    zx = n.z * n.x;
    xs = n.x * s;
    ys = n.y * s;
    zs = n.z * s;
    one_c = 1.0F - c;

    m(0,0) = (one_c * xx) + c;
    m(0,1) = (one_c * xy) - zs;
    m(0,2) = (one_c * zx) + ys;
    m(0,3) = 0;
    
    m(1,0) = (one_c * xy) + zs;
    m(1,1) = (one_c * yy) + c;
    m(1,2) = (one_c * yz) - xs;
    m(1,3) = 0;
    
    m(2,0) = (one_c * zx) - ys;
    m(2,1) = (one_c * yz) + xs;
    m(2,2) = (one_c * zz) + c;
    m(2,3) = 0;
    
    m(3,0) = 0;
    m(3,1) = 0;
    m(3,2) = 0;
    m(3,3) = 1;

    return m;
  }

  matrix matrix::translation (const vec3 &v)
  {
    matrix m(1);

    m(0,3) = v.x;
    m(1,3) = v.y;
    m(2,3) = v.z;

    return m;
  }

  matrix matrix::scaling (GLfloat sx, GLfloat sy, GLfloat sz, GLfloat sw)
  {
    matrix m (1.F);

    m(0,0) = sx;
    m(1,1) = sy;
    m(2,2) = sz;
    m(3,3) = sw;

    return m;
  }

  vec3 operator *(const matrix &a, const vec3 &v)
  {
    return vec3 (
      a(0,0) * v.x + a(0,1) * v.y + a(0,2) * v.z + a(0,3),
      a(1,0) * v.x + a(1,1) * v.y + a(1,2) * v.z + a(1,3),
      a(2,0) * v.x + a(2,1) * v.y + a(2,2) * v.z + a(2,3)
    );
  }

  void matrix::print ()
  {
    printf ("\n");
    printf ("[ %f, %f, %f, %f ]\n", data[0][0], data[1][0], data[2][0], data[3][0]);
    printf ("[ %f, %f, %f, %f ]\n", data[0][1], data[1][1], data[2][1], data[3][1]);
    printf ("[ %f, %f, %f, %f ]\n", data[0][2], data[1][2], data[2][2], data[3][2]);
    printf ("[ %f, %f, %f, %f ]\n", data[0][3], data[1][3], data[2][3], data[3][3]);
  }

  /////////////////////////////////////////////////////////////////////////////

  void draw_bbox (const sector &a, const sector &b)
  {
    static vertex_buffer vb;
    static index_buffer ib;

    vertex_v3f vd[] = {
       point (a.x, a.y, a.z),
       point (b.x, a.y, a.z),
       point (a.x, b.y, a.z),
       point (b.x, b.y, a.z),
       point (a.x, a.y, b.z),
       point (b.x, a.y, b.z),
       point (a.x, b.y, b.z),
       point (b.x, b.y, b.z),
    };

    if (!ib)
      {
        static GLushort verts[4*6] = {
           0, 4, 6, 2,  // -x
           1, 3, 7, 5,  // +x
           0, 1, 5, 4,  // -y
           7, 3, 2, 6,  // +y
           0, 2, 3, 1,  // -z
           4, 5, 7, 6,  // +z
        };

        ib.set (verts, 4*6, GL_STATIC_DRAW_ARB);
      }

    vb.set (vd, 8, GL_STREAM_DRAW_ARB);
    vb.bind ();
    ib.draw (GL_QUADS, 0, 4*6);
  }

  /////////////////////////////////////////////////////////////////////////////

  GLsizei format_stride (GLenum format)
  {
    switch (format)
      {
        case GL_V2F:                    abort ();
        case GL_V3F:                    return sizeof (vertex_v3f);
        case GL_C4UB_V2F:               abort ();
        case GL_C4UB_V3F:               abort ();
        case GL_C3F_V3F:                abort ();
        case GL_N3F_V3F:                abort ();
        case GL_C4F_N3F_V3F:            abort ();
        case GL_T2F_V3F:                abort ();
        case GL_T4F_V4F:                abort ();
        case GL_T2F_C4UB_V3F:           abort ();
        case GL_T2F_C3F_V3F:            abort ();
        case GL_T2F_N3F_V3F:            return sizeof (vertex_t2f_n3f_v3f);
        case GL_T2F_C4F_N3F_V3F:        abort ();
        case GL_T4F_C4F_N3F_V4F:        abort ();
        default:
          abort ();
      }
  }
 
  GLsizei format_offset_p (GLenum format)
  {
    switch (format)
      {
        case GL_V2F:                    abort ();
        case GL_V3F:                    { vertex_v3f v; return (char *)&v.v - (char *)&v; }
        case GL_C4UB_V2F:               abort ();
        case GL_C4UB_V3F:               abort ();
        case GL_C3F_V3F:                abort ();
        case GL_N3F_V3F:                abort ();
        case GL_C4F_N3F_V3F:            abort ();
        case GL_T2F_V3F:                abort ();
        case GL_T4F_V4F:                abort ();
        case GL_T2F_C4UB_V3F:           abort ();
        case GL_T2F_C3F_V3F:            abort ();
        case GL_T2F_N3F_V3F:            { vertex_t2f_n3f_v3f v; return (char *)&v.v - (char *)&v; }
        case GL_T2F_C4F_N3F_V3F:        abort ();
        case GL_T4F_C4F_N3F_V4F:        abort ();
        default:
          abort ();
      }
  }

  GLsizei format_offset_n (GLenum format)
  {
    switch (format)
      {
        case GL_V2F:                    abort ();
        case GL_V3F:                    abort ();
        case GL_C4UB_V2F:               abort ();
        case GL_C4UB_V3F:               abort ();
        case GL_C3F_V3F:                abort ();
        case GL_N3F_V3F:                abort ();
        case GL_C4F_N3F_V3F:            abort ();
        case GL_T2F_V3F:                abort ();
        case GL_T4F_V4F:                abort ();
        case GL_T2F_C4UB_V3F:           abort ();
        case GL_T2F_C3F_V3F:            abort ();
        case GL_T2F_N3F_V3F:            { vertex_t2f_n3f_v3f v; return (char *)&v.n - (char *)&v; }
        case GL_T2F_C4F_N3F_V3F:        abort ();
        case GL_T4F_C4F_N3F_V4F:        abort ();
        default:
          abort ();
      }
  }

  GLsizei format_offset_t (GLenum format)
  {
    switch (format)
      {
        case GL_V2F:                    abort ();
        case GL_V3F:                    abort ();
        case GL_C4UB_V2F:               abort ();
        case GL_C4UB_V3F:               abort ();
        case GL_C3F_V3F:                abort ();
        case GL_N3F_V3F:                abort ();
        case GL_C4F_N3F_V3F:            abort ();
        case GL_T2F_V3F:                abort ();
        case GL_T4F_V4F:                abort ();
        case GL_T2F_C4UB_V3F:           abort ();
        case GL_T2F_C3F_V3F:            abort ();
        case GL_T2F_N3F_V3F:            { vertex_t2f_n3f_v3f v; return (char *)&v.t - (char *)&v; }
        case GL_T2F_C4F_N3F_V3F:        abort ();
        case GL_T4F_C4F_N3F_V4F:        abort ();
        default:
          abort ();
      }
  }

  /////////////////////////////////////////////////////////////////////////////

  int nesting;

  void errchk (const char *name, const char *args, const char *file, int line)
  {
    static int inbegin;

    if (name[2] == 'B' && !strcmp (name, "glBegin"))
      inbegin = 1;
    else if (name[2] == 'E' && !strcmp (name, "glEnd"))
      inbegin = 0;

    if (inbegin)
      return;

    GLenum gl_derror = glGetError ();
    if (gl_derror != GL_NO_ERROR)
      {
        fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
                 file, line, gl_derror, gluErrorString (gl_derror), name, args);
        abort ();
      }
  }

}

template<typename idtype>
idpool<idtype>::idpool ()
: next (0)
{
}

template<typename idtype>
idtype idpool<idtype>::get ()
{
  idtype ret;

  if (free.size ())
    {
      ret = *(free.end () - 1);
      //freeid.pop_back ();
    }
  else
    ret = ++next;

  return ret;
}

template<typename idtype>
void idpool<idtype>::put (idtype &i)
{
  free.push_back (i);
}
Revision:	1.50
Committed:	Thu Aug 11 20:21:03 2005 UTC (18 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.49:	+1 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.3	/*
2			* math support
3			* most of the more complicated code is taken from mesa.
4			*/
5
6	root	1.2	#include <cstdio> // ugly
7	root	1.25	#include <cstring>
8	root	1.1	#include <cmath>
9
10	root	1.4	#include <sys/time.h>
11			#include <time.h>
12	root	1.20
13	root	1.27	#include "opengl.h"
14	root	1.2
15	root	1.1	#include "util.h"
16	root	1.15	#include "entity.h"
17	root	1.1
18	root	1.3	#define DEG2RAD (M_PI / 180.)
19
20	root	1.6	void renormalize (sector &s, point &p)
21			{
22			float i;
23
24	root	1.11	p.x = modff (p.x, &i); s.x += (soffs)i;
25			p.y = modff (p.y, &i); s.y += (soffs)i;
26			p.z = modff (p.z, &i); s.z += (soffs)i;
27	root	1.6	}
28
29	root	1.7	/////////////////////////////////////////////////////////////////////////////
30
31	root	1.1	const vec3 normalize (const vec3 &v)
32			{
33	root	1.37	GLfloat s = length (v);
34	root	1.3
35			if (!s)
36			return v;
37	root	1.1
38	root	1.3	s = 1. / s;
39	root	1.1	return vec3 (v.x * s, v.y * s, v.z * s);
40			}
41
42			const vec3 cross (const vec3 &a, const vec3 &b)
43			{
44			return vec3 (
45	root	1.3	a.y * b.z - a.z * b.y,
46			a.z * b.x - a.x * b.z,
47			a.x * b.y - a.y * b.x
48			);
49	root	1.2	}
50
51	root	1.7	/////////////////////////////////////////////////////////////////////////////
52
53			plane::plane (GLfloat a, GLfloat b, GLfloat c, GLfloat d)
54	root	1.9	: n (vec3 (a,b,c))
55	root	1.7	{
56	root	1.37	GLfloat s = 1. / length (n);
57	root	1.7
58			n = n * s;
59	root	1.9	this->d = d * s;
60	root	1.7	}
61
62			/////////////////////////////////////////////////////////////////////////////
63
64	root	1.1	void box::add (const box &o)
65			{
66			a.x = min (a.x, o.a.x);
67			a.y = min (a.y, o.a.y);
68			a.z = min (a.z, o.a.z);
69			b.x = max (b.x, o.b.x);
70			b.y = max (b.y, o.b.y);
71			b.z = max (b.z, o.b.z);
72			}
73
74	root	1.19	void box::add (const point &p)
75	root	1.1	{
76			a.x = min (a.x, p.x);
77			a.y = min (a.y, p.y);
78			a.z = min (a.z, p.z);
79			b.x = max (b.x, p.x);
80			b.y = max (b.y, p.y);
81			b.z = max (b.z, p.z);
82	root	1.5	}
83
84	root	1.7	/////////////////////////////////////////////////////////////////////////////
85	root	1.4
86			struct timer timer;
87			static double base;
88			double timer::now = 0.;
89			double timer::diff;
90	root	1.41	double timer::fps = 1.;
91	root	1.44	//double min_frame = 1. / 85.;
92	root	1.50	double min_frame = 1. / 1000.;
93	root	1.4
94			void timer::frame ()
95			{
96			struct timeval tv;
97	root	1.23	double next;
98	root	1.4
99	root	1.34	gettimeofday (&tv, 0);
100
101			next = tv.tv_sec - base + tv.tv_usec / 1.e6;
102			diff = next - now;
103
104	root	1.45	fps = fps * 0.96 + (1. / diff) * 0.04;
105	root	1.34
106			if (diff < min_frame)
107	root	1.23	{
108	root	1.34	SDL_Delay ((unsigned int)((min_frame - diff) * 1000.));
109
110	root	1.23	gettimeofday (&tv, 0);
111
112			next = tv.tv_sec - base + tv.tv_usec / 1.e6;
113			diff = next - now;
114			}
115	root	1.4
116			now = next;
117			}
118
119			timer::timer ()
120			{
121			struct timeval tv;
122			gettimeofday (&tv, 0);
123			base = tv.tv_sec + tv.tv_usec / 1.e6;
124			}
125
126	root	1.20	void render_text (GLint x, GLint y, const char *str)
127			{
128			glRasterPos2i (x, y);
129
130	root	1.29	#if 0
131	root	1.20	while (!*str)
132			glutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, *str++);
133	root	1.29	#endif
134	root	1.15	}
135	root	1.13
136	root	1.21	namespace gl {
137	root	1.33
138			void matrix::diagonal (GLfloat v)
139			{
140			for (int i = 4; i--; )
141			for (int j = 4; j--; )
142			data[i][j] = i == j ? v : 0.;
143			}
144
145	root	1.42	matrix operator *(const matrix &a, const matrix &b)
146	root	1.33	{
147			matrix r;
148
149			// taken from mesa
150			for (int i = 0; i < 4; i++)
151			{
152			const GLfloat ai0=a(i,0), ai1=a(i,1), ai2=a(i,2), ai3=a(i,3);
153
154			r(i,0) = ai0 * b(0,0) + ai1 * b(1,0) + ai2 * b(2,0) + ai3 * b(3,0);
155			r(i,1) = ai0 * b(0,1) + ai1 * b(1,1) + ai2 * b(2,1) + ai3 * b(3,1);
156			r(i,2) = ai0 * b(0,2) + ai1 * b(1,2) + ai2 * b(2,2) + ai3 * b(3,2);
157			r(i,3) = ai0 * b(0,3) + ai1 * b(1,3) + ai2 * b(2,3) + ai3 * b(3,3);
158			}
159
160			return r;
161			}
162
163	root	1.42	matrix matrix::rotation (GLfloat angle, const vec3 &axis)
164	root	1.33	{
165			GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;
166
167			s = (GLfloat) sinf (angle * DEG2RAD);
168			c = (GLfloat) cosf (angle * DEG2RAD);
169
170	root	1.37	const GLfloat mag = length (axis);
171	root	1.33
172			if (mag <= 1.0e-4)
173			return matrix (1);
174
175			matrix m;
176			const vec3 n = axis * (1. / mag);
177
178			xx = n.x * n.x;
179			yy = n.y * n.y;
180			zz = n.z * n.z;
181			xy = n.x * n.y;
182			yz = n.y * n.z;
183			zx = n.z * n.x;
184			xs = n.x * s;
185			ys = n.y * s;
186			zs = n.z * s;
187			one_c = 1.0F - c;
188
189			m(0,0) = (one_c * xx) + c;
190			m(0,1) = (one_c * xy) - zs;
191			m(0,2) = (one_c * zx) + ys;
192			m(0,3) = 0;
193
194			m(1,0) = (one_c * xy) + zs;
195			m(1,1) = (one_c * yy) + c;
196			m(1,2) = (one_c * yz) - xs;
197			m(1,3) = 0;
198
199			m(2,0) = (one_c * zx) - ys;
200			m(2,1) = (one_c * yz) + xs;
201			m(2,2) = (one_c * zz) + c;
202			m(2,3) = 0;
203
204			m(3,0) = 0;
205			m(3,1) = 0;
206			m(3,2) = 0;
207			m(3,3) = 1;
208
209			return m;
210			}
211
212	root	1.42	matrix matrix::translation (const vec3 &v)
213			{
214			matrix m(1);
215
216			m(0,3) = v.x;
217			m(1,3) = v.y;
218			m(2,3) = v.z;
219
220			return m;
221			}
222
223			matrix matrix::scaling (GLfloat sx, GLfloat sy, GLfloat sz, GLfloat sw)
224			{
225			matrix m (1.F);
226
227			m(0,0) = sx;
228			m(1,1) = sy;
229			m(2,2) = sz;
230			m(3,3) = sw;
231
232			return m;
233			}
234
235			vec3 operator *(const matrix &a, const vec3 &v)
236	root	1.33	{
237			return vec3 (
238			a(0,0) * v.x + a(0,1) * v.y + a(0,2) * v.z + a(0,3),
239			a(1,0) * v.x + a(1,1) * v.y + a(1,2) * v.z + a(1,3),
240			a(2,0) * v.x + a(2,1) * v.y + a(2,2) * v.z + a(2,3)
241			);
242			}
243
244			void matrix::print ()
245			{
246			printf ("\n");
247			printf ("[ %f, %f, %f, %f ]\n", data[0][0], data[1][0], data[2][0], data[3][0]);
248			printf ("[ %f, %f, %f, %f ]\n", data[0][1], data[1][1], data[2][1], data[3][1]);
249			printf ("[ %f, %f, %f, %f ]\n", data[0][2], data[1][2], data[2][2], data[3][2]);
250			printf ("[ %f, %f, %f, %f ]\n", data[0][3], data[1][3], data[2][3], data[3][3]);
251			}
252
253			/////////////////////////////////////////////////////////////////////////////
254	root	1.21
255	root	1.38	void draw_bbox (const sector &a, const sector &b)
256	root	1.24	{
257	root	1.42	static vertex_buffer vb;
258			static index_buffer ib;
259	root	1.24
260	root	1.38	vertex_v3f vd[] = {
261			point (a.x, a.y, a.z),
262			point (b.x, a.y, a.z),
263			point (a.x, b.y, a.z),
264			point (b.x, b.y, a.z),
265			point (a.x, a.y, b.z),
266			point (b.x, a.y, b.z),
267			point (a.x, b.y, b.z),
268			point (b.x, b.y, b.z),
269			};
270	root	1.32
271	root	1.38	if (!ib)
272	root	1.24	{
273	root	1.43	static GLushort verts[4*6] = {
274	root	1.38	0, 4, 6, 2, // -x
275			1, 3, 7, 5, // +x
276			0, 1, 5, 4, // -y
277			7, 3, 2, 6, // +y
278			0, 2, 3, 1, // -z
279			4, 5, 7, 6, // +z
280			};
281	root	1.24
282	root	1.38	ib.set (verts, 4*6, GL_STATIC_DRAW_ARB);
283	root	1.24	}
284
285	root	1.38	vb.set (vd, 8, GL_STREAM_DRAW_ARB);
286			vb.bind ();
287	root	1.43	ib.draw (GL_QUADS, 0, 4*6);
288	root	1.24	}
289
290	root	1.39	/////////////////////////////////////////////////////////////////////////////
291
292			GLsizei format_stride (GLenum format)
293			{
294			switch (format)
295			{
296			case GL_V2F: abort ();
297			case GL_V3F: return sizeof (vertex_v3f);
298			case GL_C4UB_V2F: abort ();
299			case GL_C4UB_V3F: abort ();
300			case GL_C3F_V3F: abort ();
301			case GL_N3F_V3F: abort ();
302			case GL_C4F_N3F_V3F: abort ();
303			case GL_T2F_V3F: abort ();
304			case GL_T4F_V4F: abort ();
305			case GL_T2F_C4UB_V3F: abort ();
306			case GL_T2F_C3F_V3F: abort ();
307			case GL_T2F_N3F_V3F: return sizeof (vertex_t2f_n3f_v3f);
308			case GL_T2F_C4F_N3F_V3F: abort ();
309			case GL_T4F_C4F_N3F_V4F: abort ();
310			default:
311			abort ();
312			}
313			}
314
315			GLsizei format_offset_p (GLenum format)
316			{
317			switch (format)
318			{
319			case GL_V2F: abort ();
320	root	1.43	case GL_V3F: { vertex_v3f v; return (char )&v.v - (char )&v; }
321	root	1.39	case GL_C4UB_V2F: abort ();
322			case GL_C4UB_V3F: abort ();
323			case GL_C3F_V3F: abort ();
324			case GL_N3F_V3F: abort ();
325			case GL_C4F_N3F_V3F: abort ();
326			case GL_T2F_V3F: abort ();
327			case GL_T4F_V4F: abort ();
328			case GL_T2F_C4UB_V3F: abort ();
329			case GL_T2F_C3F_V3F: abort ();
330	root	1.43	case GL_T2F_N3F_V3F: { vertex_t2f_n3f_v3f v; return (char )&v.v - (char )&v; }
331	root	1.39	case GL_T2F_C4F_N3F_V3F: abort ();
332			case GL_T4F_C4F_N3F_V4F: abort ();
333			default:
334			abort ();
335			}
336			}
337
338			GLsizei format_offset_n (GLenum format)
339			{
340			switch (format)
341			{
342			case GL_V2F: abort ();
343			case GL_V3F: abort ();
344			case GL_C4UB_V2F: abort ();
345			case GL_C4UB_V3F: abort ();
346			case GL_C3F_V3F: abort ();
347			case GL_N3F_V3F: abort ();
348			case GL_C4F_N3F_V3F: abort ();
349			case GL_T2F_V3F: abort ();
350			case GL_T4F_V4F: abort ();
351			case GL_T2F_C4UB_V3F: abort ();
352			case GL_T2F_C3F_V3F: abort ();
353			case GL_T2F_N3F_V3F: { vertex_t2f_n3f_v3f v; return (char )&v.n - (char )&v; }
354			case GL_T2F_C4F_N3F_V3F: abort ();
355			case GL_T4F_C4F_N3F_V4F: abort ();
356			default:
357			abort ();
358			}
359			}
360
361			GLsizei format_offset_t (GLenum format)
362			{
363			switch (format)
364			{
365			case GL_V2F: abort ();
366			case GL_V3F: abort ();
367			case GL_C4UB_V2F: abort ();
368			case GL_C4UB_V3F: abort ();
369			case GL_C3F_V3F: abort ();
370			case GL_N3F_V3F: abort ();
371			case GL_C4F_N3F_V3F: abort ();
372			case GL_T2F_V3F: abort ();
373			case GL_T4F_V4F: abort ();
374			case GL_T2F_C4UB_V3F: abort ();
375			case GL_T2F_C3F_V3F: abort ();
376			case GL_T2F_N3F_V3F: { vertex_t2f_n3f_v3f v; return (char )&v.t - (char )&v; }
377			case GL_T2F_C4F_N3F_V3F: abort ();
378			case GL_T4F_C4F_N3F_V4F: abort ();
379			default:
380			abort ();
381			}
382			}
383
384			/////////////////////////////////////////////////////////////////////////////
385
386	root	1.25	int nesting;
387
388	root	1.24	void errchk (const char name, const char args, const char *file, int line)
389			{
390	root	1.25	static int inbegin;
391
392			if (name[2] == 'B' && !strcmp (name, "glBegin"))
393			inbegin = 1;
394			else if (name[2] == 'E' && !strcmp (name, "glEnd"))
395			inbegin = 0;
396
397			if (inbegin)
398			return;
399
400	root	1.24	GLenum gl_derror = glGetError ();
401			if (gl_derror != GL_NO_ERROR)
402	root	1.32	{
403			fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
404			file, line, gl_derror, gluErrorString (gl_derror), name, args);
405			abort ();
406			}
407	root	1.24	}
408	root	1.21
409			}
410
411	root	1.47	template<typename idtype>
412			idpool<idtype>::idpool ()
413	root	1.46	: next (0)
414			{
415			}
416	root	1.17
417	root	1.47	template<typename idtype>
418			idtype idpool<idtype>::get ()
419	root	1.46	{
420	root	1.47	idtype ret;
421	root	1.46
422	root	1.47	if (free.size ())
423	root	1.46	{
424	root	1.47	ret = *(free.end () - 1);
425	root	1.49	//freeid.pop_back ();
426	root	1.46	}
427			else
428	root	1.47	ret = ++next;
429	root	1.46
430			return ret;
431			}
432
433	root	1.47	template<typename idtype>
434			void idpool<idtype>::put (idtype &i)
435	root	1.46	{
436	root	1.47	free.push_back (i);
437	root	1.46	}