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_FLOAT_H
+00027 #define NL_PS_FLOAT_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "3d/ps_attrib_maker_template.h"
+00031 #include "3d/ps_attrib_maker_bin_op.h"
+00032 #include "nel/3d/animation_time.h"
+00033 #include <algorithm>
+00034 #include <nel/misc/vector_h.h>
+00035 
+00036 namespace NL3D {
+00037 
+00038 
+00039 const char *CPSAttribMaker<float>::getType() { return "float"; }
+00040 
+00043 
+00044 class CPSFloatBlender : public CPSValueBlender<float>
+00045 {
+00046 public:
+00047         NLMISC_DECLARE_CLASS(CPSFloatBlender);
+00048         CPSFloatBlender(float startFloat = 0.1f , float endFloat = 1.f, float nbCycles = 1.0f) : CPSValueBlender<float>(nbCycles)
+00049         {
+00050                 _F.setValues(startFloat, endFloat);
+00051         }
+00052         CPSAttribMakerBase *clone() const { return new CPSFloatBlender(*this); }
+00053         // F is serialized by base classes...
+00054 
+00055 };
+00056 
+00057 
+00059 class CPSFloatGradient : public CPSValueGradient<float>
+00060 {
+00061 public:
+00062         NLMISC_DECLARE_CLASS(CPSFloatGradient);
+00063 
+00070         CPSFloatGradient(const float *floatTab = CPSFloatGradient::_DefaultGradient
+00071                                                 , uint32 nbValues = 2, uint32 nbStages = 16, float nbCycles = 1.0f);
+00072 
+00073         
+00074         static float _DefaultGradient[];
+00075         CPSAttribMakerBase *clone() const { return new CPSFloatGradient(*this); }
+00076         // F is serialized by base classes...   
+00077 };
+00078 
+00083 class CPSFloatMemory : public CPSAttribMakerMemory<float>
+00084 {
+00085 public:
+00086         CPSFloatMemory() { setDefaultValue(0.f); }
+00087         NLMISC_DECLARE_CLASS(CPSFloatMemory);
+00088         CPSAttribMakerBase *clone() const { return new CPSFloatMemory(*this); }
+00089 
+00090 };
+00091 
+00095 class CPSFloatBinOp : public CPSAttribMakerBinOp<float>
+00096 {
+00097 public:
+00098         NLMISC_DECLARE_CLASS(CPSFloatBinOp);
+00099         CPSAttribMakerBase *clone() const { return new CPSFloatBinOp(*this); }
+00100 };
+00101 
+00103 class CPSFloatCurveFunctor
+00104 {
+00105         public:
+00106                 struct CCtrlPoint
+00107                 {
+00108                         CCtrlPoint() {}
+00109                         CCtrlPoint(float date, float value) : Date(date), Value(value) { nlassert(Date >= 0 && Date <= 1); }
+00110                         float Date;
+00111                         float Value;
+00112                         void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00113                         {
+00114                                 f.serial(Date, Value);
+00115                         }
+00116                 };
+00117                 
+00119                 CPSFloatCurveFunctor();
+00120 
+00124                 void                                                    addControlPoint(const CCtrlPoint &ctrlPoint);
+00125 
+00127                 uint                                                    getNumCtrlPoints(void) const { return _CtrlPoints.size(); }                     
+00128 
+00132                 const CCtrlPoint                                &getControlPoint(uint index) const;
+00133 
+00135                 void                                                    setCtrlPoint(uint index, const CCtrlPoint &ctrlPoint);
+00136 
+00138                 void                                                    removeCtrlPoint(uint index);
+00139 
+00141                 void                                                    setNumSamples(uint32 numSamples);
+00142 
+00144                 uint32                                                  getNumSamples(void) const { return _NumSamples; }
+00145 
+00147                 void                                                    enableSmoothing(bool enable = true);
+00148 
+00150                 bool                                                    hasSmoothing(void) const                        { return _Smoothing;}
+00151 
+00157                 #ifdef NL_OS_WINDOWS
+00158                         __forceinline
+00159                 #endif
+00160                 float operator()(TAnimationTime time) const
+00161                 {
+00162                         return _Tab[OptFastFloor(time * _NumSamples)];
+00163                 }
+00164 
+00166                 float                                                   getValue(float date) const;
+00167 
+00169                 void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00170 
+00171         protected:              
+00173                 float getSlope(uint index) const ;
+00175                 void                                            sortPoints(void);       
+00177                 void                                            updateTab(void);        
+00178                 std::vector<CCtrlPoint>         _CtrlPoints;
+00179                 uint32                                          _NumSamples;
+00180                 std::vector<float>                      _Tab; // sampled version of the curve           
+00181                 bool                                            _Smoothing;
+00182 };
+00183 
+00184 
+00185 inline bool operator<(const CPSFloatCurveFunctor::CCtrlPoint &lhs, const CPSFloatCurveFunctor::CCtrlPoint &rhs)
+00186 {
+00187         return lhs.Date < rhs.Date;
+00188 }
+00189 
+00190 
+00191 class CPSFloatCurve : public CPSAttribMakerT<float, CPSFloatCurveFunctor>
+00192 {
+00193 public:
+00194         CPSFloatCurve() : CPSAttribMakerT<float, CPSFloatCurveFunctor>(1) {}
+00195         NLMISC_DECLARE_CLASS(CPSFloatCurve);
+00196         CPSAttribMakerBase *clone() const { return new CPSFloatCurve(*this); }
+00197 };
+00198 
+00199 
+00200 
+00201 } // NL3D
+00202 
+00203 
+00204 #endif // NL_PS_FLOAT_H
+00205 
+00206 /* End of ps_size.h */
+
ps_float.h
