WebSVN – gelsvn – Diff – /trunk/src/GLGraphics/draw.cpp


#include <GL/glew.h>
 
#include "CGLA/Mat4x4f.h"
#include "CGLA/Vec3d.h"
#include "draw.h"
#include "HMesh/FaceCirculator.h"
 
#include "SinglePassWireframeRenderer.h"
#include "IDBufferWireFrameRenderer.h"
#include "SOIL.h"
 
using namespace CGLA;
using namespace HMesh;
using namespace std;
 
namespace 
{
	void set_material(const Geometry::Material& material)
	{
		if(material.has_texture && material.tex_id >=0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, material.tex_id);
			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		}
		else
			glDisable(GL_TEXTURE_2D);
		
		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material.ambient);
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material.diffuse);
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material.specular);
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.shininess);
	}
	
}
 
namespace GLGraphics
{
	
	void draw(Manifold& m, bool per_vertex_norms)
	{
		for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
		{
			FaceCirculator fc(f);
			if(!per_vertex_norms) 
				glNormal3fv(normal(f).get());
			if(no_edges(f)== 3) 
				glBegin(GL_TRIANGLES);
			else 
				glBegin(GL_POLYGON);
			while(!fc.end())
			{
				Vec3f n = normal(fc.get_vertex());
				if(per_vertex_norms) 
					glNormal3fv(n.get());
				glVertex3fv(fc.get_vertex()->pos.get());
				++fc;
			}
			glEnd();
		}
	}
 
