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 *
#	Content
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