manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[ Changes in definition of TriMesh: PART I ] 

Note for the developers: the change to make to existing projects is very little 
but strictly necessary to compile. This change IS NOT backward compliant.


==== OLD ==== way to define a TriMesh:

// forward declarations
class MyVertex;
class MyEdge;
class MyFace;

class MyVertex: public VertexSimp2 < MyVertex, MyEdge, MyFace, vertex::Coord3f,...other components>{};
class MyFace: public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef,...other components>{};
class MyMesh: public TriMesh<vector<MyVertex>,vector<MyFace> >{};


==== NEW ==== way to define a TriMesh:
// forward declarations
class MyVertex;
class MyEdge;
class MyFace;

// declaration of which types is used as VertexType, which type is used as FaceType and so on...
class MyUsedTypes: public vcg::UsedType < vcg::Use<MyVertex>::AsVertexType,
                                          vcg::Use<MyFace>::AsFaceType>{};

class MyVertex: public Vertex < MyUsedTypes, vertex::Coord3f,...other components>{};
class MyFace: public Face < MyUsedTypes, face::VertexRef,...other components>{};
class MyMesh: public TriMesh<vector<MyVertex>,vector<MyFace> >{};

                                 
===== classes introduced          
[vcg::UsedType] : it is a class containing all the types that must be passed to the definition of Vertex, Face, Edge... This
class replaces the list of typenames to pass as first templates and the need to specify the maximal simplicial. So 

<MyVertex, MyEdge, MyFace  becomes <MyUsedTypes<

and 

VertexSimp2 becomes Vertex

[vcg::Use] : an auxiliary class to give a simple way to specify the role of a type

Note 2: the order of templates parameters to vcg::UsedTypes is unimportant, e.g:

class MyUsedTypes: public vcg::UsedType <vcg::Use<MyVertex>::AsVertexType,
                                         vcg::Use<MyEdge>::AsEdgeType,
                                         vcg::Use<MyFace>::AsFaceType>{};

is the same as:
class MyUsedTypes: public vcg::UsedType <vcg::Use<MyFace>::AsFaceType,
                                         vcg::Use<MyEdge>::AsEdgeType,
                                         vcg::Use<MyVertex>::AsVertexType>{};

Note 3: you only need to specify the type  you use. If you do not have edges you do not need 
to include vcg::Use<MyEdge>::AsEdgeType in the template list of UsedTypes.
==== the Part II will be a tiny change to the class TriMesh it self.
This commit is contained in:
ganovelli 2010-03-15 10:44:40 +00:00
parent 01bb1ff921
commit ae83ca17ed
17 changed files with 162 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
apps/sample/aabb_binary_tree/aabb_binary_tree.cpp
View File

@ -25,10 +25,14 @@ typedef float AScalarType;
using namespace vcg; using namespace vcg;
class AEdge; class AVertex;
class AFace; class AFace;
class AVertex : public VertexSimp2< AVertex, AEdge, AFace, vertex::Normal3f, vertex::Coord3f,vertex::BitFlags >{};
class AFace : public FaceSimp2< AVertex, AEdge, AFace, face::VertexRef, face::Normal3f, face::EdgePlane, face::BitFlags> {}; struct MyUsedTypes : public vcg::UsedTypes< vcg::Use<AVertex> ::AsVertexType,
vcg::Use<AFace> ::AsFaceType>{};
class AVertex : public Vertex< MyUsedTypes, vertex::Normal3f, vertex::Coord3f,vertex::BitFlags >{};
class AFace : public Face< MyUsedTypes, face::VertexRef, face::Normal3f, face::EdgePlane, face::BitFlags> {};
//class AVertex : public vcg::Vertex< AScalarType, AEdge, AFace > { }; //class AVertex : public vcg::Vertex< AScalarType, AEdge, AFace > { };
//class AFace : public vcg::FaceRTFMFN< AVertex, AEdge, AFace > { }; //class AFace : public vcg::FaceRTFMFN< AVertex, AEdge, AFace > { };

23
apps/sample/polygonmesh_base/polygonmesh.cpp
View File

