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 #ifndef NL_PS_ATTRIB_MAKER_ITERATORS_H
00027 #define NL_PS_ATTRIB_MAKER_ITERATORS_H
00028 
00029 #include "3d/ps_attrib.h"
00030 #include "3d/ps_iterator.h"
00031 
00032 
00033 
00034 namespace NL3D 
00035 {
00036 
00042         template <typename TBaseIter>
00043         struct CPSBaseIterator
00044         {
00045                 TBaseIter       Iter;
00047                 CPSBaseIterator() {}
00048                 CPSBaseIterator(TBaseIter it) : Iter(it) {}                     
00049                 GET_INLINE float get() const { return Iter.get(); }
00050                 void  advance() { Iter.advance(); }     
00051         };
00052         
00057         template <class TBaseIter>
00058         struct CVectNormIterator : CPSBaseIterator<TBaseIter>
00059         {                               
00060                 GET_INLINE float get() const { return Iter.get().norm(); }
00061                 CVectNormIterator(const TBaseIter &it) : CPSBaseIterator<TBaseIter>(it) {}
00062         };
00063 
00068         struct CRandomIterator
00069         {
00070                 GET_INLINE float get() const { return float(rand() * (1 / double(RAND_MAX))); } // this may be optimized with a table...
00071                 void  advance() {}
00072                 void  advance(uint quantity) {}
00073         };                      
00074 
00076         struct CDecalIterator
00077         {
00078                 float Value;                    
00079                 GET_INLINE float get() const { return Value; }
00080                 void  advance() {}
00081                 void  advance(uint quantity) {}                         
00082         };
00083 
00085         template <class TBaseIter>
00086         struct CDistIterator : CPSBaseIterator<TBaseIter>
00087         {               
00088                 NLMISC::CVector V; 
00089                 float Offset;
00090                 CDistIterator(const TBaseIter &it) : CPSBaseIterator<TBaseIter>(it) {}
00091         };
00092 
00093 
00095         template <class TBaseIter>
00096         struct CFDot3AddIterator : CDistIterator<TBaseIter>
00097         {                                                                       
00098                 GET_INLINE 
00099                 float get() const 
00100                 { 
00101                         const float r = fabsf(Iter.get() * V + Offset);
00102                         return r > MaxInputValue ? MaxInputValue : r;
00103                 }
00104                 CFDot3AddIterator(const TBaseIter &it) : CDistIterator<TBaseIter>(it) {}
00105         };
00106 
00108         template <class TBaseIter>
00109         struct CFSquareDot3AddIterator : CDistIterator<TBaseIter>
00110         {                               
00111                 float get() const 
00112                 { 
00113                         float r = Iter.get() * V + Offset;
00114                         r *= r;
00115                         return r > MaxInputValue ? MaxInputValue : r;
00116                 }
00117                 CFSquareDot3AddIterator(const TBaseIter &it) : CDistIterator<TBaseIter>(it) {}
00118         };
00119 
00121         template <class TBaseIter>
00122         struct CFClampDot3AddIterator : CDistIterator<TBaseIter>
00123         {                               
00124                 GET_INLINE
00125                 float get() const 
00126                 { 
00127                         const float r = Iter.get() * V + Offset;
00128                         if (r < 0.f) return MaxInputValue;
00129                         return r > MaxInputValue ? MaxInputValue : r;
00130                 }
00131                 CFClampDot3AddIterator(const TBaseIter &it) : CDistIterator<TBaseIter>(it) {}
00132         };
00133 
00134 
00136         template <class TBaseIter>
00137         struct CFClampSquareDot3AddIterator : CDistIterator<TBaseIter>
00138         {       
00139                 GET_INLINE
00140                 float get() const 
00141                 { 
00142                         float r = Iter.get() * V + Offset;
00143                         if (r < 0) return MaxInputValue;
00144                         r *= r;
00145                         return r > MaxInputValue ? MaxInputValue : r;
00146                 }
00147                 CFClampSquareDot3AddIterator(const TBaseIter &it) : CDistIterator<TBaseIter>(it) {}                                             
00148         };
00149 
00150         
00151 } 
00152 
00153 
00154 #endif
ps_attrib_maker_iterators.h
