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 = norm (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. / norm (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 min_frame = 1. / 60.;
double min_frame = 1. / 1000.;

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

  for (;;)
    {
      gettimeofday (&tv, 0);

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

      if (diff >= min_frame)
        break;

      SDL_Delay ((unsigned int)((min_frame - diff) * 1000.));
    }

  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 = norm (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 gen_bbox (vertex_buffer_object &vb, const sector &a, const sector &b)
  {
    static GLint verts[] = {
       0x8000, 0x8004, 0x8006, 0x8002,  // -x
       0x8001, 0x8003, 0x8007, 0x8005,  // +x
       0x8000, 0x8001, 0x8005, 0x8004,  // -y
       0x8007, 0x8003, 0x8002, 0x8006,  // +y
       0x8000, 0x8002, 0x8003, 0x8001,  // -z
       0x8004, 0x8005, 0x8007, 0x8006,  // +z
       0
    };

    point pa(a), pb(b);

    vector<vertex_v3f> vd;

    for (GLint *v = verts; *v; v++)
      {
        GLint mask = *v;

        vd.push_back (point (
          mask & 1 ? pb.x : pa.x,
          mask & 2 ? pb.y : pa.y,
          mask & 4 ? pb.z : pa.z
        ));
      }

    vb.set (vd);
  }

  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.33
Committed:	Sun Oct 17 05:23:38 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.32:	+105 -105 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.29	GLfloat s = norm (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.29	GLfloat s = 1. / norm (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.24	//double min_frame = 1. / 60.;
91	root	1.31	double min_frame = 1. / 1000.;
92	root	1.4
93			void timer::frame ()
94			{
95			struct timeval tv;
96	root	1.23	double next;
97	root	1.4
98	root	1.23	for (;;)
99			{
100			gettimeofday (&tv, 0);
101
102			next = tv.tv_sec - base + tv.tv_usec / 1.e6;
103			diff = next - now;
104
105			if (diff >= min_frame)
106			break;
107
108			SDL_Delay ((unsigned int)((min_frame - diff) * 1000.));
109			}
110	root	1.4
111			now = next;
112			}
113
114			timer::timer ()
115			{
116			struct timeval tv;
117			gettimeofday (&tv, 0);
118			base = tv.tv_sec + tv.tv_usec / 1.e6;
119			}
120
121	root	1.20	void render_text (GLint x, GLint y, const char *str)
122			{
123			glRasterPos2i (x, y);
124
125	root	1.29	#if 0
126	root	1.20	while (!*str)
127			glutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, *str++);
128	root	1.29	#endif
129	root	1.15	}
130	root	1.13
131	root	1.21	namespace gl {
132	root	1.33
133			void matrix::diagonal (GLfloat v)
134			{
135			for (int i = 4; i--; )
136			for (int j = 4; j--; )
137			data[i][j] = i == j ? v : 0.;
138			}
139
140			const matrix operator *(const matrix &a, const matrix &b)
141			{
142			matrix r;
143
144			// taken from mesa
145			for (int i = 0; i < 4; i++)
146			{
147			const GLfloat ai0=a(i,0), ai1=a(i,1), ai2=a(i,2), ai3=a(i,3);
148
149			r(i,0) = ai0 * b(0,0) + ai1 * b(1,0) + ai2 * b(2,0) + ai3 * b(3,0);
150			r(i,1) = ai0 * b(0,1) + ai1 * b(1,1) + ai2 * b(2,1) + ai3 * b(3,1);
151			r(i,2) = ai0 * b(0,2) + ai1 * b(1,2) + ai2 * b(2,2) + ai3 * b(3,2);
152			r(i,3) = ai0 * b(0,3) + ai1 * b(1,3) + ai2 * b(2,3) + ai3 * b(3,3);
153			}
154
155			return r;
156			}
157
158			const matrix matrix::rotation (GLfloat angle, const vec3 &axis)
159			{
160			GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;
161
162			s = (GLfloat) sinf (angle * DEG2RAD);
163			c = (GLfloat) cosf (angle * DEG2RAD);
164
165			const GLfloat mag = norm (axis);
166
167			if (mag <= 1.0e-4)
168			return matrix (1);
169
170			matrix m;
171			const vec3 n = axis * (1. / mag);
172
173			xx = n.x * n.x;
174			yy = n.y * n.y;
175			zz = n.z * n.z;
176			xy = n.x * n.y;
177			yz = n.y * n.z;
178			zx = n.z * n.x;
179			xs = n.x * s;
180			ys = n.y * s;
181			zs = n.z * s;
182			one_c = 1.0F - c;
183
184			m(0,0) = (one_c * xx) + c;
185			m(0,1) = (one_c * xy) - zs;
186			m(0,2) = (one_c * zx) + ys;
187			m(0,3) = 0;
188
189			m(1,0) = (one_c * xy) + zs;
190			m(1,1) = (one_c * yy) + c;
191			m(1,2) = (one_c * yz) - xs;
192			m(1,3) = 0;
193
194			m(2,0) = (one_c * zx) - ys;
195			m(2,1) = (one_c * yz) + xs;
196			m(2,2) = (one_c * zz) + c;
197			m(2,3) = 0;
198
199			m(3,0) = 0;
200			m(3,1) = 0;
201			m(3,2) = 0;
202			m(3,3) = 1;
203
204			return m;
205			}
206
207			const vec3 operator *(const matrix &a, const vec3 &v)
208			{
209			return vec3 (
210			a(0,0) * v.x + a(0,1) * v.y + a(0,2) * v.z + a(0,3),
211			a(1,0) * v.x + a(1,1) * v.y + a(1,2) * v.z + a(1,3),
212			a(2,0) * v.x + a(2,1) * v.y + a(2,2) * v.z + a(2,3)
213			);
214			}
215
216			void matrix::print ()
217			{
218			printf ("\n");
219			printf ("[ %f, %f, %f, %f ]\n", data[0][0], data[1][0], data[2][0], data[3][0]);
220			printf ("[ %f, %f, %f, %f ]\n", data[0][1], data[1][1], data[2][1], data[3][1]);
221			printf ("[ %f, %f, %f, %f ]\n", data[0][2], data[1][2], data[2][2], data[3][2]);
222			printf ("[ %f, %f, %f, %f ]\n", data[0][3], data[1][3], data[2][3], data[3][3]);
223			}
224
225			const matrix matrix::translation (const vec3 &v)
226			{
227			matrix m(1);
228
229			m(0,3) = v.x;
230			m(1,3) = v.y;
231			m(2,3) = v.z;
232
233			return m;
234			}
235
236			/////////////////////////////////////////////////////////////////////////////
237	root	1.21
238	root	1.32	void gen_bbox (vertex_buffer_object &vb, const sector &a, const sector &b)
239	root	1.24	{
240			static GLint verts[] = {
241			0x8000, 0x8004, 0x8006, 0x8002, // -x
242			0x8001, 0x8003, 0x8007, 0x8005, // +x
243			0x8000, 0x8001, 0x8005, 0x8004, // -y
244			0x8007, 0x8003, 0x8002, 0x8006, // +y
245			0x8000, 0x8002, 0x8003, 0x8001, // -z
246			0x8004, 0x8005, 0x8007, 0x8006, // +z
247			0
248			};
249
250	root	1.29	point pa(a), pb(b);
251	root	1.24
252	root	1.32	vector<vertex_v3f> vd;
253
254	root	1.24	for (GLint v = verts; v; v++)
255			{
256			GLint mask = *v;
257
258	root	1.32	vd.push_back (point (
259			mask & 1 ? pb.x : pa.x,
260			mask & 2 ? pb.y : pa.y,
261			mask & 4 ? pb.z : pa.z
262			));
263	root	1.24	}
264
265	root	1.32	vb.set (vd);
266	root	1.24	}
267
268	root	1.25	int nesting;
269
270	root	1.24	void errchk (const char name, const char args, const char *file, int line)
271			{
272	root	1.25	static int inbegin;
273
274			if (name[2] == 'B' && !strcmp (name, "glBegin"))
275			inbegin = 1;
276			else if (name[2] == 'E' && !strcmp (name, "glEnd"))
277			inbegin = 0;
278
279			if (inbegin)
280			return;
281
282	root	1.24	GLenum gl_derror = glGetError ();
283			if (gl_derror != GL_NO_ERROR)
284	root	1.32	{
285			fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
286			file, line, gl_derror, gluErrorString (gl_derror), name, args);
287			abort ();
288			}
289	root	1.24	}
290	root	1.21
291			}
292
293	root	1.10	//skedjuhlar main_scheduler;
294	root	1.17