nevrax.org : docs

00001 
+00007 /* Copyright, 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 
+00027 #ifndef NL_PS_ITERATOR_H
+00028 #define NL_PS_ITERATOR_H
+00029 
+00030 #include "nel/3d/animation_time.h"
+00031 
+00032 namespace NL3D 
+00033 {
+00034 
+00035         #ifdef NL_OS_WINDOWS
+00036                 #define GET_INLINE __forceinline
+00037         #else
+00038                 #define GET_INLINE
+00039         #endif
+00040 
+00041         
+00042 
+00051         template <typename T, typename PT>
+00052         struct CAdvance1Iterator
+00053         {               
+00054                 T It;
+00055 
+00056                 CAdvance1Iterator() {}
+00058                 CAdvance1Iterator(T it, uint32 index = 0)
+00059                 {                       
+00060                         It = it + index;
+00061                 }                                               
+00062                 const PT &get() const { return *It; }
+00063                 void advance() { ++It; }
+00064                 void advance(uint numSteps) 
+00065                 { 
+00066                         It = It + numSteps; 
+00067                 }
+00068                 CAdvance1Iterator &operator++() { advance(); return *this; }
+00069                 CAdvance1Iterator operator++(int) { CAdvance1Iterator tmp = this; advance(); return tmp; }              
+00070                 const PT &operator * () const { return get(); }         
+00073 
+00074                 bool operator==(const CAdvance1Iterator &other) const { return other.It == It; }
+00075                 bool operator!=(const CAdvance1Iterator &other) const { return !(*this == other); }
+00076                 CAdvance1Iterator operator+(sint quantity) { return CAdvance1Iterator(It + quantity); }
+00077                 CAdvance1Iterator &operator+=(sint quantity) { It = It + quantity; return *this; }
+00078         };      
+00079 
+00080         
+00081 
+00089         template<typename T, typename PT>
+00090         struct CAdvance1616Iterator
+00091         {               
+00092                 T It;
+00093                 uint32 CurrPos;
+00094                 uint32 Step;
+00095                 CAdvance1616Iterator() {}
+00097                 CAdvance1616Iterator(T it, uint32 index, uint32 step)
+00098                 {
+00099                         It = it;
+00100                         CurrPos = index * step;
+00101                         Step = step;
+00102                 }
+00103                         
+00104                 const PT &get() const { return *(It + (CurrPos >> 16)); }
+00105                 void advance() { CurrPos += Step; }
+00106                 void advance(uint numSteps) 
+00107                 { 
+00108                         CurrPos = CurrPos + numSteps * Step; 
+00109                 }       
+00110                 const PT &operator * () const { return get(); }
+00112                 CAdvance1616Iterator &operator++() { advance(); return *this; }
+00113                 CAdvance1616Iterator operator++(int) { CAdvance1616Iterator tmp = this; advance(); return tmp; }                
+00114                 bool operator==(const CAdvance1616Iterator &other) const 
+00115                 { 
+00116                         #ifdef _DEBUG
+00117                                 nlassert(other.It == It);
+00118                                 nlassert(other.Step == Step);
+00119                         #endif                  
+00120                         return other.CurrPos == CurrPos; 
+00121                 }
+00122                 bool operator!=(const CAdvance1616Iterator &other) const { return !(*this == other); }
+00123                 CAdvance1616Iterator operator+(sint quantity) 
+00124                 { 
+00125                         CAdvance1616Iterator res; 
+00126                         res.It = It;
+00127                         res.CurrPos = CurrPos + Step * quantity;
+00128                         res.Step = Step;
+00129                         return res;
+00130                 }
+00131                 CAdvance1616Iterator &operator+=(sint quantity)
+00132                 {
+00133                         CurrPos += quantity * Step;
+00134                         return *this;
+00135                 }
+00136         };
+00137 
+00138 
+00139         
+00142 
+00144         typedef CAdvance1Iterator<TPSAttribFloat::const_iterator, float> TIteratorFloatStep1;
+00145         typedef CAdvance1Iterator<TPSAttribFloat::const_iterator, TAnimationTime> TIteratorFloatStep1;
+00146         typedef CAdvance1Iterator<TPSAttribVector::const_iterator, NLMISC::CVector> TIteratorVectStep1;
+00147         typedef CAdvance1616Iterator<TPSAttribFloat::const_iterator, float> TIteratorFloatStep1616;
+00148         typedef CAdvance1616Iterator<TPSAttribFloat::const_iterator, TAnimationTime> TIteratorTimeStep1616;
+00149         typedef CAdvance1616Iterator<TPSAttribVector::const_iterator, NLMISC::CVector> TIteratorVectStep1616;
+00150                 
+00151 } // NL3D
+00152 
+00153 
+00154 #endif
+
ps_iterator.h
