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 #include "std3d.h"
+00027 
+00028 
+00029 #include "3d/ps_plane_basis_maker.h"
+00030 #include "3d/ps_register_plane_basis_attribs.h"
+00031 
+00032 namespace NL3D 
+00033 {
+00034 
+00035 
+00036 CPlaneBasis CPSPlaneBasisGradient::DefaultPlaneBasisTab[] = { CPlaneBasis(NLMISC::CVector::I), CPlaneBasis(NLMISC::CVector::J) };
+00037 
+00039 // CPSPlaneBasisFollowSpeed implementation //
+00041 
+00043 CPlaneBasis CPSPlaneBasisFollowSpeed::get(CPSLocated *loc, uint32 index)
+00044 {
+00045    return (CPlaneBasis(loc->getSpeed()[index]));
+00046 }
+00047 
+00049 void *CPSPlaneBasisFollowSpeed::make(CPSLocated *loc,
+00050                                                                          uint32 startIndex,
+00051                                                                          void *tab, uint32 stride,
+00052                                                                          uint32 numAttrib,
+00053                                                                          bool enableNoCopy /* = false*/,
+00054                                                                          uint32 srcStep /*= (1 << 16)*/
+00055                                                                         ) const
+00056 {
+00057         nlassert(numAttrib);
+00058         if (srcStep == (1 << 16))
+00059         {               
+00060                 TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin() + startIndex
+00061                                                                                 , endSpeedIt = loc->getSpeed().begin() + startIndex + numAttrib;
+00062                 uint8 *ptDat  = (uint8 *) tab; 
+00063                 do
+00064                 {
+00065                         *(CPlaneBasis *) ptDat = CPlaneBasis(*speedIt);
+00066                         ++ speedIt;
+00067                         ptDat += stride;
+00068                 }
+00069                 while (speedIt != endSpeedIt);
+00070                 return tab;
+00071         }
+00072         else
+00073         {
+00074                 uint32 fpIndex = startIndex * srcStep;
+00075                 const TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin();                                                                                
+00076                 uint8 *ptDat  = (uint8 *) tab; 
+00077                 while (numAttrib --)
+00078                 {
+00079                         *(CPlaneBasis *) ptDat = CPlaneBasis(*(speedIt + (fpIndex >> 16)));                     
+00080                         ptDat += stride;
+00081                         fpIndex += srcStep;
+00082                 }               
+00083                 return tab;     
+00084         }
+00085 }
+00086 
+00088 void CPSPlaneBasisFollowSpeed::make4(CPSLocated *loc,
+00089                                                                          uint32 startIndex,
+00090                                                                          void *tab,
+00091                                                                          uint32 stride,
+00092                                                                          uint32 numAttrib,
+00093                                                                          uint32 srcStep /*= (1 << 16)*/
+00094                                                                         ) const
+00095 {
+00096         nlassert(numAttrib);
+00097         if (srcStep == (1 << 16))
+00098         {               
+00099                 TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin() + startIndex
+00100                                                                                 , endSpeedIt = loc->getSpeed().begin() + startIndex + numAttrib;        
+00101                 uint8 *ptDat  = (uint8 *) tab;
+00102                 do
+00103                 {
+00104                         *(CPlaneBasis *) ptDat = CPlaneBasis(*speedIt);
+00105                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00106                         ptDat += stride;
+00107                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00108                         ptDat += stride;
+00109                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00110                         ptDat += stride << 1;
+00111                         ++ speedIt;             
+00112                 }
+00113                 while (speedIt != endSpeedIt);
+00114         }
+00115         else
+00116         {               
+00117                 uint32 fpIndex = startIndex * srcStep;
+00118                 const TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin();        
+00119                 uint8 *ptDat  = (uint8 *) tab;
+00120                 while (numAttrib --)
+00121                 {
+00122                         *(CPlaneBasis *) ptDat = CPlaneBasis(*(speedIt + (fpIndex >> 16)));
+00123                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00124                         ptDat += stride;
+00125                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00126                         ptDat += stride;
+00127                         *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00128                         ptDat += stride << 1;
+00129                         fpIndex += srcStep;
+00130                 }               
+00131         }
+00132 }               
+00133 
+00135 void CPSPlaneBasisFollowSpeed::makeN(CPSLocated *loc,
+00136                                                                          uint32 startIndex,
+00137                                                                          void *tab,
+00138                                                                          uint32 stride,
+00139                                                                          uint32 numAttrib,
+00140                                                                          uint32 nbReplicate,
+00141                                                                          uint32 srcStep /*= (1 << 16) */
+00142                                                                         ) const
+00143 {
+00144         nlassert(numAttrib);
+00145         if (srcStep == (1 << 16))
+00146         {
+00147                 nlassert(nbReplicate > 1); 
+00148                 TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin() + startIndex
+00149                                                                                 , endSpeedIt = loc->getSpeed().begin() + startIndex + numAttrib;        
+00150                 uint8 *ptDat  = (uint8 *) tab;
+00151                 uint k; 
+00152                 do
+00153                 {
+00154                         *(CPlaneBasis *) ptDat = CPlaneBasis(*speedIt);
+00155                         
+00156                         k = nbReplicate - 1;            
+00157 
+00158                         do
+00159                         {
+00160                                 *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00161                                 ptDat += stride;
+00162                         }
+00163                         while (--k);
+00164                         ptDat += stride;
+00165                 
+00166                         ++ speedIt;             
+00167                 }
+00168                 while (speedIt != endSpeedIt);
+00169         }
+00170         else
+00171         {
+00172                 uint32 fpIndex = startIndex * srcStep;
+00173                 nlassert(nbReplicate > 1); 
+00174                 const TPSAttribVector::const_iterator speedIt = loc->getSpeed().begin();
+00175                 uint8 *ptDat  = (uint8 *) tab;
+00176                 uint k; 
+00177                 while (numAttrib --)
+00178                 {
+00179                         *(CPlaneBasis *) ptDat = CPlaneBasis(*(speedIt + (fpIndex >> 16)));
+00180                         
+00181                         k = nbReplicate - 1;            
+00182 
+00183                         do
+00184                         {
+00185                                 *(CPlaneBasis *) (ptDat + stride) = *(CPlaneBasis *) ptDat;
+00186                                 ptDat += stride;
+00187                         }
+00188                         while (--k);
+00189                         ptDat += stride;
+00190         
+00191                         fpIndex += srcStep;
+00192                 }               
+00193         }
+00194 }
+00195 
+00196 
+00198 // CSpinnerFunctor implementation                  //
+00200 
+00201 
+00203 CSpinnerFunctor::CSpinnerFunctor() : _NbSamples(16), _Axis(NLMISC::CVector::K)
+00204 {
+00205         updateSamples();
+00206 }
+00207 
+00209 void CSpinnerFunctor::setAxis(const NLMISC::CVector &axis)
+00210 {
+00211         _Axis = axis;
+00212         updateSamples();
+00213 }
+00214 
+00216 const void CSpinnerFunctor::setNumSamples(uint32 nbSamples)
+00217 {
+00218         nlassert(nbSamples > 0);
+00219         _NbSamples = nbSamples;
+00220         updateSamples();
+00221 }
+00222 
+00224 const uint32 CSpinnerFunctor::getNumSamples(void) const
+00225 {
+00226         return _NbSamples;
+00227 }
+00228 
+00230 void CSpinnerFunctor::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00231 {
+00232         f.serialVersion(1);
+00233         f.serial(_Axis, _NbSamples);
+00234         if (f.isReading()) updateSamples();
+00235 }
+00236 
+00238 void CSpinnerFunctor::updateSamples(void)
+00239 {
+00240         // compute step between each angle
+00241         const float angInc = (float) (2.f * NLMISC::Pi / _NbSamples);
+00242         _PBTab.resize(_NbSamples + 1);
+00243         NLMISC::CMatrix mat;
+00244         // compute each sample
+00245         for (uint32 k = 0; k < _NbSamples; ++k)
+00246         {               
+00247                 mat.setRot(NLMISC::CQuat(_Axis, k * angInc));
+00248                 _PBTab[k] = CPlaneBasis(mat.getI(), mat.getJ());
+00249         }
+00250 }
+00251 
+00253 void PSRegisterPlaneBasisAttribs()
+00254 {
+00255         NLMISC_REGISTER_CLASS(CPSPlaneBasisBlender);
+00256         NLMISC_REGISTER_CLASS(CPSPlaneBasisGradient);
+00257         NLMISC_REGISTER_CLASS(CPSPlaneBasisMemory);
+00258         NLMISC_REGISTER_CLASS(CPSPlaneBasisBinOp);
+00259         NLMISC_REGISTER_CLASS(CPSPlaneBasisFollowSpeed);
+00260         NLMISC_REGISTER_CLASS(CPSBasisSpinner);
+00261 }
+00262 
+00263 } // NL3D
+00264 
+00265 
+
ps_plane_basis_maker.cpp
