Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   ps_attrib_maker_template.h Go to the documentation of this file. /* Copyright, 2001 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #ifndef NL_PS_ATTRIB_MAKER_TEMPLATE_H #define NL_PS_ATTRIB_MAKER_TEMPLATE_H #include "nel/misc/types_nl.h" #include "3d/ps_attrib_maker_helper.h" #include "3d/ps_plane_basis.h" #include "3d/fast_floor.h" namespace NL3D { /* * In this file, we define several template that helps to create attributes maker such as gradient (of float, int, vector etc) * attributes maker are used in the particle system to generate values, such as size, color etc. see ps_attrib_maker.h * for more informations */ template <typename T> inline T PSValueBlend(const T &t1, const T &t2, float alpha) { return T(alpha * t2 + (1.f - alpha) * t1); } template <> inline NLMISC::CRGBA PSValueBlend(const NLMISC::CRGBA &t1, const NLMISC::CRGBA &t2, float alpha) { NLMISC::CRGBA result; result.blendFromui(t1, t2, OptFastFloor(255.0f * alpha)); return result; } template <> inline CPlaneBasis PSValueBlend(const CPlaneBasis &t1, const CPlaneBasis &t2, float alpha) { return CPlaneBasis(PSValueBlend(t1.getNormal(), t2.getNormal(), alpha)); } template <typename T> struct CPSValueBlendFuncBase { virtual void getValues(T &startValue, T &endValue) const = 0; virtual void setValues(T startValue, T endValue) = 0; }; template <typename T> class CPSValueBlendFunc : public CPSValueBlendFuncBase<T> { public: CPSValueBlendFunc() {} void serial(NLMISC::IStream &f) throw(NLMISC::EStream) { f.serialVersion(1); f.serial(_StartValue, _EndValue); } #ifdef NL_OS_WINDOWS __forceinline #endif T operator()(TAnimationTime time) const { return PSValueBlend(_StartValue, _EndValue, time); // a cast to T is necessary, because // the specialization couls be done with integer } virtual void getValues(T &startValue, T &endValue) const { startValue = (*this)(0); endValue = (*this)(1); } virtual void setValues(T startValue, T endValue) { _StartValue = startValue; _EndValue = endValue; } T getMaxValue(void) const { return std::max((*this)(0), (*this)(1)); } protected: T _StartValue, _EndValue; }; template <typename T> class CPSValueBlender : public CPSAttribMakerT<T, CPSValueBlendFunc<T> > { public: CPSValueBlender(float nbCycles) : CPSAttribMakerT<T, CPSValueBlendFunc<T> >(nbCycles) { } virtual T getMaxValue(void) const { return _F.getMaxValue(); } // serialization is done by CPSAttribMakerT }; template <typename T, const uint n> class CPSValueBlendSampleFunc : public CPSValueBlendFuncBase<T> { public: #ifdef NL_OS_WINDOWS __forceinline #endif T operator()(TAnimationTime time) const { return _Values[OptFastFloor(time * n)]; } virtual void getValues(T &startValue, T &endValue) const { startValue = _Values[0]; endValue = _Values[n]; } virtual void setValues(T startValue, T endValue) { float step = 1.f / n; float alpha = 0.0f; for (uint k = 0; k < n; ++k) { _Values[k] = PSValueBlend(startValue, endValue, alpha); alpha += step; } _Values[n] = endValue; } CPSValueBlendSampleFunc() {} void serial(NLMISC::IStream &f) throw(NLMISC::EStream) { f.serialVersion(1); if (f.isReading()) { T t1, t2; f.serial(t1, t2); setValues(t1, t2); } else { f.serial(_Values[0], _Values[n]); } } T getMaxValue(void) const { return std::max((*this)(0), (*this)(1)); } protected: T _Values[n + 1]; }; template <typename T, const uint n> class CPSValueBlenderSample : public CPSAttribMakerT<T, CPSValueBlendSampleFunc<T, n> > { public: CPSValueBlenderSample(float nbCycles) : CPSAttribMakerT<T, CPSValueBlendSampleFunc<T, n> >(nbCycles) { } virtual T getMaxValue(void) const { return _F.getMaxValue(); } }; template <typename T> class CPSValueGradientFunc { public: #ifdef NL_OS_WINDOWS __forceinline #endif T operator()(TAnimationTime time) const { return _Tab[OptFastFloor(time * _NbValues)]; } void getValues(T *tab) const { nlassert(tab); T *pt = tab; uint32 src = 0; for (uint32 k = 0; k <= (_NbValues / _NbStages); ++k, src = src + _NbStages) { *pt++ =_Tab[src]; } } T getValue(uint index) const { nlassert(index < getNumValues()); return _Tab[index * _NbStages]; } uint32 getNumValues(void) const { return (_NbValues / _NbStages) + 1; } inline void setValues(const T *ValueTab, uint32 numValues, uint32 nbStages); uint32 getNumStages(void) const { return _NbStages; } void setNumStages(uint32 numStages) { std::vector<T> v; v.resize(getNumValues()); getValues(&v[0]); setValues(&v[0], getNumValues(), numStages); } virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream); T getMaxValue(void) const { return _MaxValue; } CPSValueGradientFunc() : _NbStages(0), _NbValues(0) { } virtual ~CPSValueGradientFunc() {} protected: // a table of Values that interpolate the values given std::vector<T> _Tab; // number of interpolated value between each 'key' uint32 _NbStages; // total number of value in the tab uint32 _NbValues; // the max value T _MaxValue; }; template <typename T> class CPSValueGradient : public CPSAttribMakerT<T, CPSValueGradientFunc<T> > { public: CPSValueGradient(float nbCycles) : CPSAttribMakerT<T, CPSValueGradientFunc<T> >(nbCycles) { } virtual T getMaxValue(void) const { return _F.getMaxValue(); } }; // methods implementations // template <typename T> inline void CPSValueGradientFunc<T>::setValues(const T *valueTab, uint32 numValues, uint32 nbStages) { nlassert(numValues > 1); nlassert(nbStages > 0); _NbStages = nbStages; _MaxValue = valueTab[0]; _NbValues = (numValues - 1) * nbStages; _Tab.resize(_NbValues + 1); float step = 1.0f / float(nbStages); float alpha; std::vector<T>::iterator dest = _Tab.begin(); // copy the tab performing linear interpolation between values given in parameter for (uint32 k = 0; k < (numValues - 1); ++k) { if (!(valueTab[k] < _MaxValue)) { _MaxValue = valueTab[k]; } alpha = 0; for(uint32 l = 0; l < nbStages; ++l) { // use the right version of the template function PSValueBlend // to do the job *dest++ = PSValueBlend(valueTab[k], valueTab[k + 1], alpha); alpha += step; } } *dest++ = valueTab[numValues - 1]; } template <typename T> void CPSValueGradientFunc<T>::serial(NLMISC::IStream &f) throw(NLMISC::EStream) { f.serialVersion(1); f.serial(_NbStages); if (f.isReading()) { // reload the number of keys uint32 numVal; f.serial(numVal); _NbValues = (numVal - 1) * _NbStages; // create the table on the stack for small gradient if (numVal < 256) { T tab[256]; for (uint32 k = 0; k < numVal; ++k) { f.serial(tab[k]); } setValues(tab, numVal, _NbStages); } else { std::vector<T> tab(numVal); for (uint32 k = 0; k < numVal; ++k) { f.serial(tab[k]); } setValues(&tab[0], numVal, _NbStages); } } else { // saves the number of keys uint32 numKeyValues = getNumValues(); f.serial(numKeyValues); // save each key for (uint32 k = 0; k < numKeyValues; ++k) { f.serial(_Tab[k * _NbStages]); } } } } // NL3D #endif // NL_PS_ATTRIB_MAKER_TEMPLATE_H /* End of ps_attrib_maker_template.h */