libgender/view.h

#ifndef VIEW_H
#define VIEW_H

#include <set>
#include <map>
#include <utility>

using namespace std;

#include "util.h"
#include "event.h"
#include "shader.h"

extern struct skybox *world_skybox;

struct visibility_base
{
  unsigned int generation; // freshness check
};

struct visible {
  visibility_base *get_visibility (view &ctx);
  virtual visibility_base *new_visibility () = 0;
  virtual void clear_visibility (visibility_base *vs) = 0;
};

struct occ_query
{
  struct view &ctx;
  void *id;
  GLuint count;

  occ_query (view &ctx, void *id, GLuint count) : ctx(ctx), id(id), count(count) { };
};

enum pass_type {
  DEPTH,        // mandatory, render depth only
  POSTDEPTH,    // mandatory, occ tests or ignored
  LIGHTED,      // optional, render faces in full glory
};

struct pass_data
{
  pass_type type;

  struct light *l;

  typedef map<struct material *, shader::program_object> matmap_t;
  matmap_t matmap;

  pass_data (light *l, pass_type type = LIGHTED) : l(l), type(type) { }
};

extern pass_data pass_depth; // the standard depth pass
extern pass_data pass_postdepth; // the standard post-depth pass

struct view
{
  sector orig;
  point p;
  vec3 d, u;
  GLfloat fov;
  GLfloat z_near, z_far, c_far;
  int w, h;
  GLfloat pixfact; // how many pixels on screen are drawn by a unit length line, *roughly*
  sector eorig; // orig of currently-rendered entity in relation to the camera

  GLfloat gamma;

  // only to be used by friends: TODO

  GLfloat nz_far, nz_near, nc_far;
  GLfloat diagfact; // bounding box border to depth factor
  GLfloat perspfact; // perspfact * (1/depth)=> pixels

  struct {
    plane l, r, t, b, n, f;
    cone c;
    sphere s;
  } frustum;

  pass_data *pass;
  bool first_lighted; // first lighted pass

  set<const entity *> drawn; // TODO: put drawn info and octant+entity visibility info into vismap!

  unsigned int generation;
  typedef map<visible *, visibility_base *> visibility_map;
  visibility_map vismap;

  vector<octant *> vislist; // octants that want to be drawn
  vector<octant *> postdepthlist; // octants that want to checked

  struct oq_data {
    GLint id;
    int *res; // not GLuint because -1 is so nice a flag

    oq_data (GLint id, int &res) : id(id), res(&res) { };
  };
  vector<oq_data> occ_queries;
  void begin_occ_query (int &res);
  void end_occ_query ();

  void reset_projection ();

  // public
  
  void begin ();
  void render (pass_data &pass);
  void end ();

  bool may_draw (const entity *e);

  view ();
  ~view ();

  int stat1; //D
  int stat2; //D
};

struct light : view
{
  // the following variables are valid in the fragment shader as well as in the vertex shader
  bool has_lightvec;           // is a light vector available?
  shader::temp_3f sh_lightvec;  // not defined unless has_lightvec is true
  shader::temp_3f sh_colour;    // always available for any light

  virtual void enable (view &ctx);
  virtual void disable (view &ctx);

  virtual void vsh () = 0; // vertex shader
  virtual void fsh () = 0; // fragment shader

protected:
  shader::varying_3f lightvec;
  shader::varying_1f camdist;
  shader::uniform_3f lightpos; // or direction
};

struct linear_light : light
{
  colour c;
  GLfloat intensity;
  GLfloat radius;

  void enable (view &ctx);
  void disable (view &ctx);

  void vsh ();
  void fsh ();
};

#endif

