libgender/entity.h

#ifndef ENTITY_H
#define ENTITY_H

#include <GL/gl.h>

#include <vector>

#include "util.h"
#include "oct.h"

using namespace std;

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 (const draw_context &ctx) = 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 (const draw_context &ctx);
  ~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 (const draw_context &ctx);
  ~entity_filter ();
};

struct entity : entity_filter {
  sector sec;

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

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 (const draw_context &ctx);
};

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

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 view {
  point p;
  vec3 d, u;
  float fov;
  int w, h;

  void draw (const draw_context &ctx);
};

#endif


Revision:	1.5
Committed:	Sun Oct 3 02:38:33 2004 UTC (19 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+8 -71 lines
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	root	1.5	#include "util.h"
9	root	1.1	#include "oct.h"
10
11			using namespace std;
12
13			struct entity_base {
14			struct entity_base *parent;
15			vector<octant *> o;
16			box bbox;
17
18			virtual void update_bbox ();
19			virtual void show (const sector &sec) { };
20			void hide ();
21	root	1.5	virtual void draw (const draw_context &ctx) = 0;
22	root	1.1	virtual ~entity_base ()
23			{
24			hide ();
25			};
26			};
27
28			struct entity_container : entity_base, protected vector<entity_base *> {
29	root	1.4	void add (entity_base *e) { push_back (e); e->parent = this; }
30	root	1.1	void update_bbox ();
31			void show (const sector &sec);
32	root	1.5	void draw (const draw_context &ctx);
33	root	1.1	~entity_container ();
34			};
35
36			struct entity_filter : entity_base {
37			protected:
38			entity_base *e;
39			public:
40
41			void set (entity_base *e)
42			{
43			this->e = e;
44			e->parent = this;
45			}
46
47			void remove ()
48			{
49			this->e->parent = 0;
50			this->e = 0;
51			}
52
53			entity_base *content () { return e; };
54
55			void update_bbox ();
56			void show (const sector &sec);
57	root	1.5	void draw (const draw_context &ctx);
58	root	1.1	~entity_filter ();
59			};
60
61			struct entity : entity_filter {
62			sector sec;
63
64			void show (const sector &sec);
65	root	1.3	void show ();
66	root	1.5	void draw (const draw_context &ctx);
67	root	1.1	};
68
69			struct entity_affine : entity_filter {
70			//matrix m;
71			};
72
73			struct vertex1d {
74	root	1.3	colour c; // colour
75	root	1.2	point p; // vertex
76	root	1.1	};
77
78			struct vertex2d {
79	root	1.3	colour c; // colour
80	root	1.2	point p; // vertex
81	root	1.3	vec3 n; // normal
82	root	1.1	texc t; // texture
83	root	1.3
84			vertex2d () { };
85			vertex2d (colour c, point p, vec3 n, texc t = texc()) : c(c), p(p), n(n), t(t) { };
86	root	1.1	};
87
88			template<GLenum type>
89			struct entity_opengl1d : entity_base, vector<vertex1d> {
90			void update_bbox ();
91			void show (const sector &sec);
92	root	1.5	void draw (const draw_context &ctx);
93	root	1.1	};
94
95			template<GLenum type>
96			struct entity_opengl2d : entity_base, vector<vertex2d> {
97			void update_bbox ();
98			void show (const sector &sec);
99	root	1.5	void draw (const draw_context &ctx);
100	root	1.1	};
101
102			typedef entity_opengl1d<GL_POINTS> entity_points;
103			typedef entity_opengl1d<GL_LINES> entity_lines;
104	root	1.2	typedef entity_opengl1d<GL_LINE_STRIP> entity_line_strip;
105			typedef entity_opengl1d<GL_LINE_LOOP> entity_line_loop;
106	root	1.1	typedef entity_opengl2d<GL_TRIANGLES> entity_triangles;
107	root	1.2	typedef entity_opengl2d<GL_TRIANGLE_STRIP> entity_triangle_strip;
108			typedef entity_opengl2d<GL_TRIANGLE_FAN> entity_triangle_fan;
109	root	1.1	typedef entity_opengl2d<GL_QUADS> entity_quads;
110			typedef entity_opengl2d<GL_QUAD_STRIP> entity_quad_strip;
111			typedef entity_opengl2d<GL_POLYGON> entity_polygon;
112	root	1.2
113			struct view {
114			point p;
115	root	1.3	vec3 d, u;
116	root	1.2	float fov;
117	root	1.3	int w, h;
118	root	1.2
119	root	1.5	void draw (const draw_context &ctx);
120	root	1.2	};
121	root	1.1
122			#endif
123
124
125