	void draw(const Geometry::IndexedFaceSet& geometry)
	{
		glBegin(GL_TRIANGLES);
		for(int i=0;i<geometry.no_faces();i++)
		{
				Vec3i g_face = geometry.face(i);
				Vec3f vert0 = geometry.vertex(g_face[0]);
				Vec3f vert1 = geometry.vertex(g_face[1]);
				Vec3f vert2 = geometry.vertex(g_face[2]);
				Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));
				glNormal3fv(norm.get());
				glVertex3fv(vert0.get());
				glVertex3fv(vert1.get());
				glVertex3fv(vert2.get());
		}
		glEnd();
	}
	
	void draw(const Geometry::TriMesh& tm, bool per_vertex_norms)
	{
		int old_mat_idx = -1;
		glBegin(GL_TRIANGLES);
		for(int i=0;i<tm.geometry.no_faces();i++)
		{
			int new_mat_idx = i<static_cast<int>(tm.mat_idx.size()) ? tm.mat_idx[i] : -1;
			if(new_mat_idx != old_mat_idx)
			{
				glEnd();
				set_material(tm.materials[tm.mat_idx[i]]);
				glBegin(GL_TRIANGLES);
				old_mat_idx = new_mat_idx;
			}
			Vec3i n_face = tm.normals.face(i);
			Vec3i g_face = tm.geometry.face(i);
			Vec3i t_face = tm.texcoords.face(i);
			
			if(!per_vertex_norms)
			{
				Vec3f vert0 = tm.geometry.vertex(g_face[0]);
				Vec3f vert1 = tm.geometry.vertex(g_face[1]);
				Vec3f vert2 = tm.geometry.vertex(g_face[2]);
				Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));
				glNormal3fv(norm.get());
			}
			for(int j=0;j<3;j++)
			{
				if(per_vertex_norms && n_face != Geometry::NULL_FACE)
				{
					Vec3f norm = tm.normals.vertex(n_face[j]);
					glNormal3fv(norm.get());
				}
				if(t_face != Geometry::NULL_FACE)
				{
					Vec3f texc = tm.texcoords.vertex(t_face[j]);
					glTexCoord2fv(texc.get());
				}
				Vec3f vert = tm.geometry.vertex(g_face[j]);
				glVertex3fv(vert.get());
			}
		}
		glEnd();
		glDisable(GL_TEXTURE_2D);
	}
	
	void load_textures(Geometry::TriMesh& tm)
	{
		for(unsigned int i=0;i<tm.materials.size(); ++i)
		{
			Geometry::Material& mat = tm.materials[i];
			if(mat.tex_name != "")
			{
				string name = mat.tex_path + mat.tex_name;
				mat.tex_id = SOIL_load_OGL_texture(name.data(), 0, 0, SOIL_FLAG_TEXTURE_REPEATS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_POWER_OF_TWO);
			}
		}
	}
	 
	template<class T>
	void draw_wireframe_oldfashioned(T& m, bool per_vertex_norms, const Vec3f& line_color)
	{
		// Store state that we change
		glPushAttrib(GL_POLYGON_BIT);
		GLboolean lights_on;
		glGetBooleanv(GL_LIGHTING, &lights_on);
		Vec4f current_color;
		glGetFloatv(GL_CURRENT_COLOR, &current_color[0]);
		
		// Draw filled
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		draw(m, per_vertex_norms);
		
		// Draw lines
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		glDisable(GL_LIGHTING);
		glEnable(GL_POLYGON_OFFSET_LINE);
		glPolygonOffset(0,-5);
		glColor3fv(line_color.get());
		draw(m, per_vertex_norms);
		
		// Put back old state
		glColor3fv(current_color.get());
		if(lights_on) glEnable(GL_LIGHTING);
		glPopAttrib();
	}
	
	template
	void draw_wireframe_oldfashioned<HMesh::Manifold>(HMesh::Manifold& m, bool per_vertex_norms, const Vec3f& line_color);
 
	template
	void draw_wireframe_oldfashioned(Geometry::TriMesh& m, bool per_vertex_norms, const Vec3f& line_color);
 
	
	void draw(const Geometry::AABox& box)
	{
		glBegin(GL_QUADS);
		Vec3f norm_neg[] = {Vec3f(0,0,-1), Vec3f(-1,0,0), Vec3f(0,-1,0)};
		Vec3f norm_pos[] = {Vec3f(0,0, 1), Vec3f( 1,0,0), Vec3f(0, 1,0)};
		for(int j=0;j<3;++j)
		{
			glNormal3fv(norm_neg[j].get());
			Vec3f p = box.get_pmin();
			glVertex3f(p[0], p[1], p[2]);
			p[(j+1)%3] = box.get_pmax()[(j+1)%3];
			glVertex3f(p[0], p[1], p[2]);
			p[j] = box.get_pmax()[j];
			glVertex3f(p[0], p[1], p[2]);
			p[(j+1)%3] = box.get_pmin()[(j+1)%3];
			glVertex3f(p[0], p[1], p[2]);
		}
		glEnd();
		glBegin(GL_QUADS);
		for(int j=0;j<3;++j)
		{
			glNormal3fv(norm_pos[j].get());
			Vec3f p = box.get_pmax();
			glVertex3f(p[0], p[1], p[2]);
			p[j] = box.get_pmin()[j];
			glVertex3f(p[0], p[1], p[2]);
			p[(j+1)%3] = box.get_pmin()[(j+1)%3];
			glVertex3f(p[0], p[1], p[2]);
			p[j] = box.get_pmax()[j];
			glVertex3f(p[0], p[1], p[2]);
		}
		glEnd();
	}
	
	void draw(const Geometry::OBox& box)
	{
		Mat4x4f m = identity_Mat4x4f();
		copy_matrix(box.get_rotation(), m);
		glPushMatrix();
		glMultMatrixf(m.get());
		draw(box.get_aabox());
		glPopMatrix();
	}
	
	/** Draw the tree. The first argument is the level counter, the second
	 argument is the level at which to stop drawing. */
	template <class BoxType>
	void draw(const Geometry::BoundingINode<BoxType>& node, int level, int max_level)
	{
		if(level == max_level)
		{
			draw(node); 
			return;
		}
		node->left->draw(level + 1, max_level);
		node->right->draw(level + 1, max_level);  
	}
	
	template <class BoxType>
	void draw(const Geometry::BoundingLNode<BoxType>& node, int level, int max_level)
	{
#if USE_LEAF_BOXES
		draw(node); 
#endif
	}
	
	template <class BoxType>
	void draw(const Geometry::BoundingTree<BoxType>& tree, int max_level)
	{
		draw(*tree.root, 0, max_level);
	}
}
 