@ -69,15 +69,19 @@ class CEdge;
class DummyEdge; class DummyEdge;
class MyPolyVertex; class MyPolyVertex;
struct CUsedTypes: public vcg::UsedTypes< vcg::Use<CVertex>::AsVertexType, vcg::Use<CFace>::AsFaceType >{};
/* Definition of a mesh of triangles /* Definition of a mesh of triangles
*/ */
class CVertex : public VertexSimp2< CVertex, DummyEdge, CFace, class CVertex : public Vertex< CUsedTypes,
vertex::BitFlags, vertex::BitFlags,
vertex::Coord3f, vertex::Coord3f,
vertex::Normal3f, vertex::Normal3f,
vertex::Mark >{}; vertex::Mark >{};
class CFace : public FaceSimp2< CVertex, DummyEdge, CFace, class CFace : public Face< CUsedTypes,
face::VertexRef, // three pointers to vertices face::VertexRef, // three pointers to vertices
face::Normal3f, // normal face::Normal3f, // normal
face::BitFlags, // flags face::BitFlags, // flags
@ -91,15 +95,20 @@ class CMesh : public vcg::tri::TriMesh< vector<CVertex>, vector<CFace> > {};
/* Definition of a mesh of polygons that also supports half-edges /* Definition of a mesh of polygons that also supports half-edges
*/ */
class MyPolyFace; class MyPolyFace;
class MyPolyVertex;
struct PolyUsedTypes: public vcg::UsedTypes< vcg::Use<MyPolyVertex>::AsVertexType,
vcg::Use<CEdge>::AsEdgeType,
vcg::Use<MyPolyFace>::AsFaceType >{};
class MyPolyVertex:public vcg::VertexSimp2<MyPolyVertex , CEdge,MyPolyFace,
class MyPolyVertex:public vcg::Vertex<PolyUsedTypes,
vcg::vertex::Coord3f, vcg::vertex::Coord3f,
vcg::vertex::Normal3f, vcg::vertex::Normal3f,
vcg::vertex::Mark, vcg::vertex::Mark,
vcg::vertex::BitFlags, vcg::vertex::BitFlags,
vcg::vertex::VEAdj>{} ; vcg::vertex::VEAdj>{} ;
class CEdge : public EdgeSimp2< MyPolyVertex, CEdge, MyPolyFace, edge::BitFlags, class CEdge : public Edge< PolyUsedTypes, edge::BitFlags,
//edge::EFAdj, // pointer to the face //edge::EFAdj, // pointer to the face
//edge::HEOppAdj, // pointer to the opposite edge //edge::HEOppAdj, // pointer to the opposite edge
//edge::HEVAdj, // pointer to the vertex //edge::HEVAdj, // pointer to the vertex
@ -108,10 +117,8 @@ class CEdge : public EdgeSimp2< MyPolyVertex, CEdge, MyPolyFace, edge::BitFlags,
//,edge::HEPrevAdj // pointer to the previous halfedge //,edge::HEPrevAdj // pointer to the previous halfedge
>{}; >{};
class MyPolyFace:public vcg::FaceSimp2< class MyPolyFace:public vcg::Face<
MyPolyVertex PolyUsedTypes
,CEdge
,MyPolyFace
,vcg::face::PolyInfo // this is necessary if you use component in vcg/simplex/face/component_polygon.h ,vcg::face::PolyInfo // this is necessary if you use component in vcg/simplex/face/component_polygon.h
// It says "this class is a polygon and the memory for its components (e.g. pointer to its vertices // It says "this class is a polygon and the memory for its components (e.g. pointer to its vertices
// will be allocated dynamically") // will be allocated dynamically")

11
apps/sample/trimesh_QT/glarea.h
View File

@ -51,12 +51,17 @@ Initial release.
#include <wrap/gui/trackball.h> #include <wrap/gui/trackball.h>
/// declaring edge and face type /// declaring edge and face type
class CEdge;
using namespace vcg;
class CFace; class CFace;
class CVertex;
struct MyUsedTypes : public UsedTypes< Use<CVertex> ::AsVertexType,
Use<CFace> ::AsFaceType>{};
/// compositing wanted proprieties /// compositing wanted proprieties
class CVertex : public vcg::VertexSimp2< CVertex, CEdge, CFace, vcg::vertex::Coord3f, vcg::vertex::Normal3f, vcg::vertex::BitFlags>{}; class CVertex : public vcg::Vertex< MyUsedTypes, vcg::vertex::Coord3f, vcg::vertex::Normal3f, vcg::vertex::BitFlags>{};
class CFace : public vcg::FaceSimp2< CVertex, CEdge, CFace, vcg::face::VertexRef, vcg::face::Normal3f, vcg::face::BitFlags > {}; class CFace : public vcg::Face< MyUsedTypes, vcg::face::VertexRef, vcg::face::Normal3f, vcg::face::BitFlags > {};
class CMesh : public vcg::tri::TriMesh< std::vector<CVertex>, std::vector<CFace> > {}; class CMesh : public vcg::tri::TriMesh< std::vector<CVertex>, std::vector<CFace> > {};
class GLArea:public QGLWidget class GLArea:public QGLWidget

