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

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

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

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

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. / 600.;

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 draw_bbox (const view &ctx, 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
    };

    glBegin (GL_QUADS);
    point pa(a), pb(b);

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

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

    glEnd ();
  }

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

}

//skedjuhlar main_scheduler;

Revision:	1.29
Committed:	Mon Oct 11 00:05:48 2004 UTC (21 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.28:	+10 -7 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	root	1.12	void matrix::diagonal (GLfloat v)
54	root	1.2	{
55			for (int i = 4; i--; )
56			for (int j = 4; j--; )
57			data[i][j] = i == j ? v : 0.;
58			}
59
60	root	1.12	const matrix operator *(const matrix &a, const matrix &b)
61	root	1.2	{
62	root	1.12	matrix r;
63	root	1.2
64	root	1.3	// taken from mesa
65			for (int i = 0; i < 4; i++)
66			{
67			const GLfloat ai0=a(i,0), ai1=a(i,1), ai2=a(i,2), ai3=a(i,3);
68
69			r(i,0) = ai0 * b(0,0) + ai1 * b(1,0) + ai2 * b(2,0) + ai3 * b(3,0);
70			r(i,1) = ai0 * b(0,1) + ai1 * b(1,1) + ai2 * b(2,1) + ai3 * b(3,1);
71			r(i,2) = ai0 * b(0,2) + ai1 * b(1,2) + ai2 * b(2,2) + ai3 * b(3,2);
72			r(i,3) = ai0 * b(0,3) + ai1 * b(1,3) + ai2 * b(2,3) + ai3 * b(3,3);
73			}
74	root	1.2
75	root	1.3	return r;
76			}
77	root	1.2
78	root	1.12	const matrix matrix::rotation (GLfloat angle, const vec3 &axis)
79	root	1.3	{
80			GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;
81	root	1.2
82	root	1.3	s = (GLfloat) sinf (angle * DEG2RAD);
83			c = (GLfloat) cosf (angle * DEG2RAD);
84
85	root	1.29	const GLfloat mag = norm (axis);
86	root	1.3
87			if (mag <= 1.0e-4)
88	root	1.12	return matrix (1);
89	root	1.3
90	root	1.12	matrix m;
91	root	1.3	const vec3 n = axis * (1. / mag);
92
93			xx = n.x * n.x;
94			yy = n.y * n.y;
95			zz = n.z * n.z;
96			xy = n.x * n.y;
97			yz = n.y * n.z;
98			zx = n.z * n.x;
99			xs = n.x * s;
100			ys = n.y * s;
101			zs = n.z * s;
102			one_c = 1.0F - c;
103
104			m(0,0) = (one_c * xx) + c;
105			m(0,1) = (one_c * xy) - zs;
106			m(0,2) = (one_c * zx) + ys;
107			m(0,3) = 0;
108
109			m(1,0) = (one_c * xy) + zs;
110			m(1,1) = (one_c * yy) + c;
111			m(1,2) = (one_c * yz) - xs;
112			m(1,3) = 0;
113
114			m(2,0) = (one_c * zx) - ys;
115			m(2,1) = (one_c * yz) + xs;
116			m(2,2) = (one_c * zz) + c;
117			m(2,3) = 0;
118
119			m(3,0) = 0;
120			m(3,1) = 0;
121			m(3,2) = 0;
122			m(3,3) = 1;
123
124	root	1.9	return m;
125	root	1.3	}
126
127	root	1.12	const vec3 operator *(const matrix &a, const vec3 &v)
128	root	1.3	{
129			return vec3 (
130	root	1.9	a(0,0) * v.x + a(0,1) * v.y + a(0,2) * v.z + a(0,3),
131			a(1,0) * v.x + a(1,1) * v.y + a(1,2) * v.z + a(1,3),
132			a(2,0) * v.x + a(2,1) * v.y + a(2,2) * v.z + a(2,3)
133	root	1.3	);
134	root	1.2	}
135
136	root	1.12	void matrix::print ()
137	root	1.2	{
138			printf ("\n");
139			printf ("[ %f, %f, %f, %f ]\n", data[0][0], data[1][0], data[2][0], data[3][0]);
140			printf ("[ %f, %f, %f, %f ]\n", data[0][1], data[1][1], data[2][1], data[3][1]);
141			printf ("[ %f, %f, %f, %f ]\n", data[0][2], data[1][2], data[2][2], data[3][2]);
142			printf ("[ %f, %f, %f, %f ]\n", data[0][3], data[1][3], data[2][3], data[3][3]);
143			}
144
145	root	1.12	const matrix matrix::translation (const vec3 &v)
146	root	1.2	{
147	root	1.12	matrix m(1);
148	root	1.2
149	root	1.9	m(0,3) = v.x;
150			m(1,3) = v.y;
151			m(2,3) = v.z;
152	root	1.2
153	root	1.9	return m;
154	root	1.1	}
155
156	root	1.7	/////////////////////////////////////////////////////////////////////////////
157
158			plane::plane (GLfloat a, GLfloat b, GLfloat c, GLfloat d)
159	root	1.9	: n (vec3 (a,b,c))
160	root	1.7	{
161	root	1.29	GLfloat s = 1. / norm (n);
162	root	1.7
163			n = n * s;
164	root	1.9	this->d = d * s;
165	root	1.7	}
166
167			/////////////////////////////////////////////////////////////////////////////
168
169	root	1.1	void box::add (const box &o)
170			{
171			a.x = min (a.x, o.a.x);
172			a.y = min (a.y, o.a.y);
173			a.z = min (a.z, o.a.z);
174			b.x = max (b.x, o.b.x);
175			b.y = max (b.y, o.b.y);
176			b.z = max (b.z, o.b.z);
177			}
178
179	root	1.19	void box::add (const point &p)
180	root	1.1	{
181			a.x = min (a.x, p.x);
182			a.y = min (a.y, p.y);
183			a.z = min (a.z, p.z);
184			b.x = max (b.x, p.x);
185			b.y = max (b.y, p.y);
186			b.z = max (b.z, p.z);
187	root	1.5	}
188
189	root	1.7	/////////////////////////////////////////////////////////////////////////////
190	root	1.4
191			struct timer timer;
192			static double base;
193			double timer::now = 0.;
194			double timer::diff;
195	root	1.24	//double min_frame = 1. / 60.;
196			double min_frame = 1. / 600.;
197	root	1.4
198			void timer::frame ()
199			{
200			struct timeval tv;
201	root	1.23	double next;
202	root	1.4
203	root	1.23	for (;;)
204			{
205			gettimeofday (&tv, 0);
206
207			next = tv.tv_sec - base + tv.tv_usec / 1.e6;
208			diff = next - now;
209
210			if (diff >= min_frame)
211			break;
212
213			SDL_Delay ((unsigned int)((min_frame - diff) * 1000.));
214			}
215	root	1.4
216			now = next;
217			}
218
219			timer::timer ()
220			{
221			struct timeval tv;
222			gettimeofday (&tv, 0);
223			base = tv.tv_sec + tv.tv_usec / 1.e6;
224			}
225
226	root	1.20	void render_text (GLint x, GLint y, const char *str)
227			{
228			glRasterPos2i (x, y);
229
230	root	1.29	#if 0
231	root	1.20	while (!*str)
232			glutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, *str++);
233	root	1.29	#endif
234	root	1.15	}
235	root	1.13
236	root	1.21	namespace gl {
237
238	root	1.29	void draw_bbox (const view &ctx, 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			glBegin (GL_QUADS);
251	root	1.29	point pa(a), pb(b);
252	root	1.24
253			for (GLint v = verts; v; v++)
254			{
255			GLint mask = *v;
256
257	root	1.29	glVertex3f (mask & 1 ? pb.x : pa.x,
258			mask & 2 ? pb.y : pa.y,
259			mask & 4 ? pb.z : pa.z);
260	root	1.24	}
261
262			glEnd ();
263			}
264
265	root	1.25	int nesting;
266
267	root	1.24	void errchk (const char name, const char args, const char *file, int line)
268			{
269	root	1.25	static int inbegin;
270
271			if (name[2] == 'B' && !strcmp (name, "glBegin"))
272			inbegin = 1;
273			else if (name[2] == 'E' && !strcmp (name, "glEnd"))
274			inbegin = 0;
275
276			if (inbegin)
277			return;
278
279	root	1.24	GLenum gl_derror = glGetError ();
280			if (gl_derror != GL_NO_ERROR)
281	root	1.25	fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
282			file, line, gl_derror, gluErrorString (gl_derror), name, args);
283	root	1.24	}
284	root	1.21
285			}
286
287	root	1.10	//skedjuhlar main_scheduler;
288	root	1.17