Rev 432	Rev 441
1	`#include <GL/glew.h>`	1	`#include <GL/glew.h>`
2		2
3	`#include "CGLA/Mat4x4f.h"`	3	`#include "CGLA/Mat4x4f.h"`
4	`#include "CGLA/Vec3d.h"`	4	`#include "CGLA/Vec3d.h"`
5	`#include "draw.h"`	5	`#include "draw.h"`
6	`#include "HMesh/FaceCirculator.h"`	6	`#include "HMesh/FaceCirculator.h"`
7		7
8	`#include "SinglePassWireframeRenderer.h"`	8	`#include "SinglePassWireframeRenderer.h"`
9	`#include "IDBufferWireFrameRenderer.h"`	9	`#include "IDBufferWireFrameRenderer.h"`
-		10	`#include "SOIL.h"`
10		11
11	`using namespace CGLA;`	12	`using namespace CGLA;`
12	`using namespace HMesh;`	13	`using namespace HMesh;`
13	`using namespace std;`	14	`using namespace std;`
14		15
15	`namespace`	16	`namespace`
16	`{`	17	`{`
17	`void set_material(const Geometry::Material& material)`	18	`void set_material(const Geometry::Material& material)`
18	`{`	19	`{`
19	`if(material.has_texture && material.tex_id >=0)`	20	`if(material.has_texture && material.tex_id >=0)`
20	`{`	21	`{`
21	`glEnable(GL_TEXTURE_2D);`	22	`glEnable(GL_TEXTURE_2D);`
22	`glBindTexture(GL_TEXTURE_2D, material.tex_id);`	23	`glBindTexture(GL_TEXTURE_2D, material.tex_id);`
23	`glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);`	24	`glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);`
24	`}`	25	`}`
25	`else`	26	`else`
26	`glDisable(GL_TEXTURE_2D);`	27	`glDisable(GL_TEXTURE_2D);`
27		28
28	`glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material.ambient);`	29	`glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material.ambient);`
29	`glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material.diffuse);`	30	`glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material.diffuse);`
30	`glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material.specular);`	31	`glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material.specular);`
31	`glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.shininess);`	32	`glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.shininess);`
32	`}`	33	`}`
33		34
34	`}`	35	`}`
35		36
36	`namespace GLGraphics`	37	`namespace GLGraphics`
37	`{`	38	`{`
38		39
39	`void draw(Manifold& m, bool per_vertex_norms)`	40	`void draw(Manifold& m, bool per_vertex_norms)`
40	`{`	41	`{`
41	`for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)`	42	`for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)`
42	`{`	43	`{`
43	`FaceCirculator fc(f);`	44	`FaceCirculator fc(f);`
44	`if(!per_vertex_norms)`	45	`if(!per_vertex_norms)`
45	`glNormal3fv(normal(f).get());`	46	`glNormal3fv(normal(f).get());`
46	`if(no_edges(f)== 3)`	47	`if(no_edges(f)== 3)`
47	`glBegin(GL_TRIANGLES);`	48	`glBegin(GL_TRIANGLES);`
48	`else`	49	`else`
49	`glBegin(GL_POLYGON);`	50	`glBegin(GL_POLYGON);`
50	`while(!fc.end())`	51	`while(!fc.end())`
51	`{`	52	`{`
52	`Vec3f n = normal(fc.get_vertex());`	53	`Vec3f n = normal(fc.get_vertex());`
53	`if(per_vertex_norms)`	54	`if(per_vertex_norms)`
54	`glNormal3fv(n.get());`	55	`glNormal3fv(n.get());`
55	`glVertex3fv(fc.get_vertex()->pos.get());`	56	`glVertex3fv(fc.get_vertex()->pos.get());`
56	`++fc;`	57	`++fc;`
57	`}`	58	`}`
58	`glEnd();`	59	`glEnd();`
59	`}`	60	`}`
60	`}`	61	`}`
61		62
62	`void draw(const Geometry::IndexedFaceSet& geometry)`	63	`void draw(const Geometry::IndexedFaceSet& geometry)`
63	`{`	64	`{`
64	`glBegin(GL_TRIANGLES);`	65	`glBegin(GL_TRIANGLES);`
65	`for(int i=0;i<geometry.no_faces();i++)`	66	`for(int i=0;i<geometry.no_faces();i++)`
66	`{`	67	`{`
67	`Vec3i g_face = geometry.face(i);`	68	`Vec3i g_face = geometry.face(i);`
68	`Vec3f vert0 = geometry.vertex(g_face[0]);`	69	`Vec3f vert0 = geometry.vertex(g_face[0]);`
69	`Vec3f vert1 = geometry.vertex(g_face[1]);`	70	`Vec3f vert1 = geometry.vertex(g_face[1]);`
70	`Vec3f vert2 = geometry.vertex(g_face[2]);`	71	`Vec3f vert2 = geometry.vertex(g_face[2]);`
71	`Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));`	72	`Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));`
72	`glNormal3fv(norm.get());`	73	`glNormal3fv(norm.get());`
73	`glVertex3fv(vert0.get());`	74	`glVertex3fv(vert0.get());`
74	`glVertex3fv(vert1.get());`	75	`glVertex3fv(vert1.get());`
75	`glVertex3fv(vert2.get());`	76	`glVertex3fv(vert2.get());`
76	`}`	77	`}`
77	`glEnd();`	78	`glEnd();`
78	`}`	79	`}`
79		80
80	`void draw(const Geometry::TriMesh& tm, bool per_vertex_norms)`	81	`void draw(const Geometry::TriMesh& tm, bool per_vertex_norms)`
81	`{`	82	`{`
82	`int old_mat_idx = -1;`	83	`int old_mat_idx = -1;`
83	`glBegin(GL_TRIANGLES);`	84	`glBegin(GL_TRIANGLES);`
84	`for(int i=0;i<tm.geometry.no_faces();i++)`	85	`for(int i=0;i<tm.geometry.no_faces();i++)`
85	`{`	86	`{`
86	`int new_mat_idx = i<static_cast<int>(tm.mat_idx.size()) ? tm.mat_idx[i] : -1;`	87	`int new_mat_idx = i<static_cast<int>(tm.mat_idx.size()) ? tm.mat_idx[i] : -1;`
87	`if(new_mat_idx != old_mat_idx)`	88	`if(new_mat_idx != old_mat_idx)`
88	`{`	89	`{`
89	`glEnd();`	90	`glEnd();`
90	`set_material(tm.materials[tm.mat_idx[i]]);`	91	`set_material(tm.materials[tm.mat_idx[i]]);`
91	`glBegin(GL_TRIANGLES);`	92	`glBegin(GL_TRIANGLES);`
92	`old_mat_idx = new_mat_idx;`	93	`old_mat_idx = new_mat_idx;`
93	`}`	94	`}`
94	`Vec3i n_face = tm.normals.face(i);`	95	`Vec3i n_face = tm.normals.face(i);`
95	`Vec3i g_face = tm.geometry.face(i);`	96	`Vec3i g_face = tm.geometry.face(i);`
96	`Vec3i t_face = tm.texcoords.face(i);`	97	`Vec3i t_face = tm.texcoords.face(i);`
97		98
98	`if(!per_vertex_norms)`	99	`if(!per_vertex_norms)`
99	`{`	100	`{`
100	`Vec3f vert0 = tm.geometry.vertex(g_face[0]);`	101	`Vec3f vert0 = tm.geometry.vertex(g_face[0]);`
101	`Vec3f vert1 = tm.geometry.vertex(g_face[1]);`	102	`Vec3f vert1 = tm.geometry.vertex(g_face[1]);`
102	`Vec3f vert2 = tm.geometry.vertex(g_face[2]);`	103	`Vec3f vert2 = tm.geometry.vertex(g_face[2]);`
103	`Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));`	104	`Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));`
104	`glNormal3fv(norm.get());`	105	`glNormal3fv(norm.get());`
105	`}`	106	`}`
106	`for(int j=0;j<3;j++)`	107	`for(int j=0;j<3;j++)`
107	`{`	108	`{`
108	`if(per_vertex_norms && n_face != Geometry::NULL_FACE)`	109	`if(per_vertex_norms && n_face != Geometry::NULL_FACE)`
109	`{`	110	`{`
110	`Vec3f norm = tm.normals.vertex(n_face[j]);`	111	`Vec3f norm = tm.normals.vertex(n_face[j]);`
111	`glNormal3fv(norm.get());`	112	`glNormal3fv(norm.get());`
112	`}`	113	`}`
113	`if(t_face != Geometry::NULL_FACE)`	114	`if(t_face != Geometry::NULL_FACE)`
114	`{`	115	`{`
115	`Vec3f texc = tm.texcoords.vertex(t_face[j]);`	116	`Vec3f texc = tm.texcoords.vertex(t_face[j]);`
116	`glTexCoord2fv(texc.get());`	117	`glTexCoord2fv(texc.get());`
117	`}`	118	`}`
118	`Vec3f vert = tm.geometry.vertex(g_face[j]);`	119	`Vec3f vert = tm.geometry.vertex(g_face[j]);`
119	`glVertex3fv(vert.get());`	120	`glVertex3fv(vert.get());`
120	`}`	121	`}`
121	`}`	122	`}`
122	`glEnd();`	123	`glEnd();`
123	`glDisable(GL_TEXTURE_2D);`	124	`glDisable(GL_TEXTURE_2D);`
124	`}`	125	`}`
125		126
-		127	`void load_textures(Geometry::TriMesh& tm)`
126		128	`{`
-		129	`for(unsigned int i=0;i<tm.materials.size(); ++i)`
-		130	`{`
-		131	`Geometry::Material& mat = tm.materials[i];`
-		132	`if(mat.tex_name != "")`
-		133	`{`
-		134	`string name = mat.tex_path + mat.tex_name;`
-		135	`mat.tex_id = SOIL_load_OGL_texture(name.data(), 0, 0, SOIL_FLAG_TEXTURE_REPEATS \| SOIL_FLAG_INVERT_Y \| SOIL_FLAG_POWER_OF_TWO);`
-		136	`}`
-		137	`}`
-		138	`}`
127		139
128	`template<class T>`	140	`template<class T>`
129	`void draw_wireframe_oldfashioned(T& m, bool per_vertex_norms, const Vec3f& line_color)`	141	`void draw_wireframe_oldfashioned(T& m, bool per_vertex_norms, const Vec3f& line_color)`
130	`{`	142	`{`
131	`// Store state that we change`	143	`// Store state that we change`
132	`glPushAttrib(GL_POLYGON_BIT);`	144	`glPushAttrib(GL_POLYGON_BIT);`
133	`GLboolean lights_on;`	145	`GLboolean lights_on;`
134	`glGetBooleanv(GL_LIGHTING, &lights_on);`	146	`glGetBooleanv(GL_LIGHTING, &lights_on);`
135	`Vec4f current_color;`	147	`Vec4f current_color;`
136	`glGetFloatv(GL_CURRENT_COLOR, &current_color[0]);`	148	`glGetFloatv(GL_CURRENT_COLOR, &current_color[0]);`
137		149
138	`// Draw filled`	150	`// Draw filled`
139	`glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);`	151	`glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);`
140	`draw(m, per_vertex_norms);`	152	`draw(m, per_vertex_norms);`
141		153
142	`// Draw lines`	154	`// Draw lines`
143	`glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);`	155	`glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);`
144	`glDisable(GL_LIGHTING);`	156	`glDisable(GL_LIGHTING);`
145	`glEnable(GL_POLYGON_OFFSET_LINE);`	157	`glEnable(GL_POLYGON_OFFSET_LINE);`
146	`glPolygonOffset(0,-5);`	158	`glPolygonOffset(0,-5);`
147	`glColor3fv(line_color.get());`	159	`glColor3fv(line_color.get());`
148	`draw(m, per_vertex_norms);`	160	`draw(m, per_vertex_norms);`
149		161
150	`// Put back old state`	162	`// Put back old state`
151	`glColor3fv(current_color.get());`	163	`glColor3fv(current_color.get());`
152	`if(lights_on) glEnable(GL_LIGHTING);`	164	`if(lights_on) glEnable(GL_LIGHTING);`
153	`glPopAttrib();`	165	`glPopAttrib();`
154	`}`	166	`}`
155		167
156	`template`	168	`template`
157	`void draw_wireframe_oldfashioned<HMesh::Manifold>(HMesh::Manifold& m, bool per_vertex_norms, const Vec3f& line_color);`	169	`void draw_wireframe_oldfashioned<HMesh::Manifold>(HMesh::Manifold& m, bool per_vertex_norms, const Vec3f& line_color);`
158		170
159	`template`	171	`template`
160	`void draw_wireframe_oldfashioned(Geometry::TriMesh& m, bool per_vertex_norms, const Vec3f& line_color);`	172	`void draw_wireframe_oldfashioned(Geometry::TriMesh& m, bool per_vertex_norms, const Vec3f& line_color);`
161		173
162		174
163	`void draw(const Geometry::AABox& box)`	175	`void draw(const Geometry::AABox& box)`
164	`{`	176	`{`
165	`glBegin(GL_QUADS);`	177	`glBegin(GL_QUADS);`
166	`Vec3f norm_neg[] = {Vec3f(0,0,-1), Vec3f(-1,0,0), Vec3f(0,-1,0)};`	178	`Vec3f norm_neg[] = {Vec3f(0,0,-1), Vec3f(-1,0,0), Vec3f(0,-1,0)};`
167	`Vec3f norm_pos[] = {Vec3f(0,0, 1), Vec3f( 1,0,0), Vec3f(0, 1,0)};`	179	`Vec3f norm_pos[] = {Vec3f(0,0, 1), Vec3f( 1,0,0), Vec3f(0, 1,0)};`
168	`for(int j=0;j<3;++j)`	180	`for(int j=0;j<3;++j)`
169	`{`	181	`{`
170	`glNormal3fv(norm_neg[j].get());`	182	`glNormal3fv(norm_neg[j].get());`
171	`Vec3f p = box.get_pmin();`	183	`Vec3f p = box.get_pmin();`
172	`glVertex3f(p[0], p[1], p[2]);`	184	`glVertex3f(p[0], p[1], p[2]);`
173	`p[(j+1)%3] = box.get_pmax()[(j+1)%3];`	185	`p[(j+1)%3] = box.get_pmax()[(j+1)%3];`
174	`glVertex3f(p[0], p[1], p[2]);`	186	`glVertex3f(p[0], p[1], p[2]);`
175	`p[j] = box.get_pmax()[j];`	187	`p[j] = box.get_pmax()[j];`
176	`glVertex3f(p[0], p[1], p[2]);`	188	`glVertex3f(p[0], p[1], p[2]);`
177	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`	189	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`
178	`glVertex3f(p[0], p[1], p[2]);`	190	`glVertex3f(p[0], p[1], p[2]);`
179	`}`	191	`}`
180	`glEnd();`	192	`glEnd();`
181	`glBegin(GL_QUADS);`	193	`glBegin(GL_QUADS);`
182	`for(int j=0;j<3;++j)`	194	`for(int j=0;j<3;++j)`
183	`{`	195	`{`
184	`glNormal3fv(norm_pos[j].get());`	196	`glNormal3fv(norm_pos[j].get());`
185	`Vec3f p = box.get_pmax();`	197	`Vec3f p = box.get_pmax();`
186	`glVertex3f(p[0], p[1], p[2]);`	198	`glVertex3f(p[0], p[1], p[2]);`
187	`p[j] = box.get_pmin()[j];`	199	`p[j] = box.get_pmin()[j];`
188	`glVertex3f(p[0], p[1], p[2]);`	200	`glVertex3f(p[0], p[1], p[2]);`
189	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`	201	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`
190	`glVertex3f(p[0], p[1], p[2]);`	202	`glVertex3f(p[0], p[1], p[2]);`
191	`p[j] = box.get_pmax()[j];`	203	`p[j] = box.get_pmax()[j];`
192	`glVertex3f(p[0], p[1], p[2]);`	204	`glVertex3f(p[0], p[1], p[2]);`
193	`}`	205	`}`
194	`glEnd();`	206	`glEnd();`
195	`}`	207	`}`
196		208
197	`void draw(const Geometry::OBox& box)`	209	`void draw(const Geometry::OBox& box)`
198	`{`	210	`{`
199	`Mat4x4f m = identity_Mat4x4f();`	211	`Mat4x4f m = identity_Mat4x4f();`
200	`copy_matrix(box.get_rotation(), m);`	212	`copy_matrix(box.get_rotation(), m);`
201	`glPushMatrix();`	213	`glPushMatrix();`
202	`glMultMatrixf(m.get());`	214	`glMultMatrixf(m.get());`
203	`draw(box.get_aabox());`	215	`draw(box.get_aabox());`
204	`glPopMatrix();`	216	`glPopMatrix();`
205	`}`	217	`}`
206		218
207	`/** Draw the tree. The first argument is the level counter, the second`	219	`/** Draw the tree. The first argument is the level counter, the second`
208	`argument is the level at which to stop drawing. */`	220	`argument is the level at which to stop drawing. */`
209	`template <class BoxType>`	221	`template <class BoxType>`
210	`void draw(const Geometry::BoundingINode<BoxType>& node, int level, int max_level)`	222	`void draw(const Geometry::BoundingINode<BoxType>& node, int level, int max_level)`
211	`{`	223	`{`
212	`if(level == max_level)`	224	`if(level == max_level)`
213	`{`	225	`{`
214	`draw(node);`	226	`draw(node);`
215	`return;`	227	`return;`
216	`}`	228	`}`
217	`node->left->draw(level + 1, max_level);`	229	`node->left->draw(level + 1, max_level);`
218	`node->right->draw(level + 1, max_level);`	230	`node->right->draw(level + 1, max_level);`
219	`}`	231	`}`
220		232
221	`template <class BoxType>`	233	`template <class BoxType>`
222	`void draw(const Geometry::BoundingLNode<BoxType>& node, int level, int max_level)`	234	`void draw(const Geometry::BoundingLNode<BoxType>& node, int level, int max_level)`
223	`{`	235	`{`
224	`#if USE_LEAF_BOXES`	236	`#if USE_LEAF_BOXES`
225	`draw(node);`	237	`draw(node);`
226	`#endif`	238	`#endif`
227	`}`	239	`}`
228		240
229	`template <class BoxType>`	241	`template <class BoxType>`
230	`void draw(const Geometry::BoundingTree<BoxType>& tree, int max_level)`	242	`void draw(const Geometry::BoundingTree<BoxType>& tree, int max_level)`
231	`{`	243	`{`
232	`draw(*tree.root, 0, max_level);`	244	`draw(*tree.root, 0, max_level);`
233	`}`	245	`}`
234	`}`	246	`}`
235		247

Subversion Repositories gelsvn

(root)/trunk/src/GLGraphics/draw.cpp – Rev 432 → 441