11
apps/sample/trimesh_SDL/trimesh_sdl.cpp
View File

@ -39,7 +39,7 @@ Initial Relase
****************************************************************************/ ****************************************************************************/
#include <SDL.h> #include <SDL.h>
#include <gl/glew.h> #include <GL/glew.h>
#include <vector> #include <vector>
/*include the base definition for the vertex */ /*include the base definition for the vertex */
@ -69,16 +69,19 @@ otherwise you'll get linking errors */
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class CEdge; // dummy prototype never used
class CFace; class CFace;
class CVertex;
struct MyUsedTypes : public UsedTypes< Use<CVertex> ::AsVertexType,
Use<CFace> ::AsFaceType>{};
/* define a vertex passing the attributes you want it to have. Each attributes has its own class. /* define a vertex passing the attributes you want it to have. Each attributes has its own class.
Check vcg/simplex/vertex/component.h to find out the existing attributes. Note: then you could Check vcg/simplex/vertex/component.h to find out the existing attributes. Note: then you could
also personalized attributes */ also personalized attributes */
class CVertex : public VertexSimp2< CVertex, CEdge, CFace, vertex::Coord3f, vertex::Normal3f >{}; class CVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f >{};
/*same as for the vertes */ /*same as for the vertes */
class CFace : public FaceSimp2< CVertex, CEdge, CFace, face::VertexRef, face::Normal3f > {}; class CFace : public Face< MyUsedTypes, face::VertexRef, face::Normal3f > {};
/*the mesh is a container of vertices and a container of faces */ /*the mesh is a container of vertices and a container of faces */
class CMesh : public vcg::tri::TriMesh< vector<CVertex>, vector<CFace> > {}; class CMesh : public vcg::tri::TriMesh< vector<CVertex>, vector<CFace> > {};

10
apps/sample/trimesh_attribute/trimesh_attribute.cpp
View File

@ -6,11 +6,15 @@
#include<vcg/complex/trimesh/base.h> #include<vcg/complex/trimesh/base.h>
#include<vcg/complex/trimesh/allocate.h> #include<vcg/complex/trimesh/allocate.h>
class MyEdge;
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyEdge; // dummy prototype never used struct MyUsedTypes : public vcg::UsedTypes< vcg::Use<MyVertex> ::AsVertexType,
class MyVertex : public vcg::VertexSimp2< MyVertex, MyEdge, MyFace, vcg::vertex::Coord3f,vcg::vertex::Normal3f>{}; vcg::Use<MyFace> ::AsFaceType>{};
class MyFace : public vcg::FaceSimp2< MyVertex, MyEdge, MyFace, vcg::face::VertexRef, vcg::face::Normal3f> {};
class MyVertex : public vcg::Vertex< MyUsedTypes, vcg::vertex::Coord3f,vcg::vertex::Normal3f>{};
class MyFace : public vcg::Face< MyUsedTypes, vcg::face::VertexRef, vcg::face::Normal3f> {};
class MyMesh : public vcg::tri::TriMesh< std::vector<MyVertex>, std::vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh< std::vector<MyVertex>, std::vector<MyFace> > {};

8
apps/sample/trimesh_ball_pivoting/trimesh_ball_pivoting.cpp
View File

