449 lines
13 KiB
C++
449 lines
13 KiB
C++
/****************************************************************************
|
|
* MeshLab o o *
|
|
* An extendible mesh processor o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2005, 2009 \/)\/ *
|
|
* Visual Computing Lab /\/| *
|
|
* ISTI - Italian National Research Council | *
|
|
* \ *
|
|
* All rights reserved. *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
* for more details. *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
#ifndef __GLWRAPTETRA__
|
|
#define __GLWRAPTETRA__
|
|
#include <GL/glew.h>
|
|
#include <GL/GL.h>
|
|
#include <vcg/space/color4.h>
|
|
#include <vcg/space/tetra3.h>
|
|
#include <wrap/gui/view.h>
|
|
#include <wrap/gl/space.h>
|
|
#include <wrap/gl/math.h>
|
|
|
|
namespace vcg {
|
|
|
|
namespace tetra {
|
|
|
|
class GLW {
|
|
public:
|
|
enum DrawMode {DMNone, DMSmallTetra,DMFlat,DMWire, DMHidden,DMTransparent,DMFlatWire} ;
|
|
enum NormalMode{NMFlat,NMSmooth, NMUser, NMPerMesh};
|
|
enum ColorMode {CMNone, CMPerMesh,CMUser,CMPerTetra,CMPerVertexF,CMPerVertex};
|
|
enum Hint {HShrinkFactor};
|
|
};
|
|
|
|
template <typename MeshType>
|
|
class GlTetramesh:public GLW{
|
|
|
|
|
|
public:
|
|
|
|
typedef typename MeshType::TetraType TetraType;
|
|
typedef typename TetraType::VertexType VertexType;
|
|
typedef typename VertexType::ScalarType ScalarType;
|
|
typedef typename VertexType::CoordType CoordType;
|
|
|
|
//subclass for clipping planes
|
|
class ClipPlane
|
|
{
|
|
private:
|
|
|
|
CoordType D, D0;
|
|
ScalarType dist;
|
|
|
|
GLdouble eqn[4];
|
|
|
|
|
|
public:
|
|
bool active;
|
|
|
|
ClipPlane (){active=false;}
|
|
|
|
~ClipPlane (){}
|
|
|
|
ClipPlane(CoordType & p0, CoordType & p1, CoordType & p2)
|
|
{
|
|
CoordType N = ((p1-p0)^(p2-p0)).Normalize();
|
|
|
|
D = N;
|
|
D0 = D;
|
|
|
|
dist = vcg::Norm((p0 + p1 + p2) / 3.f);
|
|
}
|
|
|
|
//set normal of the clipping plane
|
|
void SetD(CoordType d)
|
|
{
|
|
D = d;
|
|
D0 = d;
|
|
}
|
|
//set the point of the clipping plane
|
|
void SetDist(ScalarType d)
|
|
{
|
|
dist = d;
|
|
}
|
|
bool IsClipped(CoordType p)
|
|
{
|
|
return D.V(0) * p.X() + D.V(1) * p.Y() + D.V(2) * p.Z() - dist > 0;
|
|
}
|
|
|
|
void GlClip()
|
|
{
|
|
if (active){
|
|
GLdouble d=-(D.V(0)*P.V(0)+D.V(1)*P.V(1)+D.V(2)*P.V(2));
|
|
eqn[0]=-D.V(0);
|
|
eqn[1]=-D.V(1);
|
|
eqn[2]=-D.V(2);
|
|
eqn[3]=-d;
|
|
glClipPlane(GL_CLIP_PLANE0, eqn);
|
|
glEnable(GL_CLIP_PLANE0);
|
|
}
|
|
}
|
|
|
|
void GlDraw()
|
|
{
|
|
const ScalarType w = 50;
|
|
glColor4f(1., 1., 0., 0.3);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glDisable(GL_LIGHTING);
|
|
|
|
glBegin(GL_LINES);
|
|
glVertex3f(0, 0, 0);
|
|
glVertex3f(dist, 0, 0);
|
|
glEnd();
|
|
glBegin(GL_TRIANGLES);
|
|
glVertex3f(dist, -w, w);
|
|
glVertex3f(dist, w, w);
|
|
glVertex3f(dist, -w, -w);
|
|
glVertex3f(dist, w, w);
|
|
glVertex3f(dist, w, -w);
|
|
glVertex3f(dist, -w, -w);
|
|
glEnd();
|
|
|
|
glDisable(GL_BLEND);
|
|
glEnable(GL_LIGHTING);
|
|
}
|
|
|
|
void Transform(vcg::Matrix44<float> & tr)
|
|
{
|
|
D = (tr * D0).Normalize();
|
|
}
|
|
|
|
void offsetDist(ScalarType off)
|
|
{
|
|
dist = (off < -dist) ? 0.001f : dist + off;
|
|
}
|
|
|
|
bool IsActive()
|
|
{
|
|
return active;
|
|
}
|
|
|
|
bool switchActive()
|
|
{
|
|
return active ^= true;
|
|
}
|
|
};
|
|
|
|
GlTetramesh(MeshType * m) : _m(m){}
|
|
GlTetramesh( ) {}
|
|
|
|
MeshType * _m;
|
|
ClipPlane section;
|
|
|
|
private:
|
|
ScalarType shrink_factor = 0.98f;
|
|
|
|
|
|
public:
|
|
|
|
void SetHint(Hint h, double value){
|
|
switch(h){
|
|
case HShrinkFactor: shrink_factor = value; break;
|
|
}
|
|
}
|
|
|
|
void AddClipSection(CoordType p0, CoordType p1, CoordType p2)
|
|
{
|
|
section=ClipPlane(p0,p1,p2);
|
|
section.active=true;
|
|
}
|
|
|
|
void ClearClipSection()
|
|
{
|
|
section.active=false;
|
|
}
|
|
|
|
template <DrawMode dm,NormalMode nm,ColorMode cm >
|
|
void Draw(){
|
|
switch (dm){
|
|
case DMNone: break;
|
|
case DMSmallTetra: _DrawSmallTetra<cm>();break;
|
|
case DMFlat: _DrawSurface<dm,nm,cm>();break;
|
|
case DMWire: _DrawSurface<dm,nm,cm>();break;
|
|
case DMHidden: _DrawSurface<dm,nm,cm>();break;
|
|
case DMFlatWire: _DrawFlatWire<nm,cm>(); break;
|
|
case DMTransparent: break;
|
|
}
|
|
}
|
|
|
|
private:
|
|
template <ColorMode cm >
|
|
void _DrawSmallTetra(){
|
|
|
|
glEnable(GL_LIGHT0);
|
|
glEnable(GL_LIGHTING);
|
|
ForEachTetra(*_m, [&] (TetraType & t) {
|
|
if (!t.IsD())
|
|
{
|
|
if (!t.IsS()) //draw as normal
|
|
_DrawSmallTetra<cm>(t);
|
|
else //draw in selected mode
|
|
_DrawSelectedTetra(t);
|
|
}
|
|
});
|
|
}
|
|
|
|
template <NormalMode nm,ColorMode cm >
|
|
void _DrawFlatWire(){
|
|
glPushAttrib(0xffff);
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
glEnable(GL_DEPTH);
|
|
glDepthRange(0.001,1.0);
|
|
Draw<DMFlat,nm,cm>();
|
|
glDisable(GL_LIGHTING);
|
|
glColor3f(0.0,0.0,0.0);
|
|
glDepthRange(0.0,0.999);
|
|
Draw<DMHidden,nm,cm>();
|
|
glPopAttrib();
|
|
}
|
|
|
|
|
|
template <DrawMode dm,NormalMode nm,ColorMode cm >
|
|
void _DrawSurface(){
|
|
|
|
|
|
glPushAttrib(0xffff);
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
if((dm == DMWire)||(dm ==DMHidden))
|
|
{
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_NORMALIZE);
|
|
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
|
|
}
|
|
else
|
|
{
|
|
glEnable(GL_LIGHT0);
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_NORMALIZE);
|
|
glPolygonMode(GL_FRONT,GL_FILL);
|
|
}
|
|
|
|
ForEachTetra(*_m, [&] (TetraType & t) {
|
|
_DrawTetra<dm,nm,cm>(t);
|
|
});
|
|
|
|
glPopAttrib();
|
|
}
|
|
|
|
|
|
void _DrawSelectedTetra(TetraType &t)
|
|
{
|
|
glPushMatrix();
|
|
glPushAttrib(0xffff);
|
|
glDisable(GL_CLIP_PLANE0);
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_NORMALIZE);
|
|
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
|
|
|
|
glColor3d(1,0,0);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
for (int face=0;face<4;face++)
|
|
{
|
|
glVertex(t.V(Tetra::VofF(face,0))->P());
|
|
glVertex(t.V(Tetra::VofF(face,1))->P());
|
|
glVertex(t.V(Tetra::VofF(face,2))->P());
|
|
}
|
|
glEnd();
|
|
|
|
//end drawing
|
|
glPopAttrib();
|
|
glPopMatrix();
|
|
}
|
|
|
|
template <DrawMode dm,NormalMode nm,ColorMode cm >
|
|
void _DrawTetra(TetraType &t)
|
|
{
|
|
if((!t.IsD())&&(!t.IsS()))
|
|
{
|
|
if ((dm!=DMWire)&&(dm!=DMHidden))
|
|
_ChooseColorTetra<cm>(t);
|
|
for(int i = 0; i < 4; ++i){
|
|
if (dm == DMWire)
|
|
_DrawFace<cm>(t,i);
|
|
else
|
|
{
|
|
if (t.IsBorderF(i))
|
|
{
|
|
if(nm==NMSmooth)
|
|
_DrawFaceSmooth<cm>(t,i);
|
|
else
|
|
if(nm==NMFlat)
|
|
_DrawFace<cm>(t,i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if((!t.IsD())&&(t.IsS()))
|
|
_DrawSelectedTetra(t);
|
|
}
|
|
|
|
template <ColorMode cm >
|
|
void _ChooseColorTetra(TetraType &t)
|
|
{
|
|
if (cm==CMNone)
|
|
{
|
|
if (t.IsS())
|
|
glColor3d(1,0,0);
|
|
else
|
|
glColor3d(0.8f,0.8f,0.8f);
|
|
}
|
|
if (cm == CMPerTetra)
|
|
vcg::glColor(t.C());
|
|
// else
|
|
// if(cm == CMPerTetraF)
|
|
// {
|
|
// Color4b c;
|
|
// c = color_tetra(t);
|
|
// GLint ic[4]; ic[0] = c[0];ic[1] = c[1];ic[2] = c[2];ic[3] = c[3];
|
|
// glMaterialiv(GL_FRONT,GL_DIFFUSE ,ic);
|
|
// }
|
|
}
|
|
|
|
template <ColorMode cm >
|
|
void _ChooseColorVertex(VertexType &v)
|
|
{
|
|
if (cm!=CMNone)
|
|
{
|
|
// if(cm == CMPerVertexF)
|
|
// {
|
|
// Color4b c;
|
|
// c = color_vertex(v);
|
|
// GLint ic[4]; ic[0] = c[0];ic[1] = c[1];ic[2] = c[2];ic[3] = c[3];
|
|
// glMaterialiv(GL_FRONT,GL_DIFFUSE ,ic);
|
|
// }
|
|
// else
|
|
if(cm == CMPerVertex)
|
|
vcg::glColor(v.C());
|
|
}
|
|
}
|
|
|
|
template <ColorMode cm >
|
|
void _DrawFaceSmooth(TetraType &t,int face)
|
|
{
|
|
|
|
VertexType *v0=t.V(Tetra::VofF(face,0));
|
|
VertexType *v1=t.V(Tetra::VofF(face,1));
|
|
VertexType *v2=t.V(Tetra::VofF(face,2));
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
_ChooseColorVertex<cm>(*v0);
|
|
glNormal(v0->N());
|
|
glVertex(v0->P());
|
|
_ChooseColorVertex<cm>(*v1);
|
|
glNormal(v1->N());
|
|
glVertex(v1->P());
|
|
_ChooseColorVertex<cm>(*v2);
|
|
glNormal(v2->N());
|
|
glVertex(v2->P());
|
|
glEnd();
|
|
}
|
|
|
|
template < ColorMode cm >
|
|
void _DrawFace(TetraType &t,int face)
|
|
{
|
|
glBegin(GL_TRIANGLES);
|
|
VertexType *v0=t.V(Tetra::VofF(face,0));
|
|
VertexType *v1=t.V(Tetra::VofF(face,1));
|
|
VertexType *v2=t.V(Tetra::VofF(face,2));
|
|
glNormal(vcg::Normal(v0->P(), v1->P(), v2->P()).normalized());
|
|
_ChooseColorVertex<cm>(*v0);
|
|
glVertex(v0->P());
|
|
_ChooseColorVertex<cm>(*v1);
|
|
glVertex(v1->P());
|
|
_ChooseColorVertex<cm>(*v2);
|
|
glVertex(v2->P());
|
|
glEnd();
|
|
}
|
|
|
|
template < ColorMode cm >
|
|
void _DrawSmallTetra(TetraType &t)
|
|
{
|
|
CoordType p[4], br;
|
|
br = Tetra::Barycenter(t);
|
|
|
|
if (section.active)
|
|
{
|
|
if (section.IsClipped(br))
|
|
return;
|
|
bool border = false;
|
|
bool clipBorder = false;
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
border = border || t.IsB(i);
|
|
|
|
CoordType br1 = Tetra::Barycenter(*t.TTp(i));
|
|
clipBorder = clipBorder || section.IsClipped(br1);
|
|
}
|
|
|
|
if (!border && !clipBorder)
|
|
return;
|
|
}
|
|
|
|
for(int i = 0; i < 4; ++i)
|
|
// p[i] = t.V(i)->P();
|
|
p[i] = t.V(i)->P() * shrink_factor + br * (1 - shrink_factor);
|
|
|
|
|
|
_ChooseColorTetra<cm>(t);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
for(int i = 0; i < 4; ++i)
|
|
{
|
|
VertexType *v0=t.V(Tetra::VofF(i,0));
|
|
VertexType *v1=t.V(Tetra::VofF(i,1));
|
|
VertexType *v2=t.V(Tetra::VofF(i,2));
|
|
|
|
|
|
glNormal(vcg::Normal(v0->P(), v1->P(), v2->P()).normalized());
|
|
|
|
_ChooseColorVertex<cm>(*v0);
|
|
glVertex(p[Tetra::VofF(i,0)]);
|
|
_ChooseColorVertex<cm>(*v1);
|
|
glVertex(p[Tetra::VofF(i,1)]);
|
|
_ChooseColorVertex<cm>(*v2);
|
|
glVertex(p[Tetra::VofF(i,2)]);
|
|
}
|
|
glEnd();
|
|
}
|
|
};
|
|
|
|
} // end namespace tetra
|
|
} // end nemaspace tri
|
|
#endif
|