vcglib: base.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *   
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 
00024 #ifndef __VCG_EDGE_PLUS
00025 #define __VCG_EDGE_PLUS
00026 
00027 //#include <vcg/space/point3.h>
00028 //#include <vcg/space/texcoord2.h>
00029 //#include <vcg/space/color4.h>
00030 #include <vcg/complex/all_types.h>
00031 //#include <vcg/complex/used_types.h>
00032 #include <vcg/simplex/edge/component.h>
00033 #include <vcg/container/derivation_chain.h>
00034 
00035 namespace vcg {
00036 
00037 /*------------------------------------------------------------------*/ 
00038 /* 
00039 The base class of all the recusive definition chain. It is just a container of the typenames of the various simplexes.
00040 These typenames must be known form all the derived classes.
00041 */
00042 
00043 template <class UserTypes>
00044                                 class EdgeTypeHolder: public UserTypes{
00045   public:
00046 
00047         template < class LeftV>
00048         void ImportData(const LeftV  & /* left */ ) { }
00049         static void Name(std::vector<std::string> & name){}
00050 
00051 };
00052 
00053 /* The base class form which we start to add our components.
00054 it has the empty definition for all the standard members (coords, color flags)
00055 Note:
00056 in order to avoid both virtual classes and ambiguous definitions all 
00057 the subsequent overrides must be done in a sequence of derivation.
00058 
00059 In other words we cannot derive and add in a single derivation step 
00060 (with multiple ancestor), both the real (non-empty) normal and color but 
00061 we have to build the type a step a time (deriving from a single ancestor at a time). 
00062 
00063 
00064 */ 
00065 template <class UserTypes>
00066                                 class EdgeBase: public            edge::EmptyEFAdj<
00067                                                                                                                                                 edge::EmptyEVAdj<
00068                                                                                                                                                 edge::EmptyEEAdj<
00069                                                                                                                                                 edge::EmptyEHAdj<
00070                                                                                                                                                 edge::EmptyBitFlags<
00071                                                                                                                                                 EdgeTypeHolder < UserTypes> >  > > > >{};
00072 
00073 
00074 /* The Real Big Edge class;
00075 
00076 The class __VertexArityMax__ is the one that is the Last to be derived,
00077 and therefore is the only one to know the real members 
00078 (after the many overrides) so all the functions with common behaviour 
00079 using the members defined in the various Empty/nonEmpty component classes 
00080 MUST be defined here. 
00081 
00082 I.e. IsD() that uses the overridden Flags() member must be defined here.
00083 
00084 */
00085 
00086 template <class UserTypes,
00087           template <typename> class A, template <typename> class B, 
00088           template <typename> class C, template <typename> class D, 
00089           template <typename> class E, template <typename> class F,
00090           template <typename> class G, template <typename> class H,
00091                                         template <typename> class I, template <typename> class J, 
00092                                         template <typename> class K> 
00093 class EdgeArityMax: public K<Arity10<EdgeBase<UserTypes>, A, B, C, D, E, F, G, H, I, J> > {
00094 
00095 // ----- Flags stuff -----
00096 public:
00097   
00098 
00099         enum { 
00100                 
00101                 DELETED    = 0x0001,            // This bit indicate that the edge is deleted from the mesh
00102                 NOTREAD    = 0x0002,            // This bit indicate that the edge of the mesh is not readable
00103                 NOTWRITE   = 0x0004,            // This bit indicate that the edge is not modifiable
00104                 MODIFIED   = 0x0008,            // This bit indicate that the edge is modified
00105                 VISITED    = 0x0010,            // This bit can be used to mark the visited edge
00106                 SELECTED   = 0x0020,            // This bit can be used to select 
00107                 BORDER     = 0x0100,    // Border Flag
00108                 USER0      = 0x0200                     // First user bit
00109                         };
00110 
00111         inline int & UberFlags () { return this->Flags();       }
00112         inline int UberFlags() const    {               return this->Flags();   }
00113         
00114         bool IsD() const {return (this->Flags() & DELETED) != 0;} 
00115         bool IsR() const {return (this->Flags() & NOTREAD) == 0;} 
00116         bool IsW() const {return (this->Flags() & NOTWRITE)== 0;}
00117         bool IsRW() const {return (this->Flags() & (NOTREAD | NOTWRITE)) == 0;}
00118         bool IsS() const {return (this->Flags() & SELECTED) != 0;}
00119         bool IsB() const {return (this->Flags() & BORDER) != 0;}
00120         bool IsV() const {return (this->Flags() & VISITED) != 0;}
00121         
00122 
00126         void SetFlags(int flagp) {this->Flags()=flagp;}
00127 
00131         void ClearFlags() {this->Flags()=0;}
00132         void SetD() {this->Flags() |=DELETED;}
00133         void ClearD() {this->Flags() &=(~DELETED);}
00134         void SetR() {this->Flags() &=(~NOTREAD);}
00135         void ClearR() {this->Flags() |=NOTREAD;}
00136         void ClearW() {this->Flags() |=NOTWRITE;}
00137         void SetW() {this->Flags() &=(~NOTWRITE);}
00138         void SetS()             {this->Flags() |=SELECTED;}
00139         void ClearS()   {this->Flags() &= ~SELECTED;}
00140         void SetB()             {this->Flags() |=BORDER;}
00141         void ClearB()   {this->Flags() &=~BORDER;}
00142         void SetV()             {this->Flags() |=VISITED;}
00143         void ClearV()   {this->Flags() &=~VISITED;}
00144         
00146 static int &LastBitFlag()
00147                 {
00148                         static int b =USER0;
00149                         return b;
00150                 }
00151 
00153 static inline int NewBitFlag()
00154                 {
00155                         LastBitFlag()=LastBitFlag()<<1;
00156                         return LastBitFlag();
00157                 }
00158 // de-allocate a bit among the flags that can be used by user.
00159 static inline bool DeleteBitFlag(int bitval)
00160                 {       
00161                         if(LastBitFlag()==bitval) {
00162                                         LastBitFlag()= LastBitFlag()>>1;
00163                                         return true;
00164                         }
00165                         assert(0);
00166                         return false;
00167                 }
00169         bool IsUserBit(int userBit){return (this->Flags() & userBit) != 0;}
00171         void SetUserBit(int userBit){this->Flags() |=userBit;}
00173         void ClearUserBit(int userBit){this->Flags() &= (~userBit);}
00174 
00175  template<class BoxType>
00176   void GetBBox( BoxType & bb ) const {  
00177         bb.SetNull();
00178         bb.Add(this->cP(0));  
00179         bb.Add(this->cP(1));  
00180         }
00181 
00182           };
00183 
00184           
00185 /*
00186 
00187 These are the three main classes that are used by the library user to define its own edges.
00188 The user MUST specify the names of all the type involved in a generic complex.
00189 so for example when defining a vertex of a trimesh you must know the name of the type of the edge and of the face.
00190 Typical usage example:
00191 
00192 A vertex with coords, flags and normal for use in a standard trimesh:
00193 
00194 class VertexNf   : public VertexSimp2< VertexNf, EdgeProto, FaceProto, vert::Coord3d, vert::Flag, vert::Normal3f  > {};
00195 
00196 
00197 A vertex with coords, and normal for use in a tetrahedral mesh AND in a standard trimesh:
00198 
00199 class TetraVertex   : public VertexSimp3< TetraVertex, EdgeProto, FaceProto, TetraProto, vert::Coord3d, vert::Normal3f  > {};
00200 
00201 
00202 A summary of the available vertex attributes (see component.h for more details):
00203           
00204 Coord3f,  Coord3d, 
00205 Normal3s,  Normal3f,  Normal3d
00206 Mark                              //a int component (incremental mark)
00207 BitFlags
00208 TexCoord2s,  TexCoord2f,  TexCoord2d
00209 Color4b
00210 Qualitys, Qualityf, Qualityd
00211 VFAdj                             //topology (vertex->face adjacency)
00212 */
00213 
00214 template <class UserTypes,
00215           template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
00216           template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
00217           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
00218           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
00219                                         template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
00220                                         template <typename> class K = DefaultDeriver> 
00221                                                         class Edge: public EdgeArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J, K>  {
00222                                                 public: typedef AllTypes::AEdgeType IAm; typedef UserTypes TypesPool;};
00223 
00224 }// end namespace
00225 #endif