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 = 60.;
double min_frame = 1. / 60.;
//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.9 + (1. / diff) * 0.1;

  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.;
  }

  const 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;
  }

  const 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;
  }

  const 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]);
  }

  const 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;
  }

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

  void draw_bbox (const sector &a, const sector &b)
  {
    static vertex_buffer_object vb;
    static index_buffer_object ib;

    point pa(a), pb(b);

    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 index_ushort 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, 6*4);
  }

  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 ();
      }
  }

}

//skedjuhlar main_scheduler;

Revision:	1.38
Committed:	Tue Oct 19 11:35:20 2004 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.37:	+26 -20 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.34	double timer::fps = 60.;
91	root	1.35	double min_frame = 1. / 60.;
92			//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.36	fps = fps * 0.9 + (1. / diff) * 0.1;
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			const matrix operator *(const matrix &a, const matrix &b)
146			{
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			const matrix matrix::rotation (GLfloat angle, const vec3 &axis)
164			{
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			const vec3 operator *(const matrix &a, const vec3 &v)
213			{
214			return vec3 (
215			a(0,0) * v.x + a(0,1) * v.y + a(0,2) * v.z + a(0,3),
216			a(1,0) * v.x + a(1,1) * v.y + a(1,2) * v.z + a(1,3),
217			a(2,0) * v.x + a(2,1) * v.y + a(2,2) * v.z + a(2,3)
218			);
219			}
220
221			void matrix::print ()
222			{
223			printf ("\n");
224			printf ("[ %f, %f, %f, %f ]\n", data[0][0], data[1][0], data[2][0], data[3][0]);
225			printf ("[ %f, %f, %f, %f ]\n", data[0][1], data[1][1], data[2][1], data[3][1]);
226			printf ("[ %f, %f, %f, %f ]\n", data[0][2], data[1][2], data[2][2], data[3][2]);
227			printf ("[ %f, %f, %f, %f ]\n", data[0][3], data[1][3], data[2][3], data[3][3]);
228			}
229
230			const matrix matrix::translation (const vec3 &v)
231			{
232			matrix m(1);
233
234			m(0,3) = v.x;
235			m(1,3) = v.y;
236			m(2,3) = v.z;
237
238			return m;
239			}
240
241			/////////////////////////////////////////////////////////////////////////////
242	root	1.21
243	root	1.38	void draw_bbox (const sector &a, const sector &b)
244	root	1.24	{
245	root	1.38	static vertex_buffer_object vb;
246			static index_buffer_object ib;
247	root	1.24
248	root	1.29	point pa(a), pb(b);
249	root	1.24
250	root	1.38	vertex_v3f vd[] = {
251			point (a.x, a.y, a.z),
252			point (b.x, a.y, a.z),
253			point (a.x, b.y, a.z),
254			point (b.x, b.y, a.z),
255			point (a.x, a.y, b.z),
256			point (b.x, a.y, b.z),
257			point (a.x, b.y, b.z),
258			point (b.x, b.y, b.z),
259			};
260	root	1.32
261	root	1.38	if (!ib)
262	root	1.24	{
263	root	1.38	static index_ushort verts[4*6] = {
264			0, 4, 6, 2, // -x
265			1, 3, 7, 5, // +x
266			0, 1, 5, 4, // -y
267			7, 3, 2, 6, // +y
268			0, 2, 3, 1, // -z
269			4, 5, 7, 6, // +z
270			};
271	root	1.24
272	root	1.38	ib.set (verts, 4*6, GL_STATIC_DRAW_ARB);
273	root	1.24	}
274
275	root	1.38	vb.set (vd, 8, GL_STREAM_DRAW_ARB);
276			vb.bind ();
277			ib.draw (GL_QUADS, 0, 6*4);
278	root	1.24	}
279
280	root	1.25	int nesting;
281
282	root	1.24	void errchk (const char name, const char args, const char *file, int line)
283			{
284	root	1.25	static int inbegin;
285
286			if (name[2] == 'B' && !strcmp (name, "glBegin"))
287			inbegin = 1;
288			else if (name[2] == 'E' && !strcmp (name, "glEnd"))
289			inbegin = 0;
290
291			if (inbegin)
292			return;
293
294	root	1.24	GLenum gl_derror = glGetError ();
295			if (gl_derror != GL_NO_ERROR)
296	root	1.32	{
297			fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
298			file, line, gl_derror, gluErrorString (gl_derror), name, args);
299			abort ();
300			}
301	root	1.24	}
302	root	1.21
303			}
304
305	root	1.10	//skedjuhlar main_scheduler;
306	root	1.17