cvsroot/libgender/entity.C

#include <algorithm>
#include <GL/gl.h>

using namespace std;

#include "util.h"
#include "entity.h"
#include "oct.h"
#include "view.h"

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

geometry::~geometry ()
{
}

template class geometry_opengl1d<GL_POINTS>;
template class geometry_opengl1d<GL_LINES>;
template class geometry_opengl1d<GL_LINE_STRIP>;
template class geometry_opengl1d<GL_LINE_LOOP>;
template class geometry_opengl2d<GL_TRIANGLES>;
template class geometry_opengl2d<GL_TRIANGLE_STRIP>;
template class geometry_opengl2d<GL_TRIANGLE_FAN>;
template class geometry_opengl2d<GL_QUADS>;
template class geometry_opengl2d<GL_QUAD_STRIP>;
template class geometry_opengl2d<GL_POLYGON>;

geometry_opengl::geometry_opengl ()
{
  list = glGenLists (1);
}

geometry_opengl::~geometry_opengl ()
{
  glDeleteLists (list, 1);
}

template<GLenum type>
void geometry_opengl1d<type>::set (const vector<vertex1d> &v)
{
  clear ();
  insert (end (), v.begin (), v.end ());

  bbox.reset ();

  for (const_iterator i = end (); i-- != begin (); )
    bbox.add (i->p);

  update ();
}

template<GLenum type>
void geometry_opengl1d<type>::draw (view &ctx)
{
  glBegin (type);

  for (iterator i = begin (); i < end (); ++i)
    {
      glColor3fv ((GLfloat *)&i->c);
      glVertex3fv ((GLfloat *)&i->p);
    }

  glEnd ();
}

template<GLenum type>
void geometry_opengl2d<type>::set (const vector<vertex2d> &v)
{
  bbox.reset ();

  for (vector<vertex2d>::const_iterator i = v.end (); i-- != v.begin (); )
    bbox.add (i->p);

  update ();

  glNewList (list, GL_COMPILE);

  glMaterialfv (GL_FRONT, GL_DIFFUSE,  (GLfloat *)&m.diffuse);
  glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *)&m.specular);
  glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *)&m.emission);
  glMaterialf  (GL_FRONT, GL_SHININESS, m.shininess);

#if 0
  glBegin (type);
     
  for (vector<vertex2d>::const_iterator i = v.begin (); i < v.end (); ++i)
    {
      glTexCoord2fv ((GLfloat *)&i->t);
      glNormal3fv ((GLfloat *)&i->n);
      glVertex3fv ((GLfloat *)&i->p);
    }

  glEnd ();
#else
  glEnableClientState (GL_VERTEX_ARRAY);
  glVertexPointer (3, GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->p);
  glEnableClientState (GL_NORMAL_ARRAY);
  glNormalPointer (GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->n);
  glEnableClientState (GL_TEXTURE_COORD_ARRAY);
  glTexCoordPointer (2, GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->t);

  glDrawArrays (type, 0, v.size ());
#endif

  glEndList ();
}

template<GLenum type>
void geometry_opengl2d<type>::draw (view &ctx)
{
  glCallList (list);
}

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

void geometry_transform::update ()
{
  const box &sub = g->bbox;

  bbox.reset ();
  bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.a.z));
  bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.a.z));
  bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.a.z));
  bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.a.z));
  bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.b.z));
  bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.b.z));
  bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.b.z));
  bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.b.z));

  geometry::update ();
}

#if 0
void geometry_transform::renormalize ()
{
  point trans(m(0,3), m(1,3), m(2,3));
  ::renormalize (e->orig, trans);
  m(0,3) = trans.x; m(1,3) = trans.y; m(2,3) = trans.z;
}
#endif

void geometry_transform::update (const matrix &xfrm)
{
  m = m * xfrm;

  update ();
}

void geometry_transform::set_matrix (const matrix &xfrm)
{
  m = xfrm;

  update ();
}

void geometry_transform::draw (view &ctx)
{
  glPushMatrix ();
  glMultMatrixf ((GLfloat *)&m);
  g->draw (ctx);
  glPopMatrix ();
}

