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

Subversion Repositories gelsvn

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