libgender/entity.C

#include <algorithm>
#include <cassert>

using namespace std;

#include "opengl.h"

#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<vertex_v3f> &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)
    glVertex3fv ((GLfloat *)&i->p);

  glEnd ();
}

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

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

  update ();

  glNewList (list, GL_COMPILE);

#if 0
  glBegin (type);
     
  for (vector<vertex_t2f_n3f_v3f>::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);
  glEnableClientState (GL_NORMAL_ARRAY);
  glEnableClientState (GL_TEXTURE_COORD_ARRAY);
  glVertexPointer (3, GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->p);
  glNormalPointer (GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->n);
  glTexCoordPointer (2, GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->t);

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

  glDisableClientState (GL_VERTEX_ARRAY);
  glDisableClientState (GL_NORMAL_ARRAY);
  glDisableClientState (GL_TEXTURE_COORD_ARRAY);
#endif

  glEndList ();
}

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

void geometry_sphere::update ()
{
  bbox.reset ();
  bbox.add (-point (radius, radius, radius));
  bbox.add ( point (radius, radius, radius));

  geometry::update ();
}

void geometry_sphere::draw (view &ctx)
{
  int n = min (100, max (15, (int)(ctx.pixfact * radius) / 10));

  GLUquadric *quad = gluNewQuadric ();
  gluQuadricTexture (quad, true);
  gluSphere (quad, radius, n, n);
  gluDeleteQuadric (quad);
}

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

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

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

static void nurbs_error (GLenum errorCode)
{
  const GLubyte *estring;
  estring = gluErrorString(errorCode);
  fprintf (stderr, "Nurbs error: %s\n", estring);
}

void errorCallback(GLenum errorCode)
{
   const GLubyte *estring;

   estring = gluErrorString(errorCode);
   fprintf (stderr, "Tessellation Error: %s\n", estring);
   exit (0);
}
void tcbBegin (GLenum prim)
{
  glBegin (prim);
}
void tcbVertex (void *data)
{
  glVertex3fv ((GLfloat *)data);
}
void tcbEnd ()
{
  glEnd ();
}
void geometry_nurbs::set ()
{
  // < XXX >: Testing CODE
  int u, v;
  for (u = 0; u < 4; u++) {
    for (v = 0; v < 4; v++) {
      ctlpoints[u][v][0] = 2.0*((GLfloat)u - 1.5);
      ctlpoints[u][v][1] = 2.0*((GLfloat)v - 1.5);

      if ( (u == 1 || u == 2) && (v == 1 || v == 2))
        ctlpoints[u][v][2] = 3.0;
      else
        ctlpoints[u][v][2] = -3.0;
    }
  }                    
  tess = gluNewTess();
  // </ XXX >

  glEnable(GL_AUTO_NORMAL);
  nurb = gluNewNurbsRenderer ();
  gluNurbsProperty (nurb, GLU_AUTO_LOAD_MATRIX, GL_FALSE);
  gluNurbsProperty (nurb, GLU_DISPLAY_MODE, GLU_FILL);
  gluNurbsProperty (nurb, GLU_NURBS_MODE, GLU_NURBS_TESSELLATOR);
  gluNurbsProperty (nurb, GLU_SAMPLING_METHOD, GLU_OBJECT_PATH_LENGTH);
  gluNurbsProperty (nurb, GLU_SAMPLING_TOLERANCE, 1.0);
  gluNurbsCallback (nurb, GLU_ERROR, (GLvoid (*)()) nurbs_error);
  gluNurbsCallback (nurb, GLU_NURBS_BEGIN, (GLvoid(*)()) tcbBegin);
  gluNurbsCallback (nurb, GLU_NURBS_VERTEX,(GLvoid(*)()) tcbVertex);
  gluNurbsCallback (nurb, GLU_NURBS_END, tcbEnd);
  glDisable(GL_AUTO_NORMAL);

}

void geometry_nurbs::draw (view &ctx) 
{
  GLfloat knots[8] = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0};

  GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  GLfloat mat_shininess[] = { 100.0 };

  glClearColor (0.0, 0.0, 0.0, 0.0);
  glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);


  glEnable(GL_AUTO_NORMAL);
  gluBeginSurface (nurb);
  gluNurbsSurface (nurb, 8, knots, 8, knots, 4 * 3, 3, &ctlpoints[0][0][0], 4, 4, GL_MAP2_VERTEX_3);
  gluEndSurface (nurb);