void geometry_anim::draw (view &ctx)
{
  matrix save_m = m;

  update (matrix::rotation (vx * timer.now, vec3 (1, 0, 0))
        * matrix::rotation (vy * timer.now, vec3 (0, 1, 0))
        * matrix::rotation (vz * timer.now, vec3 (0, 0, 1)));
  
  geometry_transform::draw (ctx);

  m = save_m;
}

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

void geometry_filter::set (geometry *g)
{
  this->g = g;

  if (g)
    g->parent = this;

  update ();
}

void geometry_filter::update ()
{
  if (g)
    {
      bbox = g->bbox;
      geometry::update ();
    }
}

void geometry_filter::draw (view &ctx)
{
  g->draw (ctx);
}

geometry_filter::~geometry_filter ()
{
  delete g;
}

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

void geometry_container::update ()
{
  bbox.reset ();

  for (iterator i = end (); i-- != begin (); )
    bbox.add ((*i)->bbox);

  geometry::update ();
}

void geometry_container::add (geometry *g)
{
  push_back (g);
  g->parent = this;
  
  update ();
}

void geometry_container::draw (view &ctx)
{
  for (iterator i = end (); i-- != begin (); )
    (*i)->draw (ctx);
}

geometry_container::~geometry_container ()
{
  for (iterator i = end (); i-- != begin (); )
    delete *i;
 
  clear ();
}

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

entity::entity (geometry *g)
: geometry_filter(g), p(0,0,0)
{
  update ();
}

entity::~entity ()
{
  hide ();
}

void entity::move (const vec3 &v)
{
  p = p + v;

  //renormalize (orig, p);

  update ();
}

void entity::hide ()
{
  for (vector<octant *>::iterator i = o.end (); i-- != o.begin (); )
    (*i)->remove (this);

  o.clear ();
}

void entity::update ()
{
  if (!g)
    return;

  bbox = g->bbox;

  a.x = orig.x + (soffs)floorf (bbox.a.x + p.x);
  a.y = orig.y + (soffs)floorf (bbox.a.y + p.y);
  a.z = orig.z + (soffs)floorf (bbox.a.z + p.z);
  b.x = orig.x + (soffs)ceilf  (bbox.b.x + p.x);
  b.y = orig.y + (soffs)ceilf  (bbox.b.y + p.y);
  b.z = orig.z + (soffs)ceilf  (bbox.b.z + p.z);

  if (o.size ())
    {
      hide ();
      show ();
    }
}

void entity::draw (view &ctx)
{
  sector diff = orig - ctx.orig;

  glPushMatrix ();
  glTranslatef (diff.x + p.x, diff.y + p.y, diff.z + p.z);
  g->draw (ctx);
  glPopMatrix ();
}

void entity::display (view &ctx)
{
  if (ctx.may_draw (this))
    draw (ctx);
}