Revision:	1.41
Committed:	Thu Aug 11 19:28:45 2005 UTC (20 years, 7 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.40:	+3 -6 lines
Log Message:	* empty log message *
#	Content
1	#ifndef VIEW_H
2	#define VIEW_H
3
4	#include <set>
5	#include <map>
6	#include <utility>
7
8	using namespace std;
9
10	#include "util.h"
11	#include "event.h"
12	#include "shader.h"
13
14	extern struct skybox *world_skybox;
15
16	struct visibility_base
17	{
18	unsigned int generation; // freshness check
19	};
20
21	struct visible {
22	visibility_base *get_visibility (view &ctx);
23	virtual visibility_base *new_visibility () = 0;
24	virtual void clear_visibility (visibility_base *vs) = 0;
25	};
26
27	struct occ_query
28	{
29	struct view &ctx;
30	void *id;
31	GLuint count;
32
33	occ_query (view &ctx, void *id, GLuint count) : ctx(ctx), id(id), count(count) { };
34	};
35
36	enum pass_type {
37	DEPTH, // mandatory, render depth only
38	POSTDEPTH, // mandatory, occ tests or ignored
39	LIGHTED, // optional, render faces in full glory
40	};
41
42	struct pass_data
43	{
44	pass_type type;
45
46	struct light *l;
47
48	typedef map<struct material *, shader::program_object> matmap_t;
49	matmap_t matmap;
50
51	pass_data (light *l, pass_type type = LIGHTED) : l(l), type(type) { }
52	};
53
54	extern pass_data pass_depth; // the standard depth pass
55	extern pass_data pass_postdepth; // the standard post-depth pass
56
57	struct view
58	{
59	sector orig;
60	point p;
61	vec3 d, u;
62	GLfloat fov;
63	GLfloat z_near, z_far, c_far;
64	int w, h;
65	GLfloat pixfact; // how many pixels on screen are drawn by a unit length line, roughly
66	sector eorig; // orig of currently-rendered entity in relation to the camera
67
68	GLfloat gamma;
69
70	// only to be used by friends: TODO
71
72	GLfloat nz_far, nz_near, nc_far;
73	GLfloat diagfact; // bounding box border to depth factor
74	GLfloat perspfact; // perspfact * (1/depth)=> pixels
75
76	struct {
77	plane l, r, t, b, n, f;
78	cone c;
79	sphere s;
80	} frustum;
81
82	pass_data *pass;
83	bool first_lighted; // first lighted pass
84
85	set<const entity *> drawn; // TODO: put drawn info and octant+entity visibility info into vismap!
86
87	unsigned int generation;
88	typedef map<visible , visibility_base > visibility_map;
89	visibility_map vismap;
90
91	vector<octant *> vislist; // octants that want to be drawn
92	vector<octant *> postdepthlist; // octants that want to checked
93
94	struct oq_data {
95	GLint id;
96	int *res; // not GLuint because -1 is so nice a flag
97
98	oq_data (GLint id, int &res) : id(id), res(&res) { };
99	};
100	vector<oq_data> occ_queries;
101	void begin_occ_query (int &res);
102	void end_occ_query ();
103
104	void reset_projection ();
105
106	// public
107
108	void begin ();
109	void render (pass_data &pass);
110	void end ();
111
112	bool may_draw (const entity *e);
113
114	view ();
115	~view ();
116
117	int stat1; //D
118	int stat2; //D
119	};
120
121	struct light : view
122	{
123	// the following variables are valid in the fragment shader as well as in the vertex shader
124	bool has_lightvec; // is a light vector available?
125	shader::temp_3f sh_lightvec; // not defined unless has_lightvec is true
126	shader::temp_3f sh_colour; // always available for any light
127
128	virtual void enable (view &ctx);
129	virtual void disable (view &ctx);
130
131	virtual void vsh () = 0; // vertex shader
132	virtual void fsh () = 0; // fragment shader
133
134	protected:
135	shader::varying_3f lightvec;
136	shader::varying_1f camdist;
137	shader::uniform_3f lightpos; // or direction
138	};
139
140	struct linear_light : light
141	{
142	colour c;
143	GLfloat intensity;
144	GLfloat radius;
145
146	void enable (view &ctx);
147	void disable (view &ctx);
148
149	void vsh ();
150	void fsh ();
151	};
152
153	#endif
154