libgender/entity.h

#ifndef ENTITY_H
#define ENTITY_H

#include <vector>

#include "opengl.h"

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

using namespace std;

struct geometry
{
  geometry *parent;
  box bbox;

  virtual void update ()
  {
    if (parent)
      parent->update ();
  }

  virtual void draw (view &ctx) = 0;
  geometry (geometry *parent = 0) : parent(parent) { };
  virtual ~geometry ();
};

struct vertex1d
{
  colour c; // colour
  point  p; // vertex
};

struct vertex2d
{
  point p; // vertex
  vec3  n; // normal
  texc  t; // texture

  vertex2d () { };
  vertex2d (point p, vec3 n, texc t = texc()) : p(p), n(n), t(t) { };
};

struct geometry_opengl : geometry
{
  GLuint list; // TODO: dynamic caching

  geometry_opengl ();
  ~geometry_opengl ();
};

template<GLenum type>
struct geometry_opengl1d : geometry_opengl, vector<vertex1d>
{
  void set (const vector<vertex1d> &v);
  void draw (view &ctx);
};

template<GLenum type>
struct geometry_opengl2d : geometry_opengl
{
  material *m;

  geometry_opengl2d () : m(0) { };

  void set (const vector<vertex2d> &v);
  void draw (view &ctx);
};

typedef geometry_opengl1d<GL_POINTS>         geometry_points;
typedef geometry_opengl1d<GL_LINES>          geometry_lines;
typedef geometry_opengl1d<GL_LINE_STRIP>     geometry_line_strip;
typedef geometry_opengl1d<GL_LINE_LOOP>      geometry_line_loop;
typedef geometry_opengl2d<GL_TRIANGLES>      geometry_triangles;
typedef geometry_opengl2d<GL_TRIANGLE_STRIP> geometry_triangle_strip;
typedef geometry_opengl2d<GL_TRIANGLE_FAN>   geometry_triangle_fan;
typedef geometry_opengl2d<GL_QUADS>          geometry_quads;
typedef geometry_opengl2d<GL_QUAD_STRIP>     geometry_quad_strip;
typedef geometry_opengl2d<GL_POLYGON>        geometry_polygon;

struct geometry_nurbs : geometry, vector<vertex2d>
{
  GLUnurbsObj *nurb;
  GLUtesselator *tess;
  GLfloat ctlpoints[4][4][3];

  geometry_nurbs() : tess(0), nurb(0) { }
  virtual void draw (view &ctx);
  void set ();
};

struct geometry_sphere : geometry
{
  GLfloat radius;

  void update ();
  void draw (view &ctx);
  geometry_sphere (GLfloat radius) : radius(radius) { update (); };
};

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

struct geometry_filter : geometry
{
protected:
  geometry *g;
public:

  void set (geometry *g);

  geometry *content () { return g; };

  void update ();
  void show ();
  void draw (view &ctx);
  geometry_filter (geometry *g = 0) { set (g); }
  ~geometry_filter ();
};

struct geometry_transform : geometry_filter
{
protected:
  matrix m;
public:
  void update ();

  void show ();
  void draw (view &ctx);
  void set_matrix (const matrix &xfrm);
  void update (const matrix &xfrm);

  geometry_transform (geometry *g) : geometry_filter(g), m(1) { };
  geometry_transform () : geometry_filter(0), m(1) { };
};

struct geometry_anim : geometry_transform
{
  GLfloat vx, vy, vz;
  void draw (view &ctx);
};

struct geometry_container : geometry, protected vector<geometry *>
{
  void update ();

  void add (geometry *g);
  void draw (view &ctx);
  ~geometry_container ();
};

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

struct entity : geometry_filter
{
  sector orig;
  point p;
  sector a, b; // bounding box corners

  vector<octant *> o;

  void update ();
  void draw (view &ctx);

  void move (const vec3 &v);

  virtual void show ();
  virtual void hide ();
  void display (view &ctx);

  entity (geometry *g = 0);
  ~entity ();
};

struct light : entity
{
  point p;
  colour c;
  GLfloat intensity;
  GLfloat radius;
};

#endif