Revision:	1.38
Committed:	Thu Oct 7 23:39:43 2004 UTC (22 years ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.37:	+166 -145 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include <algorithm>
2	root	1.37	#include <GL/gl.h>
3	root	1.1
4			using namespace std;
5
6	root	1.28	#include "util.h"
7	root	1.1	#include "entity.h"
8	root	1.4	#include "oct.h"
9	root	1.13	#include "view.h"
10	root	1.1
11	root	1.21	/////////////////////////////////////////////////////////////////////////////
12
13	root	1.38	geometry::~geometry ()
14	root	1.1	{
15	root	1.2	}
16
17	root	1.38	template class geometry_opengl1d<GL_POINTS>;
18			template class geometry_opengl1d<GL_LINES>;
19			template class geometry_opengl1d<GL_LINE_STRIP>;
20			template class geometry_opengl1d<GL_LINE_LOOP>;
21			template class geometry_opengl2d<GL_TRIANGLES>;
22			template class geometry_opengl2d<GL_TRIANGLE_STRIP>;
23			template class geometry_opengl2d<GL_TRIANGLE_FAN>;
24			template class geometry_opengl2d<GL_QUADS>;
25			template class geometry_opengl2d<GL_QUAD_STRIP>;
26			template class geometry_opengl2d<GL_POLYGON>;
27	root	1.21
28	root	1.38	geometry_opengl::geometry_opengl ()
29	root	1.24	{
30			list = glGenLists (1);
31			}
32
33	root	1.38	geometry_opengl::~geometry_opengl ()
34	root	1.24	{
35			glDeleteLists (list, 1);
36			}
37
38	root	1.2	template<GLenum type>
39	root	1.38	void geometry_opengl1d<type>::set (const vector<vertex1d> &v)
40	root	1.2	{
41	root	1.38	clear ();
42			insert (end (), v.begin (), v.end ());
43
44	root	1.6	bbox.reset ();
45
46	root	1.38	for (const_iterator i = end (); i-- != begin (); )
47	root	1.6	bbox.add (i->p);
48
49	root	1.38	update ();
50	root	1.2	}
51
52			template<GLenum type>
53	root	1.38	void geometry_opengl1d<type>::draw (view &ctx)
54	root	1.2	{
55			glBegin (type);
56
57			for (iterator i = begin (); i < end (); ++i)
58			{
59	root	1.22	glColor3fv ((GLfloat *)&i->c);
60	root	1.2	glVertex3fv ((GLfloat *)&i->p);
61			}
62
63			glEnd ();
64			}
65
66			template<GLenum type>
67	root	1.38	void geometry_opengl2d<type>::set (const vector<vertex2d> &v)
68	root	1.2	{
69	root	1.24	bbox.reset ();
70
71			for (vector<vertex2d>::const_iterator i = v.end (); i-- != v.begin (); )
72			bbox.add (i->p);
73	root	1.26
74	root	1.28	update ();
75	root	1.24
76			glNewList (list, GL_COMPILE);
77	root	1.14
78	root	1.24	glMaterialfv (GL_FRONT, GL_DIFFUSE, (GLfloat *)&m.diffuse);
79			glMaterialfv (GL_FRONT, GL_SPECULAR, (GLfloat *)&m.specular);
80			glMaterialfv (GL_FRONT, GL_EMISSION, (GLfloat *)&m.emission);
81			glMaterialf (GL_FRONT, GL_SHININESS, m.shininess);
82	root	1.15
83	root	1.20	#if 0
84	root	1.24	glBegin (type);
85
86	root	1.25	for (vector<vertex2d>::const_iterator i = v.begin (); i < v.end (); ++i)
87	root	1.24	{
88			glTexCoord2fv ((GLfloat *)&i->t);
89			glNormal3fv ((GLfloat *)&i->n);
90			glVertex3fv ((GLfloat *)&i->p);
91			}
92	root	1.4
93	root	1.24	glEnd ();
94	root	1.19	#else
95	root	1.24	glEnableClientState (GL_VERTEX_ARRAY);
96			glVertexPointer (3, GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->p);
97			glEnableClientState (GL_NORMAL_ARRAY);
98			glNormalPointer (GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->n);
99			glEnableClientState (GL_TEXTURE_COORD_ARRAY);
100			glTexCoordPointer (2, GL_FLOAT, sizeof (vertex2d), (void *)&v.begin ()->t);
101	root	1.19
102	root	1.24	glDrawArrays (type, 0, v.size ());
103	root	1.19	#endif
104	root	1.22
105	root	1.24	glEndList ();
106			}
107	root	1.2
108	root	1.24	template<GLenum type>
109	root	1.38	void geometry_opengl2d<type>::draw (view &ctx)
110	root	1.24	{
111	root	1.17	glCallList (list);
112	root	1.22	}
113
114			/////////////////////////////////////////////////////////////////////////////
115
116	root	1.38	void geometry_transform::update ()
117	root	1.22	{
118	root	1.38	const box &sub = g->bbox;
119	root	1.27
120			bbox.reset ();
121			bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.a.z));
122			bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.a.z));
123			bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.a.z));
124			bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.a.z));
125			bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.b.z));
126			bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.b.z));
127			bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.b.z));
128			bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.b.z));
129	root	1.22
130	root	1.38	geometry::update ();
131	root	1.28	}
132
133	root	1.38	#if 0
134			void geometry_transform::renormalize ()
135	root	1.28	{
136	root	1.34	point trans(m(0,3), m(1,3), m(2,3));
137			::renormalize (e->orig, trans);
138			m(0,3) = trans.x; m(1,3) = trans.y; m(2,3) = trans.z;
139	root	1.38	}
140	root	1.28	#endif
141
142	root	1.38	void geometry_transform::update (const matrix &xfrm)
143	root	1.28	{
144			m = m * xfrm;
145
146			update ();
147			}
148
149	root	1.38	void geometry_transform::set_matrix (const matrix &xfrm)
150	root	1.28	{
151			m = xfrm;
152
153			update ();
154	root	1.22	}
155
156	root	1.38	void geometry_transform::draw (view &ctx)
157	root	1.22	{
158	root	1.33	glPushMatrix ();
159			glMultMatrixf ((GLfloat *)&m);
160	root	1.38	g->draw (ctx);
161	root	1.33	glPopMatrix ();
162	root	1.2	}
163
164	root	1.38	void geometry_anim::draw (view &ctx)
165	root	1.23	{
166	root	1.30	matrix save_m = m;
167	root	1.23
168	root	1.30	update (matrix::rotation (vx * timer.now, vec3 (1, 0, 0))
169			* matrix::rotation (vy * timer.now, vec3 (0, 1, 0))
170			* matrix::rotation (vz * timer.now, vec3 (0, 0, 1)));
171	root	1.28
172	root	1.38	geometry_transform::draw (ctx);
173	root	1.23
174			m = save_m;
175	root	1.38	}
176
177			/////////////////////////////////////////////////////////////////////////////
178
179			void geometry_filter::set (geometry *g)
180			{
181			this->g = g;
182
183			if (g)
184			g->parent = this;
185
186			update ();
187			}
188
189			void geometry_filter::update ()
190			{
191			if (g)
192			{
193			bbox = g->bbox;
194			geometry::update ();
195			}
196			}
197
198			void geometry_filter::draw (view &ctx)
199			{
200			g->draw (ctx);
201			}
202
203			geometry_filter::~geometry_filter ()
204			{
205			delete g;
206			}
207
208			/////////////////////////////////////////////////////////////////////////////
209
210			void geometry_container::update ()
211			{
212			bbox.reset ();
213
214			for (iterator i = end (); i-- != begin (); )
215			bbox.add ((*i)->bbox);
216
217			geometry::update ();
218			}
219
220			void geometry_container::add (geometry *g)
221			{
222			push_back (g);
223			g->parent = this;
224
225			update ();
226			}
227
228			void geometry_container::draw (view &ctx)
229			{
230			for (iterator i = end (); i-- != begin (); )
231			(*i)->draw (ctx);
232			}
233
234			geometry_container::~geometry_container ()
235			{
236			for (iterator i = end (); i-- != begin (); )
237			delete *i;
238
239			clear ();
240			}
241
242			/////////////////////////////////////////////////////////////////////////////
243
244			entity::entity (geometry *g)
245			: geometry_filter(g), p(0,0,0)
246			{
247			update ();
248			}
249
250			entity::~entity ()
251			{
252			hide ();
253			}
254
255			void entity::move (const vec3 &v)
256			{
257			p = p + v;
258
259			//renormalize (orig, p);
260
261			update ();
262			}
263
264			void entity::hide ()
265			{
266			for (vector<octant *>::iterator i = o.end (); i-- != o.begin (); )
267			(*i)->remove (this);
268
269			o.clear ();
270			}
271
272			void entity::update ()
273			{
274			if (!g)
275			return;
276
277			bbox = g->bbox;
278
279			a.x = orig.x + (soffs)floorf (bbox.a.x + p.x);
280			a.y = orig.y + (soffs)floorf (bbox.a.y + p.y);
281			a.z = orig.z + (soffs)floorf (bbox.a.z + p.z);
282			b.x = orig.x + (soffs)ceilf (bbox.b.x + p.x);
283			b.y = orig.y + (soffs)ceilf (bbox.b.y + p.y);
284			b.z = orig.z + (soffs)ceilf (bbox.b.z + p.z);
285
286			if (o.size ())
287			{
288			hide ();
289			show ();
290			}
291			}
292
293			void entity::draw (view &ctx)
294			{
295			sector diff = orig - ctx.orig;
296
297			glPushMatrix ();
298			glTranslatef (diff.x + p.x, diff.y + p.y, diff.z + p.z);
299			g->draw (ctx);
300			glPopMatrix ();
301			}
302
303			void entity::display (view &ctx)
304			{
305			if (ctx.may_draw (this))
306			draw (ctx);
307	root	1.23	}
308	root	1.1
309