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_PLANE_BASIS_MAKER_H
+00027 #define NL_PLANE_BASIS_MAKER_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 "3d/ps_plane_basis.h"
+00033 #include "3d/fast_floor.h"
+00034 
+00035 
+00036 namespace NL3D {
+00037 
+00038 const char *CPSAttribMaker<CPlaneBasis>::getType() { return "CPlaneBasis";}
+00039 
+00045 class CPSPlaneBasisBlender : public CPSValueBlender<CPlaneBasis>
+00046 {
+00047 public:
+00048         NLMISC_DECLARE_CLASS(CPSPlaneBasisBlender);
+00049 
+00050         CPSPlaneBasisBlender(const CPlaneBasis &startBasis = CPlaneBasis(NLMISC::CVector::I), const CPlaneBasis &endBasis = CPlaneBasis(NLMISC::CVector::J), float nbCycles = 1.0f) : CPSValueBlender<CPlaneBasis>(nbCycles)
+00051         {
+00052                 _F.setValues(startBasis, endBasis);
+00053         }
+00054         CPSAttribMakerBase *clone() const { return new CPSPlaneBasisBlender(*this); }
+00055 };
+00056 
+00057 
+00059 class CPSPlaneBasisGradient : public CPSValueGradient<CPlaneBasis>
+00060 {
+00061 public:
+00062         NLMISC_DECLARE_CLASS(CPSPlaneBasisGradient);
+00063 
+00070         CPSPlaneBasisGradient(const CPlaneBasis *basisTab = CPSPlaneBasisGradient::DefaultPlaneBasisTab
+00071                 , uint32 nbValues = 2, uint32 nbStages = 16, float nbCycles = 1.0f) : CPSValueGradient<CPlaneBasis>(nbCycles)
+00072         {
+00073                 _F.setValues(basisTab, nbValues, nbStages);
+00074         }
+00075         CPSAttribMakerBase *clone() const { return new CPSPlaneBasisGradient(*this); }
+00076         static CPlaneBasis DefaultPlaneBasisTab[];      
+00077 };
+00078 
+00079 
+00080 
+00085 class CPSPlaneBasisFollowSpeed : public CPSAttribMaker<CPlaneBasis>
+00086 {
+00087         public:
+00088 
+00089                 CPSPlaneBasisFollowSpeed() : CPSAttribMaker<CPlaneBasis>(1) {}
+00090 
+00092                 virtual CPlaneBasis get(CPSLocated *loc, uint32 index);
+00093 
+00099                 virtual void *make(CPSLocated *loc,
+00100                                                    uint32 startIndex,
+00101                                                    void *tab,
+00102                                                    uint32 stride,
+00103                                                    uint32 numAttrib,
+00104                                                    bool enableNoCopy = false,
+00105                                                    uint32 srcStep = (1 << 16)
+00106                                                   ) const;
+00107 
+00111                 virtual void make4(CPSLocated *loc,
+00112                                                    uint32 startIndex,
+00113                                                    void *tab,
+00114                                                    uint32 stride,
+00115                                                    uint32 numAttrib,
+00116                                                    uint32 srcStep = (1 << 16)
+00117                                                   ) const;
+00118 
+00119 
+00123                 virtual void makeN(CPSLocated *loc,
+00124                                                    uint32 startIndex,
+00125                                                    void *tab,
+00126                                                    uint32 stride,
+00127                                                    uint32 numAttrib,
+00128                                                    uint32 nbReplicate,
+00129                                                    uint32 srcStep = (1 << 16)                                              
+00130                                                   ) const;
+00131 
+00132                 NLMISC_DECLARE_CLASS(CPSPlaneBasisFollowSpeed);
+00133 
+00135                 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00136                 {
+00137                         // nothing to save here
+00138                         f.serialVersion(1);
+00139                 }
+00140                 CPSAttribMakerBase *clone() const { return new CPSPlaneBasisFollowSpeed(*this); }
+00141 };
+00142 
+00143 
+00144 
+00145 
+00150 class CPSPlaneBasisMemory : public CPSAttribMakerMemory<CPlaneBasis>
+00151 {
+00152 public:
+00153         CPSPlaneBasisMemory() { setDefaultValue(CPlaneBasis(NLMISC::CVector::K)); }
+00154         NLMISC_DECLARE_CLASS(CPSPlaneBasisMemory);
+00155         CPSAttribMakerBase *clone() const { return new CPSPlaneBasisMemory(*this); }
+00156 };
+00157 
+00158 
+00162 class CPSPlaneBasisBinOp : public CPSAttribMakerBinOp<CPlaneBasis>
+00163 {
+00164 public:
+00165         NLMISC_DECLARE_CLASS(CPSPlaneBasisBinOp);
+00166         CPSAttribMakerBase *clone() const { return new CPSPlaneBasisBinOp(*this); }
+00167 };
+00168 
+00169 
+00170 // a functor object that produce basis by applying a rotation over a fixed axis
+00171 class CSpinnerFunctor
+00172 {
+00173 public:
+00174         CSpinnerFunctor();
+00175         const CPlaneBasis &operator()(float date) const { return _PBTab[OptFastFloor(date * _NbSamples)]; }
+00177         void                                    setAxis(const NLMISC::CVector &axis);
+00179         const NLMISC::CVector   getAxis(void) const { return _Axis;}
+00181         const void setNumSamples(uint32 nbSamples);
+00183         const uint32 getNumSamples(void) const;
+00185         void serial(NLMISC::IStream &f) throw(NLMISC::EStream); 
+00186 protected:
+00187         std::vector<CPlaneBasis>        _PBTab;
+00188         uint32                                          _NbSamples;
+00189         NLMISC::CVector                         _Axis;
+00191         void                                            updateSamples(void);
+00192 };
+00193 
+00194 
+00195 
+00197 class CPSBasisSpinner : public CPSAttribMakerT<CPlaneBasis, CSpinnerFunctor>
+00198 {
+00199 public:
+00200         CPSBasisSpinner() : CPSAttribMakerT<CPlaneBasis, CSpinnerFunctor>(1) {}
+00201         NLMISC_DECLARE_CLASS(CPSBasisSpinner);
+00202         CPSAttribMakerBase *clone() const { return new CPSBasisSpinner(*this); }
+00203 };
+00204 
+00205 
+00206 
+00207 } // NL3D
+00208 
+00209 
+00210 #endif // NL_PLANE_BASIS_MAKER_H
+00211 
+00212 /* End of plane_basis_maker.h */
+
ps_plane_basis_maker.h
