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. / 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 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.32
Committed:	Sat Oct 16 23:23:21 2004 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.31:	+14 -8 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* math support
3	* most of the more complicated code is taken from mesa.
4	*/
5
6	#include <cstdio> // ugly
7	#include <cstring>
8	#include <cmath>
9
10	#include <sys/time.h>
11	#include <time.h>
12
13	#include "opengl.h"
14
15	#include "util.h"
16	#include "entity.h"
17
18	#define DEG2RAD (M_PI / 180.)
19
20	void renormalize (sector &s, point &p)
21	{
22	float i;
23
24	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	}
28
29	/////////////////////////////////////////////////////////////////////////////
30
31	const vec3 normalize (const vec3 &v)
32	{
33	GLfloat s = norm (v);
34
35	if (!s)
36	return v;
37
38	s = 1. / s;
39	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	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	}
50
51	/////////////////////////////////////////////////////////////////////////////
52
53	void matrix::diagonal (GLfloat v)
54	{
55	for (int i = 4; i--; )
56	for (int j = 4; j--; )
57	data[i][j] = i == j ? v : 0.;
58	}
59
60	const matrix operator *(const matrix &a, const matrix &b)
61	{
62	matrix r;
63
64	// 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
75	return r;
76	}
77
78	const matrix matrix::rotation (GLfloat angle, const vec3 &axis)
79	{
80	GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;
81
82	s = (GLfloat) sinf (angle * DEG2RAD);
83	c = (GLfloat) cosf (angle * DEG2RAD);
84
85	const GLfloat mag = norm (axis);
86
87	if (mag <= 1.0e-4)
88	return matrix (1);
89
90	matrix m;
91	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	return m;
125	}
126
127	const vec3 operator *(const matrix &a, const vec3 &v)
128	{
129	return vec3 (
130	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	);
134	}
135
136	void matrix::print ()
137	{
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	const matrix matrix::translation (const vec3 &v)
146	{
147	matrix m(1);
148
149	m(0,3) = v.x;
150	m(1,3) = v.y;
151	m(2,3) = v.z;
152
153	return m;
154	}
155
156	/////////////////////////////////////////////////////////////////////////////
157
158	plane::plane (GLfloat a, GLfloat b, GLfloat c, GLfloat d)
159	: n (vec3 (a,b,c))
160	{
161	GLfloat s = 1. / norm (n);
162
163	n = n * s;
164	this->d = d * s;
165	}
166
167	/////////////////////////////////////////////////////////////////////////////
168
169	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	void box::add (const point &p)
180	{
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	}
188
189	/////////////////////////////////////////////////////////////////////////////
190
191	struct timer timer;
192	static double base;
193	double timer::now = 0.;
194	double timer::diff;
195	//double min_frame = 1. / 60.;
196	double min_frame = 1. / 1000.;
197
198	void timer::frame ()
199	{
200	struct timeval tv;
201	double next;
202
203	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
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	void render_text (GLint x, GLint y, const char *str)
227	{
228	glRasterPos2i (x, y);
229
230	#if 0
231	while (!*str)
232	glutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, *str++);
233	#endif
234	}
235
236	namespace gl {
237
238	void gen_bbox (vertex_buffer_object &vb, const sector &a, const sector &b)
239	{
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	point pa(a), pb(b);
251
252	vector<vertex_v3f> vd;
253
254	for (GLint v = verts; v; v++)
255	{
256	GLint mask = *v;
257
258	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	}
264
265	vb.set (vd);
266	}
267
268	int nesting;
269
270	void errchk (const char name, const char args, const char *file, int line)
271	{
272	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	GLenum gl_derror = glGetError ();
283	if (gl_derror != GL_NO_ERROR)
284	{
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	}
290
291	}
292
293	//skedjuhlar main_scheduler;
294