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 (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, GL_STATIC_DRAW_ARB);
    vb.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.37
Committed:	Mon Oct 18 12:01:14 2004 UTC (19 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.36:	+3 -3 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.34	void draw_bbox (vertex_buffer_object &vb, const sector &a, const sector &b)
244	root	1.24	{
245			static GLint verts[] = {
246			0x8000, 0x8004, 0x8006, 0x8002, // -x
247			0x8001, 0x8003, 0x8007, 0x8005, // +x
248			0x8000, 0x8001, 0x8005, 0x8004, // -y
249			0x8007, 0x8003, 0x8002, 0x8006, // +y
250			0x8000, 0x8002, 0x8003, 0x8001, // -z
251			0x8004, 0x8005, 0x8007, 0x8006, // +z
252			0
253			};
254
255	root	1.29	point pa(a), pb(b);
256	root	1.24
257	root	1.32	vector<vertex_v3f> vd;
258
259	root	1.24	for (GLint v = verts; v; v++)
260			{
261			GLint mask = *v;
262
263	root	1.32	vd.push_back (point (
264			mask & 1 ? pb.x : pa.x,
265			mask & 2 ? pb.y : pa.y,
266			mask & 4 ? pb.z : pa.z
267			));
268	root	1.24	}
269
270	root	1.34	vb.set (vd, GL_STATIC_DRAW_ARB);
271			vb.draw (GL_QUADS, 0, 6*4);
272	root	1.24	}
273
274	root	1.25	int nesting;
275
276	root	1.24	void errchk (const char name, const char args, const char *file, int line)
277			{
278	root	1.25	static int inbegin;
279
280			if (name[2] == 'B' && !strcmp (name, "glBegin"))
281			inbegin = 1;
282			else if (name[2] == 'E' && !strcmp (name, "glEnd"))
283			inbegin = 0;
284
285			if (inbegin)
286			return;
287
288	root	1.24	GLenum gl_derror = glGetError ();
289			if (gl_derror != GL_NO_ERROR)
290	root	1.32	{
291			fprintf (stderr, "%s:%d [GLERROR %d,%s] %s(%s)\n",
292			file, line, gl_derror, gluErrorString (gl_derror), name, args);
293			abort ();
294			}
295	root	1.24	}
296	root	1.21
297			}
298
299	root	1.10	//skedjuhlar main_scheduler;
300	root	1.17