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

struct colour {
  GLfloat r, g, b;
};

struct vect {
  GLfloat x, y, z;
};

struct texc {
  GLfloat u, v;
};

struct box {
  point a, b;

  void reset ()
  {
    a.x = a.y = a.z = GLFLOAT_MAX;
    b.x = b.y = b.z = 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 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 draw ();
};

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

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

struct vertex2d {
  point  v; // vertex
  colour c; // colour
  vect   n; // normal
  texc   t; // texture
};

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_linestrip;
typedef entity_opengl1d<GL_LINE_LOOP>      entity_lineloop;
typedef entity_opengl2d<GL_TRIANGLES>      entity_triangles;
typedef entity_opengl2d<GL_TRIANGLE_STRIP> entity_trianglestrip;
typedef entity_opengl2d<GL_TRIANGLE_FAN>   entity_trianglefan;
typedef entity_opengl2d<GL_QUADS>          entity_quads;
typedef entity_opengl2d<GL_QUAD_STRIP>     entity_quad_strip;
typedef entity_opengl2d<GL_POLYGON>        entity_polygon;

#endif


Revision:	1.1
Committed:	Sat Oct 2 15:54:43 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Log Message:	* empty log message *
#	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			};
25
26			struct colour {
27			GLfloat r, g, b;
28			};
29
30			struct vect {
31			GLfloat x, y, z;
32			};
33
34			struct texc {
35			GLfloat u, v;
36			};
37
38			struct box {
39			point a, b;
40
41			void reset ()
42			{
43			a.x = a.y = a.z = GLFLOAT_MAX;
44			b.x = b.y = b.z = GLFLOAT_MIN;
45			}
46
47			void add (const box &o);
48			};
49
50			struct entity_base {
51			struct entity_base *parent;
52			vector<octant *> o;
53			box bbox;
54
55			virtual void update_bbox ();
56			virtual void show (const sector &sec) { };
57			void hide ();
58			virtual void draw () = 0;
59			virtual ~entity_base ()
60			{
61			hide ();
62			};
63			};
64
65			struct entity_container : entity_base, protected vector<entity_base *> {
66			void update_bbox ();
67			void show (const sector &sec);
68			void draw ();
69			~entity_container ();
70			};
71
72			struct entity_filter : entity_base {
73			protected:
74			entity_base *e;
75			public:
76
77			void set (entity_base *e)
78			{
79			this->e = e;
80			e->parent = this;
81			}
82
83			void remove ()
84			{
85			this->e->parent = 0;
86			this->e = 0;
87			}
88
89			entity_base *content () { return e; };
90
91			void update_bbox ();
92			void show (const sector &sec);
93			void draw ();
94			~entity_filter ();
95			};
96
97			struct entity : entity_filter {
98			sector sec;
99
100			void show (const sector &sec);
101			void draw ();
102			};
103
104			struct entity_affine : entity_filter {
105			//matrix m;
106			};
107
108			struct vertex1d {
109			point v; // vertex
110			colour c; // colour
111			};
112
113			struct vertex2d {
114			point v; // vertex
115			colour c; // colour
116			vect n; // normal
117			texc t; // texture
118			};
119
120			template<GLenum type>
121			struct entity_opengl1d : entity_base, vector<vertex1d> {
122			void update_bbox ();
123			void show (const sector &sec);
124			void draw ();
125			};
126
127			template<GLenum type>
128			struct entity_opengl2d : entity_base, vector<vertex2d> {
129			void update_bbox ();
130			void show (const sector &sec);
131			void draw ();
132			};
133
134			typedef entity_opengl1d<GL_POINTS> entity_points;
135			typedef entity_opengl1d<GL_LINES> entity_lines;
136			typedef entity_opengl1d<GL_LINE_STRIP> entity_linestrip;
137			typedef entity_opengl1d<GL_LINE_LOOP> entity_lineloop;
138			typedef entity_opengl2d<GL_TRIANGLES> entity_triangles;
139			typedef entity_opengl2d<GL_TRIANGLE_STRIP> entity_trianglestrip;
140			typedef entity_opengl2d<GL_TRIANGLE_FAN> entity_trianglefan;
141			typedef entity_opengl2d<GL_QUADS> entity_quads;
142			typedef entity_opengl2d<GL_QUAD_STRIP> entity_quad_strip;
143			typedef entity_opengl2d<GL_POLYGON> entity_polygon;
144
145			#endif
146
147
148