diff --git a/vcg/simplex/tetrahedronplus/base.h b/vcg/simplex/tetrahedronplus/base.h deleted file mode 100644 index b29a396c..00000000 --- a/vcg/simplex/tetrahedronplus/base.h +++ /dev/null @@ -1,326 +0,0 @@ -/**************************************************************************** -* VCGLib o o * -* Visual and Computer Graphics Library o o * -* _ O _ * -* Copyright(C) 2004 \/)\/ * -* 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. * -* * -****************************************************************************/ -/**************************************************************************** - History - -$Log: not supported by cvs2svn $ -Revision 1.1 2007/05/09 10:31:53 ganovelli -added - - - -****************************************************************************/ -#ifndef __VCG_TETRA_PLUS -#define __VCG_TETRA_PLUS - -#include -#include -#include -#include - -namespace vcg { - -/*------------------------------------------------------------------*/ -/* -The base class of all the recusive definition chain. It is just a container of the typenames of the various simplexes. -These typenames must be known form all the derived classes. -*/ - -template -class TetraTypeHolder{ - public: - typedef BVT VertexType; - typedef typename VertexType::CoordType CoordType; - typedef typename VertexType::ScalarType ScalarType; - typedef BET EdgeType; - typedef BFT FaceType; - typedef BTT TetraType; - typedef BVT *VertPointer; - typedef BET *EdgePointer; - typedef BFT *FacePointer; - typedef BTT *TetraPointer; - static void Name(std::vector & name){} - - - // prot - -}; - -/* The base class form which we start to add our components. -it has the empty definition for all the standard members (coords, color flags) -Note: -in order to avoid both virtual classes and ambiguous definitions all -the subsequent overrides must be done in a sequence of derivation. - -In other words we cannot derive and add in a single derivation step -(with multiple ancestor), both the real (non-empty) normal and color but -we have to build the type a step a time (deriving from a single ancestor at a time). - - -*/ -template -class TetraBase: public tetra::EmptyVertexRef< - tetra::EmptyAdj< - TetraTypeHolder > > { -}; - - - -// Metaprogramming Core - -template class A> - class TetraArity1: public A > {}; - -template class A, template class B> - class TetraArity2: public B > {}; - -template class A, template class B, - template class C > - class TetraArity3: public C > {}; - -template class A, template class B, - template class C, template class D> - class TetraArity4: public D > {}; - -template class A, template class B, - template class C, template class D, - template class E > - class TetraArity5: public E > {}; - -template class A, template class B, - template class C, template class D, - template class E, template class F > - class TetraArity6: public F > {}; - -template class A, template class B, - template class C, template class D, - template class E, template class F, - template class G > - class TetraArity7: public G > {}; - -template class A, template class B, - template class C, template class D, - template class E, template class F, - template class G, template class H > - class TetraArity8: public H > {}; - -/* The Real Big Face class; - -The class __FaceArityMax__ is the one that is the Last to be derived, -and therefore is the only one to know the real members -(after the many overrides) so all the functions with common behaviour -using the members defined in the various Empty/nonEmpty component classes -MUST be defined here. - -I.e. IsD() that uses the overridden Flags() member must be defined here. - -*/ - -template class A, template class B, - template class C, template class D, - template class E, template class F, - template class G, template class H, - template class I > - class TetraArityMax: public I > { - -// ----- Flags stuff ----- -public: - - inline int & UberFlags () - { - return this->Flags(); - } - inline const int UberFlags() const - { - return this->Flags(); - } - enum { - - DELETED = 0x00000001, // Face is deleted from the mesh - NOTREAD = 0x00000002, // Face of the mesh is not readable - NOTWRITE = 0x00000004, // Face of the mesh is not writable - VISITED = 0x00000010, // Face has been visited. Usualy this is a per-algorithm used bit. - SELECTED = 0x00000020, // Face is selected. Algorithms should try to work only on selected face (if explicitly requested) - // Border _flags, it is assumed that BORDERi = BORDER0<Flags() & DELETED) != 0;} - /// checks if the Face is readable - bool IsR() const {return (this->Flags() & NOTREAD) == 0;} - /// checks if the Face is modifiable - bool IsW() const {return (this->Flags() & NOTWRITE)== 0;} - /// This funcion checks whether the Face is both readable and modifiable - bool IsRW() const {return (this->Flags() & (NOTREAD | NOTWRITE)) == 0;} - /// checks if the Face is Modified - bool IsS() const {return (this->Flags() & SELECTED) != 0;} - /// checks if the Face is Modified - bool IsV() const {return (this->Flags() & VISITED) != 0;} - - /** Set the flag value - @param flagp Valore da inserire nel flag - */ - void SetFlags(int flagp) {this->Flags()=flagp;} - - /** Set the flag value - @param flagp Valore da inserire nel flag - */ - void ClearFlags() {this->Flags()=0;} - - /// deletes the Face from the mesh - void SetD() {this->Flags() |=DELETED;} - /// un-delete a Face - void ClearD() {this->Flags() &=(~DELETED);} - /// marks the Face as readable - void SetR() {this->Flags() &=(~NOTREAD);} - /// marks the Face as not readable - void ClearR() {this->Flags() |=NOTREAD;} - /// marks the Face as writable - void SetW() {this->Flags() &=(~NOTWRITE);} - /// marks the Face as notwritable - void ClearW() {this->Flags() |=NOTWRITE;} - /// select the Face - void SetS() {this->Flags() |=SELECTED;} - /// Un-select a Face - void ClearS() {this->Flags() &= ~SELECTED;} - /// select the Face - void SetV() {this->Flags() |=VISITED;} - /// Un-select a Face - void ClearV() {this->Flags() &= ~VISITED;} - - /// This function checks if the face is selected - bool IsB(int i) const {return (this->Flags() & (BORDER0<Flags() |=(BORDER0<Flags() &= (~(BORDER0<>1; - return true; - } - assert(0); - return false; - } - /// This function checks if the given user bit is true - bool IsUserBit(int userBit){return (this->Flags() & userBit) != 0;} - /// This function set the given user bit - void SetUserBit(int userBit){this->Flags() |=userBit;} - /// This function clear the given user bit - void ClearUserBit(int userBit){this->Flags() &= (~userBit);} - - template - void GetBBox( BoxType & bb ) const - { - bb.Set(this->P(0)); - bb.Add(this->P(1)); - bb.Add(this->P(2)); - } - - -}; - -template < typename T=int> -class TetraDefaultDeriver : public T {}; - -/* - -These are the three main classes that are used by the library user to define its own Facees. -The user MUST specify the names of all the type involved in a generic complex. -so for example when defining a Face of a trimesh you must know the name of the type of the edge and of the face. -Typical usage example: - -A Face with coords, flags and normal for use in a standard trimesh: - -class MyFaceNf : public FaceSimp2< VertProto, EdgeProto, MyFaceNf, face::Flag, face::Normal3f > {}; - - -A Face with coords, and normal for use in a tetrahedral mesh AND in a standard trimesh: - -class TetraFace : public FaceSimp3< VertProto, EdgeProto, TetraFace, TetraProto, face::Coord3d, face::Normal3f > {}; - - -A summary of the components that can be added to a face (see components.h for details): - -VertexRef -Mark //Incremental mark (int) -VTAdj //Topology vertex face adjacency - (pointers to next face in the ring of the vertex -TTAdj //topology: face face adj - pointers to adjacent faces - -*/ - -template class A = TetraDefaultDeriver, template class B = TetraDefaultDeriver, - template class C = TetraDefaultDeriver, template class D = TetraDefaultDeriver, - template class E = TetraDefaultDeriver, template class F = TetraDefaultDeriver, - template class G = TetraDefaultDeriver, template class H = TetraDefaultDeriver, - template class I = TetraDefaultDeriver > - class TetraSimp3: public TetraArityMax {}; -class DumTT; -template class A = TetraDefaultDeriver, template class B = TetraDefaultDeriver, - template class C = TetraDefaultDeriver, template class D = TetraDefaultDeriver, - template class E = TetraDefaultDeriver, template class F = TetraDefaultDeriver, - template class G = TetraDefaultDeriver, template class H = TetraDefaultDeriver, - template class I = TetraDefaultDeriver > - class TetraSimp2: public TetraArityMax {}; - - -}// end namespace -#endif - diff --git a/vcg/simplex/tetrahedronplus/component.h b/vcg/simplex/tetrahedronplus/component.h deleted file mode 100644 index 7182ac43..00000000 --- a/vcg/simplex/tetrahedronplus/component.h +++ /dev/null @@ -1,267 +0,0 @@ -/**************************************************************************** -* VCGLib o o * -* Visual and Computer Graphics Library o o * -* _ O _ * -* Copyright(C) 2004 \/)\/ * -* 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. * -* * -****************************************************************************/ -/**************************************************************************** - History - -$Log: not supported by cvs2svn $ -Revision 1.1 2007/05/09 10:31:53 ganovelli -added - - - -****************************************************************************/ -#ifndef __VCG_TETRAHEDRON_PLUS_COMPONENT -#define __VCG_TETRAHEDRON_PLUS_COMPONENT - -#include -#include - -namespace vcg { - namespace tetra { -/* -Some naming Rules -All the Components that can be added to a vertex should be defined in the namespace vert: - -*/ - -/*-------------------------- VERTEX ----------------------------------------*/ -template class EmptyVertexRef: public T { -public: - // typedef typename T::VertexType VertexType; - // typedef typename T::CoordType CoordType; - inline typename T::VertexType * & V( const int j ) { assert(0); static typename T::VertexType *vp=0; return vp; } - inline typename T::VertexType * const & V( const int j ) const { assert(0); static typename T::VertexType *vp=0; return vp; } - inline typename T::VertexType * const cV( const int j ) const { assert(0); static typename T::VertexType *vp=0; return vp; } - inline typename T::CoordType & P( const int j ) { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; } - inline const typename T::CoordType & P( const int j ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; } - inline const typename T::CoordType &cP( const int j ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; } - static bool HasVertexRef() { return false; } - static void Name(std::vector & name){T::Name(name);} - -}; -template class VertexRef: public T { -public: - VertexRef(){ - v[0]=0; - v[1]=0; - v[2]=0; - } - - inline typename T::VertexType * & V( const int j ) { assert(j>=0 && j<4); return v[j]; } - inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && j<4); return v[j]; } - inline typename T::VertexType * const cV( const int j ) const { assert(j>=0 && j<4); return v[j]; } - - // Shortcut per accedere ai punti delle facce - inline typename T::CoordType & P( const int j ) { assert(j>=0 && j<4); return v[j]->P(); } - inline const typename T::CoordType & P( const int j ) const { assert(j>=0 && j<4); return v[j]->cP(); } - inline const typename T::CoordType &cP( const int j ) const { assert(j>=0 && j<4); return v[j]->cP(); } - - /** Return the pointer to the ((j+1)%3)-th vertex of the face. - @param j Index of the face vertex. - */ - inline typename T::VertexType * & V0( const int j ) { return V(j);} - inline typename T::VertexType * & V1( const int j ) { return V((j+1)%4);} - inline typename T::VertexType * & V2( const int j ) { return V((j+2)%4);} - inline const typename T::VertexType * const & V0( const int j ) const { return V(j);} - inline const typename T::VertexType * const & V1( const int j ) const { return V((j+1)%4);} - inline const typename T::VertexType * const & V2( const int j ) const { return V((j+2)%4);} - inline const typename T::VertexType * const & cV0( const int j ) const { return cV(j);} - inline const typename T::VertexType * const & cV1( const int j ) const { return cV((j+1)%4);} - inline const typename T::VertexType * const & cV2( const int j ) const { return cV((j+2)%4);} - - /// Shortcut to get vertex values - inline typename T::CoordType & P0( const int j ) { return V(j)->P();} - inline typename T::CoordType & P1( const int j ) { return V((j+1)%4)->P();} - inline typename T::CoordType & P2( const int j ) { return V((j+2)%4)->P();} - inline const typename T::CoordType & P0( const int j ) const { return V(j)->P();} - inline const typename T::CoordType & P1( const int j ) const { return V((j+1)%4)->P();} - inline const typename T::CoordType & P2( const int j ) const { return V((j+2)%4)->P();} - inline const typename T::CoordType & cP0( const int j ) const { return cV(j)->P();} - inline const typename T::CoordType & cP1( const int j ) const { return cV((j+1)%4)->P();} - inline const typename T::CoordType & cP2( const int j ) const { return cV((j+2)%4)->P();} - - inline typename T::VertexType * & UberV( const int j ) { assert(j>=0 && j<4); return v[j]; } - inline const typename T::VertexType * const & UberV( const int j ) const { assert(j>=0 && j<4); return v[j]; } - static bool HasVertexRef() { return true; } - static void Name(std::vector & name){name.push_back(std::string("VertexRef"));T::Name(name);} - - - private: - typename T::VertexType *v[4]; -}; - - -/*------------------------- FACE NORMAL -----------------------------------------*/ -template class EmptyFaceNormal: public T { -public: - typedef ::vcg::Point3 NormalType; - /// Return the vector of Flags(), senza effettuare controlli sui bit - NormalType N(const int & ){ static int dummynormal(0); return dummynormal; } - const NormalType cN(const int & ) const { return 0; } - static bool HasFaceNormal() { return false; } - static bool HasFaceNormalOcc() { return false; } - static void Name(std::vector & name){T::Name(name);} - -}; - -template class FaceNormal: public T { -public: - typedef ::vcg::Point3 NormalType; - - NormalType N(const int & i){ assert((i>=0)&&(i < 4)); return _facenormals[i]; } - const NormalType cN(const int & i) const { assert((i>=0)&&(i < 4)); return _facenormals[i]; } - static bool HasFaceNormals() { return true; } - static bool HasFaceNormalOcc() { return false; } - static void Name(std::vector & name){name.push_back(std::string("FaceNormal"));T::Name(name);} - -private: - NormalType _facenormals[4]; -}; - -template class FaceNormal3f: public FaceNormal{ -public:static void Name(std::vector & name){name.push_back(std::string("FaceNormal3f"));T::Name(name);} }; - -template class FaceNormal3d: public FaceNormal{ -public:static void Name(std::vector & name){name.push_back(std::string("FaceNormal3d"));T::Name(name);} }; - -/*------------------------- FLAGS -----------------------------------------*/ -template class EmptyBitFlags: public T { -public: - /// Return the vector of Flags(), senza effettuare controlli sui bit - int &Flags() { static int dummyflags(0); return dummyflags; } - const int Flags() const { return 0; } - static bool HasFlags() { return false; } - static bool HasFlagsOcc() { return false; } - static void Name(std::vector & name){T::Name(name);} - -}; - -template class BitFlags: public T { -public: - BitFlags(){_flags=0;} - int &Flags() {return _flags; } - const int Flags() const {return _flags; } - static bool HasFlags() { return true; } - static void Name(std::vector & name){name.push_back(std::string("BitFlags"));T::Name(name);} - - -private: - int _flags; -}; -/*-------------------------- INCREMENTAL MARK ----------------------------------------*/ - -template class EmptyMark: public T { -public: - typedef int MarkType; - static bool HasMark() { return false; } - static bool HasMarkOcc() { return false; } - inline void InitIMark() { } - inline int & IMark() { assert(0); static int tmp=-1; return tmp;} - inline const int IMark() const {return 0;} - static void Name(std::vector & name){T::Name(name);} - -}; -template class Mark: public T { -public: - static bool HasMark() { return true; } - static bool HasMarkOcc() { return true; } - inline void InitIMark() { _imark = 0; } - inline int & IMark() { return _imark;} - inline const int & IMark() const {return _imark;} - static void Name(std::vector & name){name.push_back(std::string("Mark"));T::Name(name);} - - private: - int _imark; -}; - - -/*----------------------------- VTADJ ------------------------------*/ - -template class EmptyAdj: public T { -public: - typedef int VFAdjType; - typename T::TetraPointer & VTp( const int ) { static typename T::TetraPointer tp=0; return tp; } - typename T::TetraPointer const cVTp( const int ) const { static typename T::TetraPointer const tp=0; return tp; } - typename T::TetraPointer & TTp( const int ) { static typename T::TetraPointer tp=0; return tp; } - typename T::TetraPointer const cTTp( const int ) const { static typename T::TetraPointer const tp=0; return tp; } - char & VTi( const int j ) { static char z=0; return z; } - char & TTi( const int j ) { static char z=0; return z; } - static bool HasVTAdjacency() { return false; } - static bool HasTTAdjacency() { return false; } - static bool HasTTAdjacencyOcc() { return false; } - static bool HasVTAdjacencyOcc() { return false; } - static void Name( std::vector< std::string > & name ){ T::Name(name); } -}; - -template class VTAdj: public T { -public: - VTAdj() { _vtp[0]=0; _vtp[1]=0; _vtp[2]=0; _vtp[3]=0; } - typename T::TetraPointer & VTp( const int j ) { assert( j >= 0 && j < 4 ); return _vtp[j]; } - typename T::TetraPointer const VTp( const int j ) const { assert( j >= 0 && j < 4 ); return _vtp[j]; } - typename T::TetraPointer const cVTp( const int j ) const { assert( j >= 0 && j < 4 ); return _vtp[j]; } - char & VTi( const int j ) { return _vti[j]; } - const char & cVTi( const int j ) const { return _vti[j]; } - static bool HasVTAdjacency() { return true; } - static bool HasVTAdjacencyOcc() { return false; } - static void Name( std::vector< std::string > & name ) { name.push_back( std::string("VTAdj") ); T::Name(name); } - -private: - typename T::TetraPointer _vtp[4]; - char _vti[4]; -}; - -/*----------------------------- TTADJ ------------------------------*/ - -template class TTAdj: public T { -public: - TTAdj(){ - _ttp[0]=0; - _ttp[1]=0; - _ttp[2]=0; - _ttp[3]=0; - } - typename T::TetraPointer &TTp(const int j) { assert(j>=0 && j<4); return _ttp[j]; } - typename T::TetraPointer const TTp(const int j) const { assert(j>=0 && j<4); return _ttp[j]; } - typename T::TetraPointer const cTTp(const int j) const { assert(j>=0 && j<4); return _ttp[j]; } - char &TTi(const int j) { return _tti[j]; } - const char &cTTi(const int j) const { return _tti[j]; } - - typename T::TetraPointer &TTp1( const int j ) { return TTp((j+1)%4);} - typename T::TetraPointer &TTp2( const int j ) { return TTp((j+2)%4);} - typename T::TetraPointer const TTp1( const int j ) const { return TTp((j+1)%4);} - typename T::TetraPointer const TTp2( const int j ) const { return TTp((j+2)%4);} - - bool IsBorderF(const int & i) const { assert( (i>=0) && (i < 4)); { return TTp(i) == this;}} - - static bool HasTTAdjacency() { return true; } - static bool HasTTAdjacencyOcc() { return false; } - static void Name(std::vector & name){name.push_back(std::string("TTAdj"));T::Name(name);} - -private: - typename T::TetraPointer _ttp[4] ; - char _tti[4] ; -}; - - } // end namespace vert -}// end namespace vcg -#endif