Revision:	1.23
Committed:	Mon Oct 11 00:05:48 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.22:	+11 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#ifndef ENTITY_H
2			#define ENTITY_H
3
4	root	1.22	#include <vector>
5	root	1.1
6	root	1.22	#include "opengl.h"
7	root	1.1
8	root	1.5	#include "util.h"
9	root	1.1	#include "oct.h"
10	root	1.8	#include "view.h"
11	root	1.22	#include "material.h"
12	root	1.1
13			using namespace std;
14
15	root	1.22	struct geometry
16			{
17	root	1.19	geometry *parent;
18	root	1.1	box bbox;
19
20	root	1.19	virtual void update ()
21	root	1.15	{
22	root	1.19	if (parent)
23			parent->update ();
24	root	1.15	}
25
26	root	1.19	virtual void draw (view &ctx) = 0;
27			geometry (geometry *parent = 0) : parent(parent) { };
28			virtual ~geometry ();
29	root	1.1	};
30
31	root	1.22	struct vertex1d
32			{
33	root	1.3	colour c; // colour
34	root	1.2	point p; // vertex
35	root	1.1	};
36
37	root	1.22	struct vertex2d
38			{
39	root	1.6	point p; // vertex
40			vec3 n; // normal
41			texc t; // texture
42	root	1.3
43			vertex2d () { };
44	root	1.6	vertex2d (point p, vec3 n, texc t = texc()) : p(p), n(n), t(t) { };
45			};
46
47	root	1.22	struct geometry_opengl : geometry
48			{
49	root	1.19	GLuint list; // TODO: dynamic caching
50	root	1.13
51	root	1.19	geometry_opengl ();
52			~geometry_opengl ();
53	root	1.1	};
54
55			template<GLenum type>
56	root	1.22	struct geometry_opengl1d : geometry_opengl, vector<vertex1d>
57			{
58	root	1.19	void set (const vector<vertex1d> &v);
59	root	1.18	void draw (view &ctx);
60	root	1.1	};
61
62			template<GLenum type>
63	root	1.22	struct geometry_opengl2d : geometry_opengl
64			{
65			material *m;
66
67			geometry_opengl2d () : m(0) { };
68	root	1.6
69	root	1.13	void set (const vector<vertex2d> &v);
70	root	1.18	void draw (view &ctx);
71	root	1.1	};
72
73	root	1.19	typedef geometry_opengl1d<GL_POINTS> geometry_points;
74			typedef geometry_opengl1d<GL_LINES> geometry_lines;
75			typedef geometry_opengl1d<GL_LINE_STRIP> geometry_line_strip;
76			typedef geometry_opengl1d<GL_LINE_LOOP> geometry_line_loop;
77			typedef geometry_opengl2d<GL_TRIANGLES> geometry_triangles;
78			typedef geometry_opengl2d<GL_TRIANGLE_STRIP> geometry_triangle_strip;
79			typedef geometry_opengl2d<GL_TRIANGLE_FAN> geometry_triangle_fan;
80			typedef geometry_opengl2d<GL_QUADS> geometry_quads;
81			typedef geometry_opengl2d<GL_QUAD_STRIP> geometry_quad_strip;
82			typedef geometry_opengl2d<GL_POLYGON> geometry_polygon;
83	root	1.20
84	root	1.22	struct geometry_nurbs : geometry, vector<vertex2d>
85			{
86	root	1.20	GLUnurbsObj *nurb;
87	root	1.21	GLUtesselator *tess;
88	root	1.20	GLfloat ctlpoints[4][4][3];
89
90	root	1.21	geometry_nurbs() : tess(0), nurb(0) { }
91	root	1.20	virtual void draw (view &ctx);
92			void set ();
93			};
94	root	1.11
95	root	1.23	struct geometry_sphere : geometry
96			{
97			GLfloat radius;
98
99			void update ();
100			void draw (view &ctx);
101			geometry_sphere (GLfloat radius) : radius(radius) { update (); };
102			};
103
104			/////////////////////////////////////////////////////////////////////////////
105
106	root	1.22	struct geometry_filter : geometry
107			{
108	root	1.16	protected:
109	root	1.19	geometry *g;
110	root	1.16	public:
111	root	1.11
112	root	1.19	void set (geometry *g);
113
114			geometry *content () { return g; };
115	root	1.11
116	root	1.16	void update ();
117	root	1.11	void show ();
118	root	1.18	void draw (view &ctx);
119	root	1.19	geometry_filter (geometry *g = 0) { set (g); }
120			~geometry_filter ();
121			};
122
123	root	1.22	struct geometry_transform : geometry_filter
124			{
125	root	1.19	protected:
126			matrix m;
127			public:
128			void update ();
129
130			void show ();
131			void draw (view &ctx);
132	root	1.17	void set_matrix (const matrix &xfrm);
133			void update (const matrix &xfrm);
134	root	1.19
135			geometry_transform (geometry *g) : geometry_filter(g), m(1) { };
136			geometry_transform () : geometry_filter(0), m(1) { };
137	root	1.11	};
138	root	1.1
139	root	1.22	struct geometry_anim : geometry_transform
140			{
141	root	1.12	GLfloat vx, vy, vz;
142	root	1.18	void draw (view &ctx);
143	root	1.19	};
144
145	root	1.22	struct geometry_container : geometry, protected vector<geometry *>
146			{
147	root	1.19	void update ();
148
149			void add (geometry *g);
150			void draw (view &ctx);
151			~geometry_container ();
152			};
153
154			/////////////////////////////////////////////////////////////////////////////
155
156	root	1.22	struct entity : geometry_filter
157			{
158	root	1.19	sector orig;
159			point p;
160			sector a, b; // bounding box corners
161
162			vector<octant *> o;
163
164			void update ();
165			void draw (view &ctx);
166
167			void move (const vec3 &v);
168
169	root	1.22	virtual void show ();
170			virtual void hide ();
171	root	1.19	void display (view &ctx);
172
173			entity (geometry *g = 0);
174			~entity ();
175	root	1.12	};
176	root	1.22
177			struct light : entity
178			{
179			point p;
180			colour c;
181			GLfloat intensity;
182			GLfloat radius;
183			};
184
185	root	1.1	#endif
186
187
188