/*
  glEnable(GL_AUTO_NORMAL);
  glPushMatrix();
  GL_LG_DEBUG;
=======

  gluEndSurface (nurb);
>>>>>>> 1.40
  glDisable(GL_AUTO_NORMAL);
  glPopMatrix();
  glFlush();
*/
}

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

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::show ()
{
  if (!o.size ())
    world.add (this);
}

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

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

#define SIZE 33

struct geometry_heightfield::node
{
  vertex_t2f_n3f_v3f v[SIZE*SIZE];
  gl::vertex_buffer vb;
  gl::index_buffer ib;
};

geometry_heightfield::geometry_heightfield ()
{
  update ();
}

void geometry_heightfield::update ()
{
  bbox.a = sector (0, 0, 0);
  bbox.b = sector (1, 1, 1);

  geometry::update ();
}

void geometry_heightfield::draw (view &ctx)
{
  glBegin (GL_QUADS);
  glVertex3f (0.F, 0.F, 0.F);
  glVertex3f (0.F, 0.F, 1.F);
  glVertex3f (1.F, 0.F, 1.F);
  glVertex3f (1.F, 0.F, 0.F);
  glEnd ();
}

Revision:	1.52
Committed:	Fri Oct 29 22:32:49 2004 UTC (21 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.51:	+105 -69 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include <algorithm>
2	root	1.42	#include <cassert>
3	root	1.1
4			using namespace std;
5	root	1.42
6			#include "opengl.h"
7	root	1.1
8	root	1.28	#include "util.h"
9	root	1.1	#include "entity.h"
10	root	1.4	#include "oct.h"
11	root	1.13	#include "view.h"
12	root	1.1
13	root	1.21	/////////////////////////////////////////////////////////////////////////////
14
15	root	1.38	geometry::~geometry ()
16	root	1.1	{
17	root	1.2	}
18
19	root	1.38	template class geometry_opengl1d<GL_POINTS>;
20			template class geometry_opengl1d<GL_LINES>;
21			template class geometry_opengl1d<GL_LINE_STRIP>;
22			template class geometry_opengl1d<GL_LINE_LOOP>;
23			template class geometry_opengl2d<GL_TRIANGLES>;
24			template class geometry_opengl2d<GL_TRIANGLE_STRIP>;
25			template class geometry_opengl2d<GL_TRIANGLE_FAN>;
26			template class geometry_opengl2d<GL_QUADS>;
27			template class geometry_opengl2d<GL_QUAD_STRIP>;
28			template class geometry_opengl2d<GL_POLYGON>;
29	root	1.21
30	root	1.38	geometry_opengl::geometry_opengl ()
31	root	1.24	{
32			list = glGenLists (1);
33			}
34
35	root	1.38	geometry_opengl::~geometry_opengl ()
36	root	1.24	{
37			glDeleteLists (list, 1);
38			}
39
40	root	1.2	template<GLenum type>
41	root	1.46	void geometry_opengl1d<type>::set (const vector<vertex_v3f> &v)
42	root	1.2	{
43	root	1.38	clear ();
44			insert (end (), v.begin (), v.end ());
45
46	root	1.6	bbox.reset ();
47
48	root	1.38	for (const_iterator i = end (); i-- != begin (); )
49	root	1.6	bbox.add (i->p);
50
51	root	1.38	update ();
52	root	1.2	}
53
54			template<GLenum type>
55	root	1.38	void geometry_opengl1d<type>::draw (view &ctx)
56	root	1.2	{
57			glBegin (type);
58
59			for (iterator i = begin (); i < end (); ++i)
60	root	1.46	glVertex3fv ((GLfloat *)&i->p);
61	root	1.2
62			glEnd ();
63			}
64
65			template<GLenum type>
66	root	1.46	void geometry_opengl2d<type>::set (const vector<vertex_t2f_n3f_v3f> &v)
67	root	1.2	{
68	root	1.24	bbox.reset ();
69
70	root	1.46	for (vector<vertex_t2f_n3f_v3f>::const_iterator i = v.end (); i-- != v.begin (); )
71	root	1.24	bbox.add (i->p);
72	root	1.26
73	root	1.28	update ();
74	root	1.24
75			glNewList (list, GL_COMPILE);
76	root	1.14
77	root	1.20	#if 0
78	root	1.24	glBegin (type);
79
80	root	1.46	for (vector<vertex_t2f_n3f_v3f>::const_iterator i = v.begin (); i < v.end (); ++i)
81	root	1.24	{
82			glTexCoord2fv ((GLfloat *)&i->t);
83			glNormal3fv ((GLfloat *)&i->n);
84			glVertex3fv ((GLfloat *)&i->p);
85			}
86	root	1.4
87	root	1.24	glEnd ();
88	root	1.19	#else
89	root	1.24	glEnableClientState (GL_VERTEX_ARRAY);
90			glEnableClientState (GL_NORMAL_ARRAY);
91			glEnableClientState (GL_TEXTURE_COORD_ARRAY);
92	root	1.46	glVertexPointer (3, GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->p);
93			glNormalPointer (GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->n);
94			glTexCoordPointer (2, GL_FLOAT, sizeof (vertex_t2f_n3f_v3f), (void *)&v.begin ()->t);
95	root	1.19
96	root	1.24	glDrawArrays (type, 0, v.size ());
97	root	1.46
98			glDisableClientState (GL_VERTEX_ARRAY);
99			glDisableClientState (GL_NORMAL_ARRAY);
100			glDisableClientState (GL_TEXTURE_COORD_ARRAY);
101	root	1.19	#endif
102	root	1.22
103	root	1.24	glEndList ();
104			}
105	root	1.2
106	root	1.24	template<GLenum type>
107	root	1.38	void geometry_opengl2d<type>::draw (view &ctx)
108	root	1.24	{
109	root	1.51	m->enable (ctx);
110	root	1.17	glCallList (list);
111	root	1.51	m->disable (ctx);
112	root	1.22	}
113
114	root	1.44	void geometry_sphere::update ()
115			{
116			bbox.reset ();
117			bbox.add (-point (radius, radius, radius));
118			bbox.add ( point (radius, radius, radius));
119
120			geometry::update ();
121			}
122
123			void geometry_sphere::draw (view &ctx)
124			{
125	root	1.48	int n = min (100, max (15, (int)(ctx.pixfact * radius) / 10));
126	root	1.44
127			GLUquadric *quad = gluNewQuadric ();
128			gluQuadricTexture (quad, true);
129			gluSphere (quad, radius, n, n);
130			gluDeleteQuadric (quad);
131			}
132
133	root	1.22	/////////////////////////////////////////////////////////////////////////////
134
135	root	1.38	void geometry_transform::update ()
136	root	1.22	{
137	root	1.38	const box &sub = g->bbox;
138	root	1.27
139			bbox.reset ();
140			bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.a.z));
141			bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.a.z));
142			bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.a.z));
143			bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.a.z));
144			bbox.add (m * vec3 (sub.a.x, sub.a.y, sub.b.z));
145			bbox.add (m * vec3 (sub.b.x, sub.a.y, sub.b.z));
146			bbox.add (m * vec3 (sub.a.x, sub.b.y, sub.b.z));
147			bbox.add (m * vec3 (sub.b.x, sub.b.y, sub.b.z));
148	root	1.22
149	root	1.38	geometry::update ();
150	root	1.28	}
151
152	root	1.38	#if 0
153			void geometry_transform::renormalize ()
154	root	1.28	{
155	root	1.34	point trans(m(0,3), m(1,3), m(2,3));
156			::renormalize (e->orig, trans);
157			m(0,3) = trans.x; m(1,3) = trans.y; m(2,3) = trans.z;
158	root	1.38	}
159	root	1.28	#endif
160
161	root	1.38	void geometry_transform::update (const matrix &xfrm)
162	root	1.28	{
163			m = m * xfrm;
164
165			update ();
166			}
167
168	root	1.38	void geometry_transform::set_matrix (const matrix &xfrm)
169	root	1.28	{
170			m = xfrm;
171
172			update ();
173	root	1.22	}
174
175	root	1.38	void geometry_transform::draw (view &ctx)
176	root	1.22	{
177	root	1.33	glPushMatrix ();
178			glMultMatrixf ((GLfloat *)&m);
179	root	1.38	g->draw (ctx);
180	root	1.33	glPopMatrix ();
181	root	1.2	}
182
183	root	1.38	void geometry_anim::draw (view &ctx)
184	root	1.23	{
185	root	1.30	matrix save_m = m;
186	root	1.23
187	root	1.30	update (matrix::rotation (vx * timer.now, vec3 (1, 0, 0))
188			* matrix::rotation (vy * timer.now, vec3 (0, 1, 0))
189			* matrix::rotation (vz * timer.now, vec3 (0, 0, 1)));
190	root	1.28
191	root	1.38	geometry_transform::draw (ctx);
192	root	1.23
193			m = save_m;
194	root	1.38	}
195
196			/////////////////////////////////////////////////////////////////////////////
197
198			void geometry_filter::set (geometry *g)
199			{
200			this->g = g;
201
202			if (g)
203			g->parent = this;
204
205			update ();
206			}
207
208			void geometry_filter::update ()
209			{
210			if (g)
211			{
212			bbox = g->bbox;
213			geometry::update ();
214			}
215			}
216
217			void geometry_filter::draw (view &ctx)
218			{
219			g->draw (ctx);
220			}
221
222			geometry_filter::~geometry_filter ()
223			{
224			delete g;
225			}
226
227			/////////////////////////////////////////////////////////////////////////////
228
229			void geometry_container::update ()
230			{
231			bbox.reset ();
232
233			for (iterator i = end (); i-- != begin (); )
234			bbox.add ((*i)->bbox);
235
236			geometry::update ();
237			}
238
239			void geometry_container::add (geometry *g)
240			{
241			push_back (g);
242			g->parent = this;
243
244			update ();
245			}
246
247			void geometry_container::draw (view &ctx)
248			{
249			for (iterator i = end (); i-- != begin (); )
250			(*i)->draw (ctx);
251			}
252
253			geometry_container::~geometry_container ()
254			{
255			for (iterator i = end (); i-- != begin (); )
256			delete *i;
257
258			clear ();
259			}
260
261	root	1.52	///////////////////////////////////////////////////////////////////////////
262	root	1.38
263	root	1.39	static void nurbs_error (GLenum errorCode)
264			{
265			const GLubyte *estring;
266			estring = gluErrorString(errorCode);
267			fprintf (stderr, "Nurbs error: %s\n", estring);
268			}
269	root	1.40
270	root	1.39	void errorCallback(GLenum errorCode)
271			{
272			const GLubyte *estring;
273
274			estring = gluErrorString(errorCode);
275			fprintf (stderr, "Tessellation Error: %s\n", estring);
276			exit (0);
277			}
278	root	1.41	void tcbBegin (GLenum prim)
279			{
280			glBegin (prim);
281			}
282			void tcbVertex (void *data)
283			{
284			glVertex3fv ((GLfloat *)data);
285			}
286			void tcbEnd ()
287			{
288			glEnd ();
289			}
290	root	1.39	void geometry_nurbs::set ()
291			{
292			// < XXX >: Testing CODE
293			int u, v;
294			for (u = 0; u < 4; u++) {
295			for (v = 0; v < 4; v++) {
296			ctlpoints[u][v][0] = 2.0*((GLfloat)u - 1.5);
297			ctlpoints[u][v][1] = 2.0*((GLfloat)v - 1.5);
298
299			if ( (u == 1 \|\| u == 2) && (v == 1 \|\| v == 2))
300			ctlpoints[u][v][2] = 3.0;
301			else
302			ctlpoints[u][v][2] = -3.0;
303			}
304			}
305	root	1.41	tess = gluNewTess();
306	root	1.39	// </ XXX >
307	root	1.1
308	root	1.39	glEnable(GL_AUTO_NORMAL);
309			nurb = gluNewNurbsRenderer ();
310	root	1.41	gluNurbsProperty (nurb, GLU_AUTO_LOAD_MATRIX, GL_FALSE);
311			gluNurbsProperty (nurb, GLU_DISPLAY_MODE, GLU_FILL);
312			gluNurbsProperty (nurb, GLU_NURBS_MODE, GLU_NURBS_TESSELLATOR);
313			gluNurbsProperty (nurb, GLU_SAMPLING_METHOD, GLU_OBJECT_PATH_LENGTH);
314			gluNurbsProperty (nurb, GLU_SAMPLING_TOLERANCE, 1.0);
315	root	1.39	gluNurbsCallback (nurb, GLU_ERROR, (GLvoid (*)()) nurbs_error);
316	root	1.41	gluNurbsCallback (nurb, GLU_NURBS_BEGIN, (GLvoid(*)()) tcbBegin);
317			gluNurbsCallback (nurb, GLU_NURBS_VERTEX,(GLvoid(*)()) tcbVertex);
318			gluNurbsCallback (nurb, GLU_NURBS_END, tcbEnd);
319	root	1.39	glDisable(GL_AUTO_NORMAL);
320	root	1.41
321	root	1.39	}
322	root	1.40
323	root	1.39	void geometry_nurbs::draw (view &ctx)
324			{
325			GLfloat knots[8] = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0};
326
327			GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
328			GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
329			GLfloat mat_shininess[] = { 100.0 };
330
331			glClearColor (0.0, 0.0, 0.0, 0.0);
332			glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
333			glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
334			glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
335
336
337			glEnable(GL_AUTO_NORMAL);
338			gluBeginSurface (nurb);
339			gluNurbsSurface (nurb, 8, knots, 8, knots, 4 * 3, 3, &ctlpoints[0][0][0], 4, 4, GL_MAP2_VERTEX_3);
340	root	1.41	gluEndSurface (nurb);
341			/*
342			glEnable(GL_AUTO_NORMAL);
343			glPushMatrix();
344			GL_LG_DEBUG;
345			=======
346	root	1.39
347	root	1.40	gluEndSurface (nurb);
348	root	1.41	>>>>>>> 1.40
349	root	1.39	glDisable(GL_AUTO_NORMAL);
350	root	1.41	glPopMatrix();
351			glFlush();
352			*/
353	root	1.39	}
354	root	1.52
355			/////////////////////////////////////////////////////////////////////////////
356
357			entity::entity (geometry *g)
358			: geometry_filter(g)
359			, p(0,0,0)
360			{
361			update ();
362			}
363
364			entity::~entity ()
365			{
366			hide ();
367			}
368
369			void entity::move (const vec3 &v)
370			{
371			p = p + v;
372
373			renormalize (orig, p);
374
375			update ();
376			}
377
378			void entity::show ()
379			{
380			if (!o.size ())
381			world.add (this);
382			}
383
384			void entity::hide ()
385			{
386			for (vector<octant *>::iterator i = o.end (); i-- != o.begin (); )
387			(*i)->remove (this);
388
389			o.clear ();
390			}
391
392			void entity::update ()
393			{
394			if (!g)
395			return;
396
397			bbox = g->bbox;
398
399			a.x = orig.x + (soffs)floorf (bbox.a.x + p.x);
400			a.y = orig.y + (soffs)floorf (bbox.a.y + p.y);
401			a.z = orig.z + (soffs)floorf (bbox.a.z + p.z);
402			b.x = orig.x + (soffs)ceilf (bbox.b.x + p.x);
403			b.y = orig.y + (soffs)ceilf (bbox.b.y + p.y);
404			b.z = orig.z + (soffs)ceilf (bbox.b.z + p.z);
405
406			if (o.size ())
407			{
408			hide ();
409			show ();
410			}
411			}
412
413			void entity::draw (view &ctx)
414			{
415			sector diff = orig - ctx.orig;
416
417			glPushMatrix ();
418			glTranslatef (diff.x + p.x, diff.y + p.y, diff.z + p.z);
419			g->draw (ctx);
420			glPopMatrix ();
421			}
422
423			/////////////////////////////////////////////////////////////////////////////
424			//
425
426			#define SIZE 33
427
428			struct geometry_heightfield::node
429			{
430			vertex_t2f_n3f_v3f v[SIZE*SIZE];
431			gl::vertex_buffer vb;
432			gl::index_buffer ib;
433			};
434
435			geometry_heightfield::geometry_heightfield ()
436			{
437			update ();
438			}
439
440			void geometry_heightfield::update ()
441			{
442			bbox.a = sector (0, 0, 0);
443			bbox.b = sector (1, 1, 1);
444
445			geometry::update ();
446			}
447
448			void geometry_heightfield::draw (view &ctx)
449			{
450			glBegin (GL_QUADS);
451			glVertex3f (0.F, 0.F, 0.F);
452			glVertex3f (0.F, 0.F, 1.F);
453			glVertex3f (1.F, 0.F, 1.F);
454			glVertex3f (1.F, 0.F, 0.F);
455			glEnd ();
456			}
457