/**************************************************************************** * VCGLib o o * * Visual and Computer Graphics Library o o * * _ O _ * * Copyright(C) 2004-2016 \/)\/ * * 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 #include "component.h" namespace vcg { /*------------------------------------------------------------------*/ // /* 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 TetraTypeHolder: public UserTypes { public: template void ImportData(const RightT & ){} static void Name(std::vector & /* name */){} // prot inline int VN() const { return 4;} }; /* 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 TetraSimpBase: public tetrahedron::EmptyCore< TetraTypeHolder > { }; 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, template class J, template class K, template class L> class TetraArityMax: public Arity12, A, B, C, D, E, F, G, H, I, J, K, L> { // ----- Flags stuff ----- public: enum { DELETED = 0x00000001, // Tet is deleted from the mesh NOTREAD = 0x00000002, // Tet of the mesh is not readable NOTWRITE = 0x00000004, // Tet of the mesh is not writable VISITED = 0x00000010, // Tet has been visited. Usualy this is a per-algorithm used bit. SELECTED = 0x00000020, // Tet is selected. Algorithms should try to work only on selected face (if explicitly requested) // Border _flags, it is assumed that BORDERi = BORDER0<cFlags() & DELETED) != 0;} /// checks if the Tet is readable bool IsR() const {return (this->cFlags() & NOTREAD) == 0;} /// checks if the Tet is modifiable bool IsW() const {return (this->cFlags() & NOTWRITE)== 0;} /// This funcion checks whether the Tet is both readable and modifiable bool IsRW() const {return (this->cFlags() & (NOTREAD | NOTWRITE)) == 0;} /// checks if the Tet is Modified bool IsS() const {return (this->cFlags() & SELECTED) != 0;} /// checks if the Tet is Modified bool IsV() const {return (this->cFlags() & 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 Tet from the mesh void SetD() {this->Flags() |=DELETED;} /// un-delete a Tet void ClearD() {this->Flags() &=(~DELETED);} /// marks the Tet as readable void SetR() {this->Flags() &=(~NOTREAD);} /// marks the Tet as not readable void ClearR() {this->Flags() |=NOTREAD;} /// marks the Tet as writable void SetW() {this->Flags() &=(~NOTWRITE);} /// marks the Tet as notwritable void ClearW() {this->Flags() |=NOTWRITE;} /// select the Tet void SetS() {this->Flags() |=SELECTED;} /// Un-select a Tet void ClearS() {this->Flags() &= ~SELECTED;} /// select the Tet void SetV() {this->Flags() |=VISITED;} /// Un-select a Tet void ClearV() {this->Flags() &= ~VISITED;} /// This function checks if the face is border bool IsB(int i) const {return (this->cFlags() & (BORDER0<cFlags() & (BORDER0123)) != 0;} /// This function select the face void SetB(int i) {this->Flags() |=(BORDER0<Flags() &= (~(BORDER0<>1==bitval) { FirstUnusedBitFlag() = FirstUnusedBitFlag()>>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->cP(0)); bb.Add(this->cP(1)); bb.Add(this->cP(2)); bb.Add(this->cP(3)); } }; // 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 = DefaultDeriver, template class B = DefaultDeriver, template class C = DefaultDeriver, template class D = DefaultDeriver, template class E = DefaultDeriver, template class F = DefaultDeriver, template class G = DefaultDeriver, template class H = DefaultDeriver, template class I = DefaultDeriver, template class J = DefaultDeriver, template class K = DefaultDeriver, template class L = DefaultDeriver> class TetraSimp : public TetraArityMax { public: typedef AllTypes::ATetraType IAm; typedef UserTypes TypesPool;}; }// end namespace #endif