nevrax.org : docs

00001 
+00007 /* Copyright, 2000, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_LAYERED_ORDERING_TABLE_H
+00027 #define NL_LAYERED_ORDERING_TABLE_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "3d/ordering_table.h"
+00031 
+00032 namespace NL3D {
+00033 
+00034 
+00042 template <class T>
+00043 class CLayeredOrderingTable
+00044 {
+00045 public: 
+00046 
+00048         CLayeredOrderingTable();
+00049 
+00054         void init( uint32 nNbEntries );
+00055 
+00059         uint32 getSize();
+00060 
+00065         void reset(uint maxElementToInsert);
+00066 
+00072         void insert( uint layer, T *pValue, uint32 nEntryPos = 0 );
+00073 
+00088         inline void begin(bool forwardTraversal = true);
+00089 
+00093         inline T* get();
+00094 
+00098         inline void next();
+00099 
+00100 // =================
+00101 // =================
+00102 // IMPLEMENTATION.
+00103 // =================
+00104 // =================
+00105 private:
+00106         typedef std::vector<T *> TTypePtVect;
+00107         COrderingTable<T>               _Layer0;        
+00108         TTypePtVect                             _Layer1;
+00109         COrderingTable<T>               _Layer2;        
+00110         uint                                    _IndexInLayer1;
+00111         uint8                                   _CurrLayer;
+00112         bool                                    _ForwardTraversal;
+00113 };
+00114 
+00115 
+00118 template <class T>
+00119 CLayeredOrderingTable<T>::CLayeredOrderingTable()  : _IndexInLayer1(0), _CurrLayer(0), _ForwardTraversal(true){
+00120 
+00121 }
+00122 
+00123 //==================================================================
+00124 template <class T>
+00125 void CLayeredOrderingTable<T>::init( uint32 nNbEntries )
+00126 {
+00127         _Layer0.init(nNbEntries);
+00128         _Layer2.init(nNbEntries);
+00129 }
+00130 
+00131 //==================================================================
+00132 template <class T>
+00133 uint32 CLayeredOrderingTable<T>::getSize()
+00134 {
+00135         nlassert(_Layer0.getSize() == _Layer2.getSize());
+00136         return _Layer0.getSize();
+00137 }
+00138 
+00139 //==================================================================
+00140 template <class T>
+00141 void CLayeredOrderingTable<T>::reset(uint maxElementToInsert)
+00142 {
+00143         _Layer0.reset(maxElementToInsert);
+00144         _Layer2.reset(maxElementToInsert);
+00145         _Layer1.clear();
+00146 }
+00147 
+00148 //==================================================================
+00149 template <class T>
+00150 void CLayeredOrderingTable<T>::insert( uint layer, T *pValue, uint32 nEntryPos /* = 0 */)
+00151 {
+00152         switch (layer)
+00153         {
+00154                 case 0:                 
+00155                         _Layer0.insert(nEntryPos, pValue);
+00156                 break;
+00157                 case 1:                 
+00158                         _Layer1.push_back(pValue);
+00159                 break;
+00160                 case 2:                 
+00161                         _Layer2.insert(nEntryPos, pValue);
+00162                 break;
+00163                 default:
+00164                         nlassert(0); // invalid layer
+00165                 break;
+00166         }
+00167 }
+00168 
+00169 //==================================================================
+00170 template <class T>
+00171 inline void CLayeredOrderingTable<T>::begin(bool forwardTraversal /*= true*/)
+00172 {
+00173         _ForwardTraversal = forwardTraversal;
+00174         if (forwardTraversal)
+00175         {                               
+00176                 _Layer0.begin();
+00177                 if (!_Layer0.get())
+00178                 {
+00179                         if (_Layer1.size() != 0)
+00180                         {
+00181                                 _CurrLayer = 1;
+00182                                 _IndexInLayer1 = 0;
+00183                         }
+00184                         else
+00185                         {
+00186                                 _CurrLayer = 2;
+00187                                 _Layer2.begin();
+00188                         }
+00189                 }
+00190                 else
+00191                 {
+00192                         _CurrLayer = 0;
+00193                 }
+00194         }
+00195         else
+00196         {               
+00197                 _Layer2.begin();
+00198                 if (!_Layer2.get())
+00199                 {
+00200                         if (_Layer1.size() != 0)
+00201                         {
+00202                                 _CurrLayer = 1;
+00203                                 _IndexInLayer1 = 0;
+00204                         }
+00205                         else
+00206                         {
+00207                                 _CurrLayer = 0;
+00208                                 _Layer0.begin();
+00209                         }
+00210                 }
+00211                 else
+00212                 {
+00213                         _CurrLayer = 2;
+00214                 }
+00215         }
+00216 }
+00217 
+00218 //==================================================================
+00219 template <class T>
+00220 inline T* CLayeredOrderingTable<T>::get()
+00221 {
+00222         switch(_CurrLayer)
+00223         {
+00224                 case 0:                 
+00225                         return _Layer0.get();
+00226                 break;
+00227                 case 1:                 
+00228                         return _Layer1[_IndexInLayer1];
+00229                 break;
+00230                 case 2:                 
+00231                         return _Layer2.get();
+00232                 break;
+00233                 default:
+00234                         nlassert(0);
+00235                 break;
+00236         }
+00237         return NULL; // avoid warning
+00238 }
+00239 
+00240 //==================================================================
+00241 template <class T>
+00242 inline void CLayeredOrderingTable<T>::next()
+00243 {
+00244         if (_ForwardTraversal)
+00245         {               
+00246                 switch(_CurrLayer)
+00247                 {
+00248                         case 0:
+00249                                 _Layer0.next();
+00250                                 if (_Layer0.get() == NULL)
+00251                                 {
+00252                                         if (_Layer1.size() != 0)
+00253                                         {
+00254                                                 _CurrLayer = 1;
+00255                                                 _IndexInLayer1 = 0;
+00256                                         }
+00257                                         else
+00258                                         {
+00259                                                 _CurrLayer = 2;
+00260                                                 _Layer2.begin();
+00261                                         }
+00262                                 }
+00263 
+00264                         break;
+00265                         case 1:
+00266                                 ++ _IndexInLayer1;
+00267                                 if (_IndexInLayer1 == _Layer1.size())
+00268                                 {
+00269                                         _CurrLayer = 2;
+00270                                         _Layer2.begin();
+00271                                 }
+00272                         break;
+00273                         case 2:
+00274                                 _Layer2.next();
+00275                         break;
+00276                 }
+00277         }
+00278         else
+00279         {               
+00280                 switch(_CurrLayer)
+00281                 {
+00282                 
+00283                         case 2:
+00284                                 _Layer2.next();
+00285                                 if (_Layer2.get() == NULL)
+00286                                 {
+00287                                         if (_Layer1.size() != 0)
+00288                                         {
+00289                                                 _CurrLayer = 1;
+00290                                                 _IndexInLayer1 = 0;
+00291                                         }
+00292                                         else
+00293                                         {
+00294                                                 _CurrLayer = 0;
+00295                                                 _Layer0.begin();
+00296                                         }
+00297                                 }
+00298 
+00299                         break;
+00300                         case 1:
+00301                                 ++ _IndexInLayer1;
+00302                                 if (_IndexInLayer1 == _Layer1.size())
+00303                                 {
+00304                                         _CurrLayer = 0;
+00305                                         _Layer0.begin();
+00306                                 }
+00307                         break;
+00308                         case 0:
+00309                                 _Layer0.next();
+00310                         break;
+00311                 }
+00312         }
+00313 }
+00314 
+00315 
+00316 
+00317 
+00318 
+00319 } // NL3D
+00320 
+00321 
+00322 #endif // NL_LAYERED_ORDERING_TABLE_H
+00323 
+00324 /* End of layered_ordering_table.h */
+