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


#include "CGLA/Mat4x4f.h"
 
#include "gel_gl.h"
#include "draw.h"
#include "HMesh/FaceCirculator.h"
 
using namespace CGLA;
using namespace HMesh;
using namespace std;
 
namespace 
{
void set_material(const Geometry::Material& material)
{
    		if(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());
				glBegin(GL_POLYGON);
				while(!fc.end())
				{
						Vec3f n = normal(fc.get_vertex());
						glNormal3fv(n.get());
						glVertex3fv(fc.get_vertex()->pos.get());
						++fc;
				}
				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++)
    {
        if(tm.mat_idx[i] != old_mat_idx)
        {
            glEnd();
            set_material(tm.materials[tm.mat_idx[i]]);
            glBegin(GL_TRIANGLES);
            old_mat_idx = tm.mat_idx[i];
        }
        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 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 324	Rev 331
1	`#include "CGLA/Mat4x4f.h"`	1	`#include "CGLA/Mat4x4f.h"`
2		2
3	`#include "gel_gl.h"`	3	`#include "gel_gl.h"`
4	`#include "draw.h"`	4	`#include "draw.h"`
-		5	`#include "HMesh/FaceCirculator.h"`
5		6
6	`using namespace CGLA;`	7	`using namespace CGLA;`
-		8	`using namespace HMesh;`
7	`using namespace std;`	9	`using namespace std;`
8		10
9	`namespace`	11	`namespace`
10	`{`	12	`{`
11	`void set_material(const Geometry::Material& material)`	13	`void set_material(const Geometry::Material& material)`
12	`{`	14	`{`
13	`if(material.tex_id >=0)`	15	`if(material.tex_id >=0)`
14	`{`	16	`{`
15	`glEnable(GL_TEXTURE_2D);`	17	`glEnable(GL_TEXTURE_2D);`
16	`glBindTexture(GL_TEXTURE_2D, material.tex_id);`	18	`glBindTexture(GL_TEXTURE_2D, material.tex_id);`
17	`glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);`	19	`glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);`
18	`}`	20	`}`
19	`else`	21	`else`
20	`glDisable(GL_TEXTURE_2D);`	22	`glDisable(GL_TEXTURE_2D);`
21		23
22	`glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material.ambient);`	24	`glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material.ambient);`
23	`glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material.diffuse);`	25	`glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material.diffuse);`
24	`glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material.specular);`	26	`glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material.specular);`
25	`glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.shininess);`	27	`glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.shininess);`
26	`}`	28	`}`
27		29
28	`}`	30	`}`
29		31
30	`namespace GLGraphics`	32	`namespace GLGraphics`
31	`{`	33	`{`
32		34
-		35	`void draw(Manifold& m, bool per_vertex_norms)`
-		36	`{`
-		37	`for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)`
-		38	`{`
-		39	`FaceCirculator fc(f);`
-		40	`if(!per_vertex_norms)`
-		41	`glNormal3fv(normal(f).get());`
-		42	`glBegin(GL_POLYGON);`
-		43	`while(!fc.end())`
-		44	`{`
-		45	`Vec3f n = normal(fc.get_vertex());`
-		46	`glNormal3fv(n.get());`
-		47	`glVertex3fv(fc.get_vertex()->pos.get());`
-		48	`++fc;`
-		49	`}`
-		50	`glEnd();`
-		51	`}`
-		52	`}`
-		53
-		54
33	`void draw(const Geometry::TriMesh& tm)`	55	`void draw(const Geometry::TriMesh& tm, bool per_vertex_norms)`
34	`{`	56	`{`
35	`int old_mat_idx = -1;`	57	`int old_mat_idx = -1;`
36	`glBegin(GL_TRIANGLES);`	58	`glBegin(GL_TRIANGLES);`
37	`for(int i=0;i<tm.geometry.no_faces();i++)`	59	`for(int i=0;i<tm.geometry.no_faces();i++)`
38	`{`	60	`{`
39	`if(tm.mat_idx[i] != old_mat_idx)`	61	`if(tm.mat_idx[i] != old_mat_idx)`
40	`{`	62	`{`
41	`glEnd();`	63	`glEnd();`
42	`set_material(tm.materials[tm.mat_idx[i]]);`	64	`set_material(tm.materials[tm.mat_idx[i]]);`
43	`glBegin(GL_TRIANGLES);`	65	`glBegin(GL_TRIANGLES);`
44	`old_mat_idx = tm.mat_idx[i];`	66	`old_mat_idx = tm.mat_idx[i];`
45	`}`	67	`}`
46	`Vec3i n_face = tm.normals.face(i);`	68	`Vec3i n_face = tm.normals.face(i);`
47	`Vec3i g_face = tm.geometry.face(i);`	69	`Vec3i g_face = tm.geometry.face(i);`
48	`Vec3i t_face = tm.texcoords.face(i);`	70	`Vec3i t_face = tm.texcoords.face(i);`
-		71
-		72	`if(!per_vertex_norms)`
-		73	`{`
-		74	`Vec3f vert0 = tm.geometry.vertex(g_face[0]);`
-		75	`Vec3f vert1 = tm.geometry.vertex(g_face[1]);`
-		76	`Vec3f vert2 = tm.geometry.vertex(g_face[2]);`
-		77	`Vec3f norm = normalize(cross(vert1-vert0, vert2-vert0));`
-		78	`glNormal3fv(norm.get());`
-		79	`}`
49	`for(int j=0;j<3;j++)`	80	`for(int j=0;j<3;j++)`
50	`{`	81	`{`
51	`if(n_face != Geometry::NULL_FACE)`	82	`if(per_vertex_norms && n_face != Geometry::NULL_FACE)`
52	`{`	83	`{`
53	`Vec3f norm = tm.normals.vertex(n_face[j]);`	84	`Vec3f norm = tm.normals.vertex(n_face[j]);`
54	`glNormal3fv(norm.get());`	85	`glNormal3fv(norm.get());`
55	`}`	86	`}`
56	`if(t_face != Geometry::NULL_FACE)`	87	`if(t_face != Geometry::NULL_FACE)`
57	`{`	88	`{`
58	`Vec3f texc = tm.texcoords.vertex(t_face[j]);`	89	`Vec3f texc = tm.texcoords.vertex(t_face[j]);`
59	`glTexCoord2fv(texc.get());`	90	`glTexCoord2fv(texc.get());`
60	`}`	91	`}`
61	`Vec3f vert = tm.geometry.vertex(g_face[j]);`	92	`Vec3f vert = tm.geometry.vertex(g_face[j]);`
62	`glVertex3fv(vert.get());`	93	`glVertex3fv(vert.get());`
63	`}`	94	`}`
64	`}`	95	`}`
65	`glEnd();`	96	`glEnd();`
66	`glDisable(GL_TEXTURE_2D);`	97	`glDisable(GL_TEXTURE_2D);`
67	`}`	98	`}`
68		99
69	`void draw(const Geometry::AABox& box)`	100	`void draw(const Geometry::AABox& box)`
70	`{`	101	`{`
71	`glBegin(GL_QUADS);`	102	`glBegin(GL_QUADS);`
72	`Vec3f norm_neg[] = {Vec3f(0,0,-1), Vec3f(-1,0,0), Vec3f(0,-1,0)};`	103	`Vec3f norm_neg[] = {Vec3f(0,0,-1), Vec3f(-1,0,0), Vec3f(0,-1,0)};`
73	`Vec3f norm_pos[] = {Vec3f(0,0, 1), Vec3f( 1,0,0), Vec3f(0, 1,0)};`	104	`Vec3f norm_pos[] = {Vec3f(0,0, 1), Vec3f( 1,0,0), Vec3f(0, 1,0)};`
74	`for(int j=0;j<3;++j)`	105	`for(int j=0;j<3;++j)`
75	`{`	106	`{`
76	`glNormal3fv(norm_neg[j].get());`	107	`glNormal3fv(norm_neg[j].get());`
77	`Vec3f p = box.get_pmin();`	108	`Vec3f p = box.get_pmin();`
78	`glVertex3f(p[0], p[1], p[2]);`	109	`glVertex3f(p[0], p[1], p[2]);`
79	`p[(j+1)%3] = box.get_pmax()[(j+1)%3];`	110	`p[(j+1)%3] = box.get_pmax()[(j+1)%3];`
80	`glVertex3f(p[0], p[1], p[2]);`	111	`glVertex3f(p[0], p[1], p[2]);`
81	`p[j] = box.get_pmax()[j];`	112	`p[j] = box.get_pmax()[j];`
82	`glVertex3f(p[0], p[1], p[2]);`	113	`glVertex3f(p[0], p[1], p[2]);`
83	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`	114	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`
84	`glVertex3f(p[0], p[1], p[2]);`	115	`glVertex3f(p[0], p[1], p[2]);`
85	`}`	116	`}`
86	`glEnd();`	117	`glEnd();`
87	`glBegin(GL_QUADS);`	118	`glBegin(GL_QUADS);`
88	`for(int j=0;j<3;++j)`	119	`for(int j=0;j<3;++j)`
89	`{`	120	`{`
90	`glNormal3fv(norm_pos[j].get());`	121	`glNormal3fv(norm_pos[j].get());`
91	`Vec3f p = box.get_pmax();`	122	`Vec3f p = box.get_pmax();`
92	`glVertex3f(p[0], p[1], p[2]);`	123	`glVertex3f(p[0], p[1], p[2]);`
93	`p[j] = box.get_pmin()[j];`	124	`p[j] = box.get_pmin()[j];`
94	`glVertex3f(p[0], p[1], p[2]);`	125	`glVertex3f(p[0], p[1], p[2]);`
95	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`	126	`p[(j+1)%3] = box.get_pmin()[(j+1)%3];`
96	`glVertex3f(p[0], p[1], p[2]);`	127	`glVertex3f(p[0], p[1], p[2]);`
97	`p[j] = box.get_pmax()[j];`	128	`p[j] = box.get_pmax()[j];`
98	`glVertex3f(p[0], p[1], p[2]);`	129	`glVertex3f(p[0], p[1], p[2]);`
99	`}`	130	`}`
100	`glEnd();`	131	`glEnd();`
101	`}`	132	`}`
102		133
103	`void draw(const Geometry::OBox& box)`	134	`void draw(const Geometry::OBox& box)`
104	`{`	135	`{`
105	`Mat4x4f m = identity_Mat4x4f();`	136	`Mat4x4f m = identity_Mat4x4f();`
106	`copy_matrix(box.get_rotation(), m);`	137	`copy_matrix(box.get_rotation(), m);`
107	`glPushMatrix();`	138	`glPushMatrix();`
108	`glMultMatrixf(m.get());`	139	`glMultMatrixf(m.get());`
109	`draw(box.get_aabox());`	140	`draw(box.get_aabox());`
110	`glPopMatrix();`	141	`glPopMatrix();`
111	`}`	142	`}`
112		143
113	`/** Draw the tree. The first argument is the level counter, the second`	144	`/** Draw the tree. The first argument is the level counter, the second`
114	`argument is the level at which to stop drawing. */`	145	`argument is the level at which to stop drawing. */`
115	`template <class BoxType>`	146	`template <class BoxType>`
116	`void draw(const Geometry::BoundingINode<BoxType>& node, int level, int max_level)`	147	`void draw(const Geometry::BoundingINode<BoxType>& node, int level, int max_level)`
117	`{`	148	`{`
118	`if(level == max_level)`	149	`if(level == max_level)`
119	`{`	150	`{`
120	`draw(node);`	151	`draw(node);`
121	`return;`	152	`return;`
122	`}`	153	`}`
123	`node->left->draw(level + 1, max_level);`	154	`node->left->draw(level + 1, max_level);`
124	`node->right->draw(level + 1, max_level);`	155	`node->right->draw(level + 1, max_level);`
125	`}`	156	`}`
126		157
127	`template <class BoxType>`	158	`template <class BoxType>`
128	`void draw(const Geometry::BoundingLNode<BoxType>& node, int level, int max_level)`	159	`void draw(const Geometry::BoundingLNode<BoxType>& node, int level, int max_level)`
129	`{`	160	`{`
130	`#if USE_LEAF_BOXES`	161	`#if USE_LEAF_BOXES`
131	`draw(node);`	162	`draw(node);`
132	`#endif`	163	`#endif`
133	`}`	164	`}`
134		165
135	`template <class BoxType>`	166	`template <class BoxType>`
136	`void draw(const Geometry::BoundingTree<BoxType>& tree, int max_level)`	167	`void draw(const Geometry::BoundingTree<BoxType>& tree, int max_level)`
137	`{`	168	`{`
138	`draw(*tree.root, 0, max_level);`	169	`draw(*tree.root, 0, max_level);`
139	`}`	170	`}`
140		171
141	`}`	172	`}`
142		173

Subversion Repositories gelsvn

(root)/trunk/src/GLGraphics/draw.cpp – Rev 324 → 331