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 
00027 #ifndef NL_PS_ATTRIB_MAKER_BIN_OP_H
00028         #error Do not include this file! include ps_attrib_maker_bin_op_inline instead!
00029 #endif
00030 
00031 #ifndef NL_PS_ATTRIB_MAKER_BIN_OP_INLINE_H
00032 #define NL_PS_ATTRIB_MAKER_BIN_OP_INLINE_H
00033 
00034 
00035 
00036 namespace NL3D {
00037 
00038 
00044 template <class T>
00045 inline T PSBinOpModulate(T arg1, T arg2) { return arg1 * arg2; }
00046 template <class T>
00047 inline T PSBinOpAdd(T arg1, T arg2) { return arg1 + arg2; }
00048 template <class T>
00049 inline T PSBinOpSubtract(T arg1, T arg2) { return arg1 - arg2; }
00050 
00051 template <>
00052 inline CPlaneBasis PSBinOpModulate(CPlaneBasis p1, CPlaneBasis p2)
00053 {
00054         // we compute p1 * p2
00055         NLMISC::CVector z = p1.X ^ p1.Y;
00056         CPlaneBasis r;
00057         r.X.x = p2.X.x * p1.X.x + p2.X.y * p1.Y.x + p2.X.z * z.x;
00058         r.X.y = p2.X.x * p1.X.y + p2.X.y * p1.Y.y + p2.X.z * z.y;
00059         r.X.z = p2.X.x * p1.X.z + p2.X.y * p1.Y.z + p2.X.z * z.z;
00060 
00061         r.Y.x = p2.Y.x * p1.X.x + p2.Y.y * p1.Y.x + p2.Y.z * z.x;
00062         r.Y.y = p2.Y.x * p1.X.y + p2.Y.y * p1.Y.y + p2.Y.z * z.y;
00063         r.Y.z = p2.Y.x * p1.X.z + p2.Y.y * p1.Y.z + p2.Y.z * z.z;
00064 
00065         return r;
00066 
00067 }
00068 template <>
00069 inline CPlaneBasis PSBinOpAdd(CPlaneBasis p1, CPlaneBasis p2)
00070 {
00071         nlassert(0); // not allowed for now
00072         return CPlaneBasis(NLMISC::CVector::Null);
00073 }
00074 template <>
00075 inline CPlaneBasis PSBinOpSubtract(CPlaneBasis p1, CPlaneBasis p2)
00076 {
00077         nlassert(0); // not allowed for now
00078         return CPlaneBasis(NLMISC::CVector::Null);
00079 }
00080 
00081 
00082 
00083  
00084 template <>
00085 inline NLMISC::CRGBA PSBinOpModulate(NLMISC::CRGBA t1, NLMISC::CRGBA t2)
00086 {
00087         NLMISC::CRGBA result;
00088         result.modulateFromColor(t1, t2);
00089         return result;
00090 }
00091 template <>
00092 inline NLMISC::CRGBA PSBinOpAdd(NLMISC::CRGBA t1, NLMISC::CRGBA t2)
00093 {
00094         NLMISC::CRGBA r;
00095         uint S = t1.R + t2.R; if (S > 255) S = 255; r.R = (uint8) S;
00096         S = t1.G + t2.G; if (S > 255) S = 255; r.G = (uint8) S;
00097         S = t1.B + t2.B; if (S > 255) S = 255; r.B = (uint8) S;
00098         return r;
00099 }
00100 template <>
00101 inline NLMISC::CRGBA PSBinOpSubtract(NLMISC::CRGBA t1, NLMISC::CRGBA t2)
00102 {
00103         NLMISC::CRGBA r;
00104         sint S = t1.R - t2.R; if (S < 0) S = 0; r.R = (uint8) S;
00105         S = t1.G - t2.G; if (S < 0) S = 0; r.G = (uint8) S;
00106         S = t1.B - t2.B; if (S < 0) S = 0; r.B = (uint8) S;
00107         return r;
00108 }
00109 
00110 
00112 // CPSAttribMakerBinOp implementation //
00114 
00115 
00116 
00117 //=================================================================================================================
00119 template <class T>
00120 CPSAttribMakerBinOp<T>::CPSAttribMakerBinOp(const CPSAttribMakerBinOp &other) : CPSAttribMaker<T>(other) // parent copy ctor
00121 {       
00122         std::auto_ptr<CPSAttribMaker<T> > a0(NLMISC::safe_cast<CPSAttribMaker<T> *>(other._Arg[0]->clone()))
00123                                                                         , a1(NLMISC::safe_cast<CPSAttribMaker<T> *>(other._Arg[1]->clone()));   
00124         this->_Op =             other._Op;
00125         this->_Size =   other._Size;
00126         this->_MaxSize =  other._MaxSize;
00127         this->_Arg[0] = a0.release();
00128         this->_Arg[1] = a1.release();   
00129 }
00130 
00131 //=================================================================================================================
00132 template <class T>
00133 CPSAttribMakerBinOp<T>::CPSAttribMakerBinOp() : _Op(CPSBinOp::selectArg1), _Size(0), _MaxSize(0)
00134 {
00135         _Arg[0] = _Arg[1] = NULL;
00136         _HasMemory  = true; 
00137 }
00138 
00139 //=================================================================================================================
00140 template <class T>
00141 void CPSAttribMakerBinOp<T>::clean(void) 
00142 {
00143         delete _Arg[0];
00144         delete _Arg[1];
00145 }
00146 
00147 //=================================================================================================================
00148 template <class T>
00149 CPSAttribMakerBinOp<T>::~CPSAttribMakerBinOp() 
00150 {
00151         clean();
00152 }
00153 
00154 //=================================================================================================================
00156 bool CPSAttribMakerBinOp<CPlaneBasis>::supportOp(CPSBinOp::BinOp op) 
00157 { 
00158         return  (op == CPSBinOp::selectArg1 || op == CPSBinOp::selectArg2 || op == CPSBinOp::modulate);
00159 }
00160 
00161 
00162 //=================================================================================================================
00163 template <class T>
00164 T               CPSAttribMakerBinOp<T>::get                       (CPSLocated *loc, uint32 index)
00165 {
00166         switch (_Op)
00167         {
00168                 case CPSBinOp::selectArg1:
00169                         return _Arg[0]->get(loc, index);
00170                 break;
00171                 case CPSBinOp::selectArg2:
00172                         return _Arg[1]->get(loc, index);
00173                 break;
00174                 case CPSBinOp::modulate:
00175                         return PSBinOpModulate(_Arg[0]->get(loc, index), _Arg[1]->get(loc, index));
00176                 break;
00177                 case CPSBinOp::add:
00178                         return PSBinOpAdd(_Arg[0]->get(loc, index), _Arg[1]->get(loc, index));
00179                 break;
00180                 case CPSBinOp::subtract:
00181                         return PSBinOpSubtract(_Arg[0]->get(loc, index), _Arg[1]->get(loc, index));
00182                 break;
00183                 default: break;
00184         }
00185 
00186         nlstop;
00187         return T();
00188 }
00189 
00190 // for private use
00191 void MakePrivate(uint8 * dest, const NLMISC::CRGBA *src1, const NLMISC::CRGBA *src2, uint32 stride, uint32 numAttrib, CPSBinOp::BinOp op);
00192 // for private use
00193 template <class T>
00194 void MakePrivate(uint8 * dest, const T *src1, const T *src2, uint32 stride, uint32 numAttrib, CPSBinOp::BinOp op)
00195 {
00196         uint8 *destEnd = dest + (stride * numAttrib);
00197 
00198         switch (op)
00199         {
00200                 case CPSBinOp::modulate:
00201                 {
00202                         while (dest != destEnd)
00203                         {
00204                                 * (T *) dest = PSBinOpModulate(*src1 ++, *src2 ++);
00205                                 dest += stride;
00206                         }
00207                 }
00208                 break;
00209                 case CPSBinOp::add:
00210                 {
00211                         while (dest != destEnd)
00212                         {
00213                                 * (T *) dest = PSBinOpAdd(*src1 ++, *src2 ++);
00214                                 dest += stride;
00215                         }
00216                 }
00217                 break;
00218                 case CPSBinOp::subtract:
00219                 while (dest != destEnd)
00220                 {
00221                         * (T *) dest = PSBinOpSubtract(*src1 ++, *src2 ++);
00222                         dest += stride;
00223                 }
00224                 break;
00225                 default: break;
00226         }
00227 }
00228 
00229 
00230 //=================================================================================================================
00231 template <class T>
00232 inline void   *CPSAttribMakerBinOp<T>::makePrivate(T *buf1,
00233                                                                                                    T *buf2,
00234                                                                                                    CPSLocated *loc,
00235                                                                                                    uint32 startIndex,
00236                                                                                                    void *tab,
00237                                                                                                    uint32 stride,
00238                                                                                                    uint32 numAttrib,
00239                                                                                                    bool allowNoCopy /* = false */,
00240                                                                                                    uint32 srcStep /* = (1 << 16)*/
00241                                                                                                   ) const
00242 {
00243         uint8 *dest = (uint8 *) tab;
00244         uint leftToDo = numAttrib, toProcess;
00245         nlassert(_Arg[0] && _Arg[1]);   
00246         switch (_Op)
00247         {
00248                 case CPSBinOp::selectArg1:
00249                         return _Arg[0]->make(loc, startIndex, tab, stride, numAttrib, allowNoCopy, srcStep);
00250                         break;
00251                 case CPSBinOp::selectArg2:
00252                         return _Arg[1]->make(loc, startIndex, tab, stride, numAttrib, allowNoCopy, srcStep);
00253                         break;          
00254                 default: break;
00255         }
00256 
00257 
00258 
00259         while (leftToDo)
00260         {
00261                 toProcess = leftToDo > PSBinOpBufSize ? PSBinOpBufSize : leftToDo;
00262                 T *src1 = (T *) _Arg[0]->make(loc, startIndex + (numAttrib - leftToDo), &buf1[0], sizeof(T), toProcess, true, srcStep);
00263                 T *src2 = (T *) _Arg[1]->make(loc, startIndex + (numAttrib - leftToDo), &buf2[0], sizeof(T), toProcess, true, srcStep);
00264                 MakePrivate(dest, src1, src2, stride, toProcess, _Op);          
00265                 leftToDo -= toProcess;
00266         }
00267 
00268         return tab;
00269 }
00270 
00271 //=================================================================================================================
00272 template <class T>
00273 void   *CPSAttribMakerBinOp<T>::make      (CPSLocated *loc,
00274                                                                                    uint32 startIndex,
00275                                                                                    void *tab,
00276                                                                                    uint32 stride,
00277                                                                                    uint32 numAttrib,
00278                                                                                    bool allowNoCopy /* = false */,
00279                                                                                    uint32 srcStep /* = (1 << 16)*/
00280                                                                                   ) const
00281 {
00286         uint8 tab1[PSBinOpBufSize * sizeof(T)];
00287         uint8 tab2[PSBinOpBufSize * sizeof(T)];
00288         return makePrivate((T *) &tab1[0], (T *) &tab2[0], loc, startIndex, tab, stride, numAttrib, allowNoCopy, srcStep);
00289 }
00290 
00291 
00292 // for private use
00293 void Make4Private(uint8 * dest, const NLMISC::CRGBA *src1, const NLMISC::CRGBA *src2, uint32 stride, uint32 numAttrib, CPSBinOp::BinOp op);
00294 
00295 // for private use
00296 template <class T>
00297 void Make4Private(uint8 * dest, const T *src1, const T *src2, uint32 stride, uint32 numAttrib, CPSBinOp::BinOp op)
00298 {
00299         const uint stride2 = stride << 1, stride3 = stride + stride2, stride4 = stride2 << 1; 
00300         uint8 *destEnd = dest + ((stride<<2) * numAttrib);
00301         switch (op)
00302         {
00303                 case CPSBinOp::modulate:
00304                 {
00305                         while (dest != destEnd)
00306                         {
00307                                 // compute one value, and duplicate if 4 times
00308                                 * (T *) dest = PSBinOpModulate(*src1 ++, *src2 ++);
00309                                 * (T *) (dest + stride) = * (T *) dest;
00310                                 * (T *) (dest + stride2) = * (T *) dest;
00311                                 * (T *) (dest + stride3) = * (T *) dest;
00312                                 dest += stride4;
00313                         }
00314                 }
00315                 break;
00316                 case CPSBinOp::add:
00317                 {
00318                         while (dest != destEnd)
00319                         {
00320                                 // compute one value, and duplicate if 4 times
00321                                 * (T *) dest = PSBinOpAdd(*src1 ++, *src2 ++);
00322                                 * (T *) (dest + stride) = * (T *) dest;
00323                                 * (T *) (dest + stride2) = * (T *) dest;
00324                                 * (T *) (dest + stride3) = * (T *) dest;
00325                                 dest += stride4;
00326                         }
00327                 }
00328                 break;
00329                 case CPSBinOp::subtract:
00330                         while (dest != destEnd)
00331                         {
00332                                 // compute one value, and duplicate if 4 times
00333                                 * (T *) dest = PSBinOpSubtract(*src1 ++, *src2 ++);
00334                                 * (T *) (dest + stride) = * (T *) dest;
00335                                 * (T *) (dest + stride2) = * (T *) dest;
00336                                 * (T *) (dest + stride3) = * (T *) dest;
00337                                 dest += stride4;
00338                         }
00339                 break;
00340                 default: break;
00341         }
00342 }
00343 
00344 //=================================================================================================================
00345 template <class T>
00346 inline void    CPSAttribMakerBinOp<T>::make4Private(T *buf1,
00347                                                                                                     T *buf2,
00348                                                                                                         CPSLocated *loc,
00349                                                                                                         uint32 startIndex,
00350                                                                                                         void *tab,
00351                                                                                                         uint32 stride,
00352                                                                                                         uint32 numAttrib,
00353                                                                                                         uint32 srcStep /* = (1 << 16)*/
00354                                                                                                    ) const
00355 {       
00356         uint8 *dest = (uint8 *) tab;
00357         uint leftToDo = numAttrib, toProcess;
00358         nlassert(_Arg[0] && _Arg[1]);   
00359         switch (_Op)
00360         {
00361                 case CPSBinOp::selectArg1:
00362                         _Arg[0]->make4(loc, startIndex, tab, stride, numAttrib, srcStep);
00363                         return;
00364                         break;
00365                 case CPSBinOp::selectArg2:
00366                         _Arg[1]->make4(loc, startIndex, tab, stride, numAttrib, srcStep);
00367                         return;
00368                         break;          
00369                 default: break;
00370         }
00371 
00372         while (leftToDo)
00373         {
00374                 toProcess = leftToDo > PSBinOpBufSize ? PSBinOpBufSize : leftToDo;
00375                 T *src1 = (T *) _Arg[0]->make(loc, startIndex + (numAttrib - leftToDo), &buf1[0], sizeof(T), toProcess, true, srcStep);
00376                 T *src2 = (T *) _Arg[1]->make(loc, startIndex + (numAttrib - leftToDo), &buf2[0], sizeof(T), toProcess, true, srcStep);
00377                 
00378                 Make4Private(dest, src1, src2, stride, toProcess, _Op);
00379                 leftToDo -= toProcess;
00380         }
00381 }
00382 
00383 
00384 //=================================================================================================================
00385 template <class T>
00386 void    CPSAttribMakerBinOp<T>::make4     (CPSLocated *loc,
00387                                                                                    uint32 startIndex,
00388                                                                                    void *tab,
00389                                                                                    uint32 stride,
00390                                                                                    uint32 numAttrib,
00391                                                                                    uint32  srcStep /*= (1 << 16) */                                                                                
00392                                                                                   ) const
00393 
00394 {
00399         uint8 tab1[PSBinOpBufSize * sizeof(T)];
00400         uint8 tab2[PSBinOpBufSize * sizeof(T)];
00401         make4Private((T *) &tab1[0], (T *) &tab2[0], loc, startIndex, tab, stride, numAttrib, srcStep);
00402 }
00403 
00404 
00405 // for private use
00406 void MakeNPrivate(uint8 * dest, const NLMISC::CRGBA *src1, const NLMISC::CRGBA *src2, uint32 stride, uint32 numAttrib, CPSBinOp::BinOp op, uint nbReplicate);
00407 
00408 // for private use
00409 template <class T>
00410 void MakeNPrivate(uint8 * dest,
00411                                   const T *src1,
00412                                   const T *src2,
00413                                   uint32 stride,
00414                                   uint32 numAttrib,
00415                                   CPSBinOp::BinOp op,
00416                                   uint nbReplicate,
00417                                   uint32 srcStep = (1 << 16)
00418                                  )
00419 {
00420         uint k;
00421         uint8 *destEnd = dest + ((stride * nbReplicate) * numAttrib);
00422         switch (op)
00423         {
00424                 case CPSBinOp::modulate:
00425                 {
00426                         while (dest != destEnd)
00427                         {
00428                                 * (T *) dest = PSBinOpModulate(*src1 ++, *src2 ++);                                     
00429                                 k = (nbReplicate - 1);
00430                                 do
00431                                 {
00432                                         * (T *) (dest + stride) = *(T *) dest;
00433                                         dest += stride;
00434                                 }
00435                                 while (--k);
00436                                 dest += stride;
00437                         }
00438                 }
00439                 break;
00440                 case CPSBinOp::add:
00441                 {
00442                         while (dest != destEnd)
00443                         {                                       
00444                                 * (T *) dest = PSBinOpAdd(*src1 ++, *src2 ++);                                  
00445                                 k = (nbReplicate - 1);
00446                                 do
00447                                 {
00448                                         * (T *) (dest + stride) = *(T *) dest;
00449                                         dest += stride;
00450                                 }
00451                                 while (--k);
00452                                 dest += stride;
00453                         }
00454                 }
00455                 break;
00456                 case CPSBinOp::subtract:
00457                         while (dest != destEnd)
00458                         {
00459                                 * (T *) dest = PSBinOpSubtract(*src1 ++, *src2 ++);                                     
00460                                 k = (nbReplicate - 1);
00461                                 do
00462                                 {
00463                                         * (T *) (dest + stride) = *(T *) dest;
00464                                         dest += stride;
00465                                 }
00466                                 while (--k);
00467                                 dest += stride;
00468                         }
00469                 break;
00470                 default: break;
00471         }
00472 }
00473 
00474 //=================================================================================================================
00475 template <class T>
00476 inline void     CPSAttribMakerBinOp<T>::makeNPrivate(T *buf1,
00477                                                                                                  T *buf2,
00478                                                                                                  CPSLocated *loc,
00479                                                                                                  uint32 startIndex,
00480                                                                                                  void *tab,
00481                                                                                                  uint32 stride,
00482                                                                                                  uint32 numAttrib,
00483                                                                                                  uint32 nbReplicate,
00484                                                                                                  uint32 srcStep /*= (1 << 16)*/                                                                                          
00485                                                                                                 ) const
00486 {               
00487         uint8 *dest = (uint8 *) tab;
00488         uint leftToDo = numAttrib, toProcess;
00489         nlassert(_Arg[0] && _Arg[1]);   
00490         switch (_Op)
00491         {
00492                 case CPSBinOp::selectArg1:
00493                         _Arg[0]->makeN(loc, startIndex, tab, stride, numAttrib, nbReplicate, srcStep);
00494                         return;
00495                         break;
00496                 case CPSBinOp::selectArg2:
00497                         _Arg[1]->makeN(loc, startIndex, tab, stride, numAttrib, nbReplicate, srcStep);
00498                         return;
00499                         break;          
00500                 default: break;
00501         }
00502         
00503         while (leftToDo)
00504         {
00505                 toProcess = leftToDo > PSBinOpBufSize ? PSBinOpBufSize : leftToDo;
00506                 T *src1 = (T *) _Arg[0]->make(loc, startIndex + (numAttrib - leftToDo), &buf1[0], sizeof(T), toProcess, true, srcStep);
00507                 T *src2 = (T *) _Arg[1]->make(loc, startIndex + (numAttrib - leftToDo), &buf2[0], sizeof(T), toProcess, true, srcStep);
00508                 
00509                 MakeNPrivate(dest, src1, src2, stride, toProcess, _Op, nbReplicate);
00510                 leftToDo -= toProcess;
00511         }
00512 }
00513 
00514 //=================================================================================================================
00515 template <class T>
00516 void    CPSAttribMakerBinOp<T>::makeN(CPSLocated *loc,
00517                                                                           uint32 startIndex,
00518                                                                           void *tab,
00519                                                                           uint32 stride,
00520                                                                           uint32 numAttrib,
00521                                                                           uint32 nbReplicate,
00522                                                                           uint32 /* srcStep = (1 << 16)*/
00523                                                                          ) const
00524 
00525 {
00530         uint8 tab1[PSBinOpBufSize * sizeof(T)];
00531         uint8 tab2[PSBinOpBufSize * sizeof(T)];
00532         makeNPrivate((T *) &tab1[0], (T *) &tab2[0], loc, startIndex, tab, stride, numAttrib, nbReplicate);
00533 }
00534 
00535 //=================================================================================================================
00536 template <class T>
00537 void    CPSAttribMakerBinOp<T>::serial            (NLMISC::IStream &f) throw(NLMISC::EStream)
00538 {
00539         if (f.isReading())
00540         {
00541                 clean();
00542         }
00543         f.serialVersion(1);
00544         f.serialEnum(_Op);
00545         f.serialPolyPtr(_Arg[0]);
00546         f.serialPolyPtr(_Arg[1]);
00547         f.serial(_Size, _MaxSize);
00548         
00549 }
00550 
00551 //=================================================================================================================
00552 template <class T>
00553 void    CPSAttribMakerBinOp<T>::deleteElement (uint32 index)
00554 {
00555         if (_Arg[0]->hasMemory())       _Arg[0]->deleteElement(index);
00556         if (_Arg[1]->hasMemory())       _Arg[1]->deleteElement(index);
00557         nlassert(_Size != 0);
00558         --_Size;
00559 }
00560 
00561 //=================================================================================================================
00562 template <class T>
00563 void    CPSAttribMakerBinOp<T>::newElement        (CPSLocated *emitterLocated, uint32 emitterIndex)
00564 {
00565         if (_Arg[0]->hasMemory())       _Arg[0]->newElement(emitterLocated, emitterIndex);
00566         if (_Arg[1]->hasMemory())       _Arg[1]->newElement(emitterLocated, emitterIndex);
00567         if (_Size != _MaxSize)
00568         {
00569                 ++_Size;
00570         }
00571 }
00572 
00573 //=================================================================================================================
00574 template <class T>
00575 void    CPSAttribMakerBinOp<T>::resize            (uint32 capacity, uint32 nbPresentElements)
00576 {
00577         nlassert(capacity < (1 << 16));
00578         _MaxSize = capacity;
00579         _Size = nbPresentElements;
00580         if (_Arg[0]->hasMemory())       _Arg[0]->resize(capacity, nbPresentElements);
00581         if (_Arg[1]->hasMemory())       _Arg[1]->resize(capacity, nbPresentElements);
00582 }
00583 
00584 
00585 } // NL3D
00586 
00587 
00588 #endif // NL_PS_ATTRIB_MAKER_BIN_OP_INLINE_H
00589 
00590 /* End of ps_attrib_maker_bin_op.h */
ps_attrib_maker_bin_op_inline.h