@ -28,12 +28,14 @@
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags, vertex::Mark>{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef, face::Normal3f, face::BitFlags > {}; Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags, vertex::Mark>{};
class MyFace : public Face < MyUsedTypes, face::VertexRef, face::Normal3f, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {};
bool callback(int percent, const char *str) { bool callback(int percent, const char *str) {

50
apps/sample/trimesh_base/trimesh_base.cpp
View File

@ -23,8 +23,12 @@
#include<vcg/simplex/vertex/base.h> #include<vcg/simplex/vertex/base.h>
#include<vcg/simplex/vertex/component.h> #include<vcg/simplex/vertex/component.h>
#include <vcg/complex/used_types.h>
#include<vcg/simplex/face/base.h> #include<vcg/simplex/face/base.h>
#include<vcg/simplex/face/component.h> #include<vcg/simplex/face/component.h>
#include<vcg/simplex/face/topology.h> #include<vcg/simplex/face/topology.h>
#include<vcg/complex/trimesh/base.h> #include<vcg/complex/trimesh/base.h>
@ -36,40 +40,44 @@
#include<vcg/complex/trimesh/update/topology.h> #include<vcg/complex/trimesh/update/topology.h>
// normals // normals
#include<vcg/complex/trimesh/update/normal.h> //class UpdateNormals #include<vcg/complex/trimesh/update/normal.h> //class UpdateNormals
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype class MyEdge;
class MyFace; class MyFace;
class MyVertex; class MyVertex;
struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
Use<MyEdge> ::AsEdgeType,
Use<MyFace> ::AsFaceType>{};
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{}; class MyVertex : public Vertex<MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{};
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::FFAdj, face::VertexRef, face::BitFlags > {}; class MyFace : public Face< MyUsedTypes, face::FFAdj, face::VertexRef, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {}; class MyEdge : public Edge<MyUsedTypes>{};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> , vector<MyEdge> > {};
int main( int argc, char **argv ) int main( int argc, char **argv )
{ {
if(argc<2) if(argc<2)
{ {
printf("Usage trimesh_base <meshfilename.ply>\n"); printf("Usage trimesh_base <meshfilename.ply>\n");
return -1; return -1;
} }
MyMesh m; MyMesh m;
if(vcg::tri::io::ImporterPLY<MyMesh>::Open(m,argv[1])!=0) if(vcg::tri::io::ImporterPLY<MyMesh>::Open(m,argv[1])!=0)
{ {
printf("Error reading file %s\n",argv[1]); printf("Error reading file %s\n",argv[1]);
exit(0); exit(0);
} }
vcg::tri::UpdateTopology<MyMesh>::FaceFace(m); vcg::tri::UpdateTopology<MyMesh>::FaceFace(m);
vcg::tri::UpdateFlags<MyMesh>::FaceBorderFromFF(m); vcg::tri::UpdateFlags<MyMesh>::FaceBorderFromFF(m);
vcg::tri::UpdateNormals<MyMesh>::PerVertexNormalized(m); vcg::tri::UpdateNormals<MyMesh>::PerVertexNormalized(m);
printf("Input mesh vn:%i fn:%i\n",m.vn,m.fn); printf("Input mesh vn:%i fn:%i\n",m.vn,m.fn);
printf( "Mesh has %i vert and %i faces\n", m.vn, m.fn ); printf( "Mesh has %i vert and %i faces\n", m.vn, m.fn );
return 0; return 0;
} }

8
apps/sample/trimesh_clustering/trimesh_clustering.cpp
View File

@ -27,12 +27,14 @@
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef, face::Normal3f, face::BitFlags > {}; Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{};
class MyFace : public Face < MyUsedTypes, face::VertexRef, face::Normal3f, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {};
int main(int argc, char **argv) int main(int argc, char **argv)

9
apps/sample/trimesh_hole/trimesh_hole.cpp
View File

@ -32,12 +32,15 @@
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::BitFlags, vertex::Normal3f, vertex::Mark, vertex::Color4b >{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef,face::FFAdj, face::Mark, face::BitFlags, face::Normal3f> {}; Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::BitFlags, vertex::Normal3f, vertex::Mark, vertex::Color4b >{};
class MyFace : public Face < MyUsedTypes, face::VertexRef,face::FFAdj, face::Mark, face::BitFlags, face::Normal3f> {};
class MyMesh : public tri::TriMesh< vector<MyVertex>, vector<MyFace > >{}; class MyMesh : public tri::TriMesh< vector<MyVertex>, vector<MyFace > >{};

13
apps/sample/trimesh_intersection/trimesh_intersection.cpp
View File

@ -33,9 +33,16 @@ using namespace vcg;
class MyFace; class MyFace;
class MyEdge; class MyEdge;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::BitFlags, vertex::Normal3f, vertex::Mark>{}; class MyVertex;
class MyEdge : public EdgeSimp2< MyVertex,MyEdge, MyFace, edge::VertexRef, edge::EVAdj> {};
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef,face::FFAdj, face::BitFlags, face::Normal3f> {}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
Use<MyEdge> ::AsEdgeType,
Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::BitFlags, vertex::Normal3f, vertex::Mark>{};
class MyEdge : public Edge< MyUsedTypes, edge::VertexRef, edge::EVAdj> {};
class MyFace : public Face <MyUsedTypes, face::VertexRef,face::FFAdj, face::BitFlags, face::Normal3f> {};
class MyEdgeMesh: public vcg::edg::EdgeMesh< vector<MyVertex>, vector<MyEdge> > {}; class MyEdgeMesh: public vcg::edg::EdgeMesh< vector<MyVertex>, vector<MyEdge> > {};
class MyMesh : public tri::TriMesh< vector<MyVertex>, vector<MyFace > >{}; class MyMesh : public tri::TriMesh< vector<MyVertex>, vector<MyFace > >{};

9
apps/sample/trimesh_isosurface/trimesh_isosurface.cpp
View File

@ -19,11 +19,14 @@ using namespace vcg;
typedef float ScalarType; typedef float ScalarType;
class MyEdge;
class MyFace; class MyFace;
class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f>{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
class MyFace : public FaceSimp2< MyVertex, MyEdge, MyFace, face::VertexRef, face::BitFlags> {}; Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f>{};
class MyFace : public Face< MyUsedTypes, face::VertexRef, face::BitFlags> {};
//class MyVertex : public vcg::Vertex< ScalarType, MyEdge, MyFace > {}; //class MyVertex : public vcg::Vertex< ScalarType, MyEdge, MyFace > {};
//class MyFace : public vcg::Face< MyVertex, MyEdge, MyFace> {}; //class MyFace : public vcg::Face< MyVertex, MyEdge, MyFace> {};

8
apps/sample/trimesh_join/trimesh_join.cpp
View File

@ -21,12 +21,14 @@
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::BitFlags >{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex> ::AsVertexType,
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef, face::BitFlags > {}; Use<MyFace> ::AsFaceType>{};
class MyVertex : public Vertex <MyUsedTypes, vertex::Coord3f, vertex::BitFlags >{};
class MyFace : public Face < MyUsedTypes, face::VertexRef, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {};

56
apps/sample/trimesh_optional/trimesh_optional.cpp
View File

@ -1,17 +1,8 @@
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include<vcg/simplex/vertex/base.h> #include "mesh_definition.h"
#include<vcg/simplex/face/base.h> #include<vcg/complex/trimesh/allocate.h>
#include<vcg/simplex/face/topology.h>
#include<vcg/simplex/vertex/component_ocf.h>
#include<vcg/simplex/face/component_ocf.h>
#include<vcg/simplex/vertex/component_occ.h>
#include<vcg/simplex/face/component_occ.h>
#include<vcg/complex/trimesh/base.h>
#include<vcg/complex/trimesh/create/platonic.h> #include<vcg/complex/trimesh/create/platonic.h>
#include<vcg/complex/trimesh/update/topology.h> #include<vcg/complex/trimesh/update/topology.h>
#include<vcg/complex/trimesh/update/flag.h> #include<vcg/complex/trimesh/update/flag.h>
@ -21,36 +12,23 @@
using namespace vcg; using namespace vcg;
using namespace std; using namespace std;
class CEdge; // dummy prototype never used
class CFace;
class CFaceOcf;
class CFaceOcc;
class CVertex;
class CVertexOcf;
// Optional stuff has two suffixes:
// OCF Optional Component Fast
// OCC Optional Component Compact
class CVertex : public VertexSimp2< CVertex, CEdge, CFace, vertex::Coord3f, vertex::BitFlags,vertex::Normal3f >{};
class CVertexOcf : public VertexSimp2< CVertexOcf, CEdge, CFaceOcf, vertex::Coord3f, vertex::BitFlags,vertex::Normal3f >{};
class CVertexOcc : public VertexSimp2< CVertexOcc, CEdge, CFaceOcc, vertex::Coord3f, vertex::BitFlags,vertex::Normal3f >{};
class CFace : public FaceSimp2< CVertex, CEdge, CFace, face::FFAdj, face::VertexRef, face::BitFlags, face::Normal3f > {};
class CFaceOcf : public FaceSimp2< CVertexOcf, CEdge, CFaceOcf, face::InfoOcf, face::FFAdjOcf, face::VertexRef, face::BitFlags, face::Normal3fOcf > {};
class CFaceOcc : public FaceSimp2< CVertexOcc, CEdge, CFaceOcc, face::FFAdjOcc, face::VertexRef, face::BitFlags, face::Normal3fOcc > {};
class CMesh : public vcg::tri::TriMesh< vector<CVertex >, vector<CFace > > {};
class CMeshOcf : public vcg::tri::TriMesh< vector<CVertexOcf>, face::vector_ocf<CFaceOcf> > {};
class CMeshOcc : public vcg::tri::TriMesh< vector_occ<CVertexOcc>, vector_occ<CFaceOcc > > {};
int main(int , char **) int main(int , char **)
{ {
CMesh cm;
CMeshOcf cmof; vcg::tri::Allocator<CMesh>::NameTypeScope bounds;
CMeshOcc cmoc; vcg::tri::Allocator<CMesh>::AddNameTypeBound<float>(bounds,"myfloat");
CMesh cm;
CMeshOcf cmof;
CMeshOcc cmoc;
CMesh::VertexPointer v = cm.face[0].V(0);
cmoc.face.EnableAttribute<CFaceOcc::NormalType>();
CMeshOcc::FaceIterator fi = vcg::tri::Allocator<CMeshOcc>::AddFaces(cmoc,1);
(*fi).N() = vcg::Point3f(9,9,9);
tri::Tetrahedron(cm); tri::Tetrahedron(cm);

9
apps/sample/trimesh_refine/trimesh_refine.cpp
View File

@ -32,8 +32,11 @@ class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{}; struct MyUsedTypes : public UsedTypes< Use<MyVertex>::AsVertexType,
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::FFAdj, face::VertexRef, face::BitFlags > {}; Use<MyFace>::AsFaceType>{};
class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{};
class MyFace : public Face < MyUsedTypes, face::FFAdj, face::VertexRef, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {};
@ -90,7 +93,7 @@ int main(int argc, char **argv)
for(i=0;i < n_steps;++i) for(i=0;i < n_steps;++i)
{ {
switch(RefMode){ switch(RefMode){
case FLAT: Refine<MyMesh, MidPoint<MyMesh> >(m,MidPoint<MyMesh>(),length); break; case FLAT: Refine<MyMesh, MidPoint<MyMesh> >(m,MidPoint<MyMesh>(&m),length); break;
case BUTTERFLY: Refine<MyMesh, MidPointButterfly<MyMesh> >(m,MidPointButterfly<MyMesh>(),length); break; case BUTTERFLY: Refine<MyMesh, MidPointButterfly<MyMesh> >(m,MidPointButterfly<MyMesh>(),length); break;
} }
} }

7
apps/sample/trimesh_smooth/trimesh_smooth.cpp
View File

@ -21,12 +21,13 @@ using namespace vcg;
using namespace std; using namespace std;
class MyEdge; // dummy prototype never used
class MyFace; class MyFace;
class MyVertex; class MyVertex;
struct MyUsedTypes : public UsedTypes< Use<MyVertex>::AsVertexType,
Use<MyFace>::AsFaceType>{};
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::VFAdj, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{}; class MyVertex : public Vertex< MyUsedTypes, vertex::VFAdj, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{};
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VFAdj, face::Normal3f, face::VertexRef, face::BitFlags > {}; class MyFace : public Face < MyUsedTypes, face::VFAdj, face::Normal3f, face::VertexRef, face::BitFlags > {};
class MyMesh : public vcg::tri::TriMesh<vector<MyVertex>, vector<MyFace> > {}; class MyMesh : public vcg::tri::TriMesh<vector<MyVertex>, vector<MyFace> > {};
int main(int argc,char ** argv) int main(int argc,char ** argv)

32
apps/sample/trimesh_split_vertex/trimesh_split_vertex.cpp
View File

@ -14,25 +14,28 @@
this sample shows how to transfer per wedge attributes from wedges to vertices. this sample shows how to transfer per wedge attributes from wedges to vertices.
during the process new vertices could be created. during the process new vertices could be created.
*/ */
using namespace vcg;
#define TEST_IN_PLACE_SPLIT #define TEST_IN_PLACE_SPLIT
#ifdef TEST_IN_PLACE_SPLIT #ifdef TEST_IN_PLACE_SPLIT
class SrcVertex; class SrcVertex;
class SrcEdge;
class SrcFace; class SrcFace;
class SrcVertex : public vcg::VertexSimp2 struct ScrUsedTypes : public UsedTypes< Use<SrcVertex>::AsVertexType,
< SrcVertex, SrcEdge, SrcFace, Use<SrcFace>::AsFaceType>{};
class SrcVertex : public vcg::Vertex
< ScrUsedTypes,
vcg::vertex::InfoOcf, vcg::vertex::InfoOcf,
vcg::vertex::Coord3f, vcg::vertex::Coord3f,
vcg::vertex::TexCoordfOcf, vcg::vertex::TexCoordfOcf,
vcg::vertex::BitFlags vcg::vertex::BitFlags
> { }; > { };
class SrcFace : public vcg::FaceSimp2 class SrcFace : public vcg::Face
< SrcVertex, SrcEdge, SrcFace, < ScrUsedTypes,
vcg::face::InfoOcf, vcg::face::InfoOcf,
vcg::face::VertexRef, vcg::face::VertexRef,
vcg::face::WedgeTexCoordfOcf vcg::face::WedgeTexCoordfOcf
@ -48,21 +51,26 @@ typedef SrcMesh DstMesh;
// source mesh type: per-wedge texture coordinates // source mesh type: per-wedge texture coordinates
class SrcVertex; class SrcVertex;
class SrcEdge;
class SrcFace; class SrcFace;
class SrcVertex : public vcg::VertexSimp2 <SrcVertex, SrcEdge, SrcFace, vcg::vertex::Coord3f, vcg::vertex::TexCoord2f, vcg::vertex::BitFlags> { };
class SrcFace : public vcg::FaceSimp2 <SrcVertex, SrcEdge, SrcFace, vcg::face::VertexRef, vcg::face::WedgeTexCoord2f> { }; struct SrcUsedTypes : public UsedTypes< Use<SrcVertex>::AsVertexType,
Use<SrcFace>::AsFaceType>{};
class SrcVertex : public vcg::Vertex <SrcUsedTypes, vcg::vertex::Coord3f, vcg::vertex::TexCoord2f, vcg::vertex::BitFlags> { };
class SrcFace : public vcg::Face <SrcUsedTypes, vcg::face::VertexRef, vcg::face::WedgeTexCoord2f> { };
class SrcMesh : public vcg::tri::TriMesh <std::vector<SrcVertex>, std::vector<SrcFace> > { }; class SrcMesh : public vcg::tri::TriMesh <std::vector<SrcVertex>, std::vector<SrcFace> > { };
// destination mesh type: per-vertex texture coordinates // destination mesh type: per-vertex texture coordinates
class DstVertex; class DstVertex;
class DstEdge;
class DstFace; class DstFace;
class DstVertex : public vcg::VertexSimp2 <DstVertex, DstEdge, DstFace, vcg::vertex::Coord3f, vcg::vertex::TexCoord2f, vcg::vertex::BitFlags> { }; struct DstUsedTypes : public UsedTypes< Use<SrcVertex>::AsVertexType,
class DstFace : public vcg::FaceSimp2 <DstVertex, DstEdge, DstFace, vcg::face::VertexRef> { }; Use<SrcFace>::AsFaceType>{};
class DstVertex : public vcg::Vertex <DstUsedTypes, vcg::vertex::Coord3f, vcg::vertex::TexCoord2f, vcg::vertex::BitFlags> { };
class DstFace : public vcg::Face <DstUsedTypes, vcg::face::VertexRef> { };
class DstMesh : public vcg::tri::TriMesh <std::vector<DstVertex>, std::vector<DstFace> > { }; class DstMesh : public vcg::tri::TriMesh <std::vector<DstVertex>, std::vector<DstFace> > { };
#endif #endif

8
apps/sample/trimesh_topology/trimesh_topology.cpp
View File

@ -16,12 +16,14 @@
using namespace vcg; using namespace vcg;
class MyEdge; // dummy prototype never used class MyEdge;
class MyFace; class MyFace;
class MyVertex; class MyVertex;
struct MyUsedTypes : public UsedTypes< Use<MyVertex>::AsVertexType,
Use<MyFace>::AsFaceType>{};
class MyVertex : public VertexSimp2< MyVertex, MyEdge, MyFace, vertex::Coord3f, vertex::BitFlags >{}; class MyVertex : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::BitFlags >{};
class MyFace : public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef,face::FFAdj, face::Mark, face::BitFlags > {}; class MyFace : public Face < MyUsedTypes, face::VertexRef,face::FFAdj, face::Mark, face::BitFlags > {};
//class MyVertex:public Vertex<float,MyEdge,MyFace>{}; //class MyVertex:public Vertex<float,MyEdge,MyFace>{};