libgender/entity.h

#ifndef ENTITY_H
#define ENTITY_H

#include <GL/gl.h>

#include <vector>

#include "oct.h"

using namespace std;

typedef unsigned int soffs; // 32 bit
const soffs soffs_max = 1UL << 31;

#define GLFLOAT_MAX 1e30
#define GLFLOAT_MIN -1e30

struct sector {
  soffs x, y, z;
};

struct point {
  GLfloat x, y, z;

  point () { };
  point (GLfloat x, GLfloat y, GLfloat z) : x(x), y(y), z(z) { };
};

struct colour {
  GLfloat r, g, b;
  colour (GLfloat r = 1., GLfloat g = 1., GLfloat b = 1.) : r(r), g(g), b(b) { };
};

struct vec3 {
  GLfloat x, y, z;
  vec3 () { };
  vec3 (GLfloat x, GLfloat y, GLfloat z) : x(x), y(y), z(z) { };

  const vec3 operator -() const
  { return vec3 (-x, -y, -z); }
};

const vec3 cross (const vec3 &a, const vec3 &b);
GLfloat dot (const vec3 &a, const vec3 &b);

struct texc {
  GLfloat s, t;
  texc () { };
  texc (GLfloat s, GLfloat t) : s(s), t(t) { };
};

struct box {
  point a, b;

  void reset ()
  {
    a = point (GLFLOAT_MAX, GLFLOAT_MAX, GLFLOAT_MAX);
    b = point (GLFLOAT_MIN, GLFLOAT_MIN, GLFLOAT_MIN);
  }

  void add (const box &o);
};

struct entity_base {
  struct entity_base *parent;
  vector<octant *> o;
  box bbox;

  virtual void update_bbox ();
  virtual void show (const sector &sec) { };
  void hide ();
  virtual void draw () = 0;
  virtual ~entity_base ()
  {
    hide ();
  };
};

struct entity_container : entity_base, protected vector<entity_base *> {
  void add (entity_base *e) { push_back (e); e->parent = this; }
  void update_bbox ();
  void show (const sector &sec);
  void draw ();
  ~entity_container ();
};

struct entity_filter : entity_base {
protected:
  entity_base *e;
public:

  void set (entity_base *e)
  {
    this->e = e;
    e->parent = this;
  }

  void remove ()
  {
    this->e->parent = 0;
    this->e = 0;
  }

  entity_base *content () { return e; };

  void update_bbox ();
  void show (const sector &sec);
  void draw ();
  ~entity_filter ();
};

struct entity : entity_filter {
  sector sec;

  void show (const sector &sec);
  void show ();
  void draw ();
};

struct entity_affine : entity_filter {
  //matrix m;
};

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

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

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

template<GLenum type>
struct entity_opengl1d : entity_base, vector<vertex1d> {
  void update_bbox ();
  void show (const sector &sec);
  void draw ();
};

template<GLenum type>
struct entity_opengl2d : entity_base, vector<vertex2d> {
  void update_bbox ();
  void show (const sector &sec);
  void draw ();
};

typedef entity_opengl1d<GL_POINTS>         entity_points;
typedef entity_opengl1d<GL_LINES>          entity_lines;
typedef entity_opengl1d<GL_LINE_STRIP>     entity_line_strip;
typedef entity_opengl1d<GL_LINE_LOOP>      entity_line_loop;
typedef entity_opengl2d<GL_TRIANGLES>      entity_triangles;
typedef entity_opengl2d<GL_TRIANGLE_STRIP> entity_triangle_strip;
typedef entity_opengl2d<GL_TRIANGLE_FAN>   entity_triangle_fan;
typedef entity_opengl2d<GL_QUADS>          entity_quads;
typedef entity_opengl2d<GL_QUAD_STRIP>     entity_quad_strip;
typedef entity_opengl2d<GL_POLYGON>        entity_polygon;

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

struct draw_context {
  enum { DEPTH, AMBIENT, LIGHTED } mode;
  light *l;
};

struct view {
  point p;
  vec3 d, u;
  float fov;
  int w, h;

  void draw (const draw_context &c);
};

#endif


