vcglib: hedge.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_HEDGE_ 
00025 #define __VCG_HEDGE_ 
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/connectors/hedge_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 HEdgeTypeHolder: 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 HEdgeBase: public
00067                                                                 hedge::EmptyHEdgeData<
00068                                                                 hedge::EmptyBitFlags<
00069                                                                 HEdgeTypeHolder < UserTypes> >  >  {
00070 };
00071 
00072 
00073 /* The Real Big Edge class;
00074 
00075 The class __VertexArityMax__ is the one that is the Last to be derived,
00076 and therefore is the only one to know the real members 
00077 (after the many overrides) so all the functions with common behaviour 
00078 using the members defined in the various Empty/nonEmpty component classes 
00079 MUST be defined here. 
00080 
00081 I.e. IsD() that uses the overridden Flags() member must be defined here.
00082 
00083 */
00084 
00085 template <class UserTypes,
00086           template <typename> class A, template <typename> class B, 
00087           template <typename> class C, template <typename> class D, 
00088           template <typename> class E, template <typename> class F,
00089           template <typename> class G, template <typename> class H,
00090                                         template <typename> class I, template <typename> class J, 
00091                                         template <typename> class K> 
00092 class HEdgeArityMax: public K<Arity10<HEdgeBase<UserTypes>, A, B, C, D, E, F, G, H, I, J> > {
00093 
00094 // ----- Flags stuff -----
00095 public:
00096   
00097 
00098         enum { 
00099                 
00100                 DELETED    = 0x0001,            // This bit indicate that the edge is deleted from the mesh
00101                 NOTREAD    = 0x0002,            // This bit indicate that the edge of the mesh is not readable
00102                 NOTWRITE   = 0x0004,            // This bit indicate that the edge is not modifiable
00103                 MODIFIED   = 0x0008,            // This bit indicate that the edge is modified
00104                 VISITED    = 0x0010,            // This bit can be used to mark the visited edge
00105                 SELECTED   = 0x0020,            // This bit can be used to select 
00106                 BORDER     = 0x0100,    // Border Flag
00107                 USER0      = 0x0200                     // First user bit
00108                         };
00109 
00110         inline int & UberFlags () { return this->Flags();       }
00111         inline int UberFlags() const    {               return this->Flags();   }
00112         
00113         bool IsD() const {return (this->Flags() & DELETED) != 0;} 
00114         bool IsR() const {return (this->Flags() & NOTREAD) == 0;} 
00115         bool IsW() const {return (this->Flags() & NOTWRITE)== 0;}
00116         bool IsRW() const {return (this->Flags() & (NOTREAD | NOTWRITE)) == 0;}
00117         bool IsS() const {return (this->Flags() & SELECTED) != 0;}
00118         bool IsB() const {return (this->Flags() & BORDER) != 0;}
00119         bool IsV() const {return (this->Flags() & VISITED) != 0;}
00120         
00121 
00125         void SetFlags(int flagp) {this->Flags()=flagp;}
00126 
00130         void ClearFlags() {this->Flags()=0;}
00131         void SetD() {this->Flags() |=DELETED;}
00132         void ClearD() {this->Flags() &=(~DELETED);}
00133         void SetR() {this->Flags() &=(~NOTREAD);}
00134         void ClearR() {this->Flags() |=NOTREAD;}
00135         void ClearW() {this->Flags() |=NOTWRITE;}
00136         void SetW() {this->Flags() &=(~NOTWRITE);}
00137         void SetS()             {this->Flags() |=SELECTED;}
00138         void ClearS()   {this->Flags() &= ~SELECTED;}
00139         void SetB()             {this->Flags() |=BORDER;}
00140         void ClearB()   {this->Flags() &=~BORDER;}
00141         void SetV()             {this->Flags() |=VISITED;}
00142         void ClearV()   {this->Flags() &=~VISITED;}
00143         
00145 static int &LastBitFlag()
00146                 {
00147                         static int b =USER0;
00148                         return b;
00149                 }
00150 
00152 static inline int NewBitFlag()
00153                 {
00154                         LastBitFlag()=LastBitFlag()<<1;
00155                         return LastBitFlag();
00156                 }
00157 // de-allocate a bit among the flags that can be used by user.
00158 static inline bool DeleteBitFlag(int bitval)
00159                 {       
00160                         if(LastBitFlag()==bitval) {
00161                                         LastBitFlag()= LastBitFlag()>>1;
00162                                         return true;
00163                         }
00164                         assert(0);
00165                         return false;
00166                 }
00168         bool IsUserBit(int userBit){return (this->Flags() & userBit) != 0;}
00170         void SetUserBit(int userBit){this->Flags() |=userBit;}
00172         void ClearUserBit(int userBit){this->Flags() &= (~userBit);}
00173 
00174  template<class BoxType>
00175   void GetBBox( BoxType & bb ) const {  
00176         bb.SetNull();
00177         bb.Add(this->cP(0));  
00178         bb.Add(this->cP(1));  
00179         }
00180 
00181           };
00182 
00183           
00184 /*
00185 
00186 These are the three main classes that are used by the library user to define its own edges.
00187 The user MUST specify the names of all the type involved in a generic complex.
00188 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.
00189 Typical usage example:
00190 
00191 A vertex with coords, flags and normal for use in a standard trimesh:
00192 
00193 class VertexNf   : public VertexSimp2< VertexNf, EdgeProto, FaceProto, vert::Coord3d, vert::Flag, vert::Normal3f  > {};
00194 
00195 
00196 A vertex with coords, and normal for use in a tetrahedral mesh AND in a standard trimesh:
00197 
00198 class TetraVertex   : public VertexSimp3< TetraVertex, EdgeProto, FaceProto, TetraProto, vert::Coord3d, vert::Normal3f  > {};
00199 
00200 
00201 A summary of the available vertex attributes (see component.h for more details):
00202           
00203 Coord3f,  Coord3d, 
00204 Normal3s,  Normal3f,  Normal3d
00205 Mark                              //a int component (incremental mark)
00206 BitFlags
00207 TexCoord2s,  TexCoord2f,  TexCoord2d
00208 Color4b
00209 Qualitys, Qualityf, Qualityd
00210 VFAdj                             //topology (vertex->face adjacency)
00211 */
00212 
00213 template <class UserTypes,
00214           template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
00215           template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
00216           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
00217           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
00218                                         template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
00219                                         template <typename> class K = DefaultDeriver> 
00220                                                         class HEdge: public HEdgeArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J, K>  {
00221                                                 public: typedef AllTypes::AHEdgeType IAm; typedef UserTypes TypesPool;};
00222 
00223 }// end namespace
00224 #endif