Revision:	1.4
Committed:	Sun Oct 3 02:37:55 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+1 -0 lines
Log Message:	add method in entity_container
#	User	Rev	Content
1	root	1.1	#ifndef ENTITY_H
2			#define ENTITY_H
3
4			#include <GL/gl.h>
5
6			#include <vector>
7
8			#include "oct.h"
9
10			using namespace std;
11
12			typedef unsigned int soffs; // 32 bit
13			const soffs soffs_max = 1UL << 31;
14
15			#define GLFLOAT_MAX 1e30
16			#define GLFLOAT_MIN -1e30
17
18			struct sector {
19			soffs x, y, z;
20			};
21
22			struct point {
23			GLfloat x, y, z;
24	root	1.3
25			point () { };
26			point (GLfloat x, GLfloat y, GLfloat z) : x(x), y(y), z(z) { };
27	root	1.1	};
28
29			struct colour {
30			GLfloat r, g, b;
31	root	1.3	colour (GLfloat r = 1., GLfloat g = 1., GLfloat b = 1.) : r(r), g(g), b(b) { };
32	root	1.1	};
33
34	root	1.3	struct vec3 {
35	root	1.1	GLfloat x, y, z;
36	root	1.3	vec3 () { };
37			vec3 (GLfloat x, GLfloat y, GLfloat z) : x(x), y(y), z(z) { };
38
39			const vec3 operator -() const
40			{ return vec3 (-x, -y, -z); }
41	root	1.1	};
42
43	root	1.3	const vec3 cross (const vec3 &a, const vec3 &b);
44			GLfloat dot (const vec3 &a, const vec3 &b);
45
46	root	1.1	struct texc {
47	root	1.3	GLfloat s, t;
48			texc () { };
49			texc (GLfloat s, GLfloat t) : s(s), t(t) { };
50	root	1.1	};
51
52			struct box {
53			point a, b;
54
55			void reset ()
56			{
57	root	1.3	a = point (GLFLOAT_MAX, GLFLOAT_MAX, GLFLOAT_MAX);
58			b = point (GLFLOAT_MIN, GLFLOAT_MIN, GLFLOAT_MIN);
59	root	1.1	}
60
61			void add (const box &o);
62			};
63
64			struct entity_base {
65			struct entity_base *parent;
66			vector<octant *> o;
67			box bbox;
68
69			virtual void update_bbox ();
70			virtual void show (const sector &sec) { };
71			void hide ();
72			virtual void draw () = 0;
73			virtual ~entity_base ()
74			{
75			hide ();
76			};
77			};
78
79			struct entity_container : entity_base, protected vector<entity_base *> {
80	root	1.4	void add (entity_base *e) { push_back (e); e->parent = this; }
81	root	1.1	void update_bbox ();
82			void show (const sector &sec);
83			void draw ();
84			~entity_container ();
85			};
86
87			struct entity_filter : entity_base {
88			protected:
89			entity_base *e;
90			public:
91
92			void set (entity_base *e)
93			{
94			this->e = e;
95			e->parent = this;
96			}
97
98			void remove ()
99			{
100			this->e->parent = 0;
101			this->e = 0;
102			}
103
104			entity_base *content () { return e; };
105
106			void update_bbox ();
107			void show (const sector &sec);
108			void draw ();
109			~entity_filter ();
110			};
111
112			struct entity : entity_filter {
113			sector sec;
114
115			void show (const sector &sec);
116	root	1.3	void show ();
117	root	1.1	void draw ();
118			};
119
120			struct entity_affine : entity_filter {
121			//matrix m;
122			};
123
124			struct vertex1d {
125	root	1.3	colour c; // colour
126	root	1.2	point p; // vertex
127	root	1.1	};
128
129			struct vertex2d {
130	root	1.3	colour c; // colour
131	root	1.2	point p; // vertex
132	root	1.3	vec3 n; // normal
133	root	1.1	texc t; // texture
134	root	1.3
135			vertex2d () { };
136			vertex2d (colour c, point p, vec3 n, texc t = texc()) : c(c), p(p), n(n), t(t) { };
137	root	1.1	};
138
139			template<GLenum type>
140			struct entity_opengl1d : entity_base, vector<vertex1d> {
141			void update_bbox ();
142			void show (const sector &sec);
143			void draw ();
144			};
145
146			template<GLenum type>
147			struct entity_opengl2d : entity_base, vector<vertex2d> {
148			void update_bbox ();
149			void show (const sector &sec);
150			void draw ();
151			};
152
153			typedef entity_opengl1d<GL_POINTS> entity_points;
154			typedef entity_opengl1d<GL_LINES> entity_lines;
155	root	1.2	typedef entity_opengl1d<GL_LINE_STRIP> entity_line_strip;
156			typedef entity_opengl1d<GL_LINE_LOOP> entity_line_loop;
157	root	1.1	typedef entity_opengl2d<GL_TRIANGLES> entity_triangles;
158	root	1.2	typedef entity_opengl2d<GL_TRIANGLE_STRIP> entity_triangle_strip;
159			typedef entity_opengl2d<GL_TRIANGLE_FAN> entity_triangle_fan;
160	root	1.1	typedef entity_opengl2d<GL_QUADS> entity_quads;
161			typedef entity_opengl2d<GL_QUAD_STRIP> entity_quad_strip;
162			typedef entity_opengl2d<GL_POLYGON> entity_polygon;
163	root	1.2
164			struct light {
165			point p;
166			colour c;
167			GLfloat intensity;
168			GLfloat radius;
169			};
170
171			struct draw_context {
172			enum { DEPTH, AMBIENT, LIGHTED } mode;
173			light *l;
174			};
175
176			struct view {
177			point p;
178	root	1.3	vec3 d, u;
179	root	1.2	float fov;
180	root	1.3	int w, h;
181	root	1.2
182			void draw (const draw_context &c);
183			};
184	root	1.1
185			#endif
186
187
188