ps_attrib_maker_helper.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_HELPER_H
#define NL_PS_ATTRIB_MAKER_HELPER_H

#include "nel/3d/ps_attrib_maker.h"

#include "nel/misc/fast_floor.h" // inline assembly for fast float<->int conversions
#include "nel/3d/ps_attrib_maker_iterators.h" // some iterators we use

namespace NL3D
{






template <typename T, class F> class CPSAttribMakerT : public CPSAttribMaker<T>
{
    public:
        F _F;

        virtual T get(CPSLocated *loc, uint32 index);
        virtual T get(const CPSEmitterInfo &info);

        virtual T get(float input)
        {
            NLMISC::OptFastFloorBegin();
            nlassert(input >= 0.f && input <= 1.f);
            T tmp=  _F(input);
            NLMISC::OptFastFloorEnd();
            return tmp;
        }

        /*  virtual void *make(CPSLocated *loc,
                             uint32 startIndex,
                             void *tab, uint32 stride,
                             uint32 numAttrib,
                             bool allowNoCopy = false,
                             uint32 srcStep = (1 << 16)
                                             ) const;*/

         /* virtual void make4(CPSLocated *loc,
                             uint32 startIndex,
                             void *tab,
                             uint32 stride,
                             uint32 numAttrib,
                             uint32 srcStep = (1 << 16)
                            ) const;*/

        /* virtual void makeN(CPSLocated *loc,
                            uint32 startIndex,
                            void *tab,
                            uint32 stride,
                            uint32 numAttrib,
                            uint32 nbReplicate,
                            uint32 srcStep = (1 << 16)
                        ) const;*/


        virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
        {
            sint ver = f.serialVersion(2);
            CPSAttribMaker<T>::serial(f);
            f.serial(_F);
            switch (ver)
            {
                case 1:
                {
                    CPSInputType it;
                    f.serialEnum(it.InputType);
                    _InputType = it;
                }
                break;
                case 2:
                    f.serial(_InputType);
                break;
            }
            f.serial(_Clamp);
        }

        CPSAttribMakerT(float nbCycles) :  CPSAttribMaker<T>(nbCycles), _Clamp(false)
        {}

          virtual ~CPSAttribMakerT() {}


        virtual bool hasCustomInput(void) { return true; }


        virtual void setInput(const CPSInputType &input) { _InputType = input; }


        virtual CPSInputType getInput(void) const { return _InputType; }


        bool isClampingSupported(void) const { return true; }


        virtual void setClamping(bool enable = true) { _Clamp = enable; };


        virtual bool getClamping(void) const  { return _Clamp; };


          typedef T value_type;

          typedef F functor_type;

    private:

        // type of the input
        CPSInputType _InputType;

        // clamping on/ off
        bool _Clamp;



         template <typename It> void makeByIterator(It it,
                                                     void *tab,
                                                     uint32 stride,
                                                     uint32 numAttrib,
                                                     bool canOverlapOne,
                                                     bool forceClampEntry
                                                     ) const
         {
            uint8 *pt = (uint8 *) tab;


            if (this->_NbCycles > 1 || canOverlapOne || forceClampEntry)
            {
                // the value could cycle, so we need to clamp it to 0.0f 1.0f

                if (!_Clamp && !forceClampEntry)
                {
                    if (this->_NbCycles == 1)
                    {
                        while (numAttrib --)
                        {
                            *(T *)pt = _F(NLMISC::OptFastFractionnalPart(it.get()));
                            pt += stride;
                            it.advance();
                        }
                    }
                    else
                    {
                        while (numAttrib --)
                        {
                            const float time =  this->_NbCycles * (it.get());
                            *(T *)pt = _F(NLMISC::OptFastFractionnalPart(time));
                            pt += stride;
                            it.advance();
                        }
                    }
                }
                else
                {
                    // clamping is on
                    float value;
                    if (this->_NbCycles == 1)
                    {
                        while (numAttrib --)
                        {
                            value = it.get();
                            if (value > MaxInputValue)
                            {
                                value = MaxInputValue;
                            }
                            *(T *)pt = _F(value);
                            pt += stride;
                            it.advance();
                        }
                    }
                    else
                    {
                        while (numAttrib --)
                        {
                            float value =  this->_NbCycles * (it.get());
                            if (value > MaxInputValue)
                            {
                                value = MaxInputValue;
                            }
                            *(T *)pt = _F(value);
                            pt += stride;
                            it.advance();
                        }
                    }
                }
            }
            else
            {
                // the fastest case : it match the particle's life perfectly

                if (this->_NbCycles == 1)
                {
                    while (numAttrib --)
                    {
                        *(T *)pt = _F(it.get());
                        pt += stride;
                        it.advance();
                    }
                }
                else
                {
                    // the particle won't cover the whole pattern during his life
                    while (numAttrib --)
                    {
                        *(T *)pt = _F(this->_NbCycles  * (it.get()));
                        pt += stride;
                        it.advance();
                    }
                }
            }
        }

         template <typename It> void make4ByIterator(It it,
                                                     void *tab,
                                                     uint32 stride,
                                                     uint32 numAttrib,
                                                     bool canOverlapOne) const
         {


            uint8 *pt = (uint8 *) tab;


            // first precompute the various strides (stride * 2, 3 and 4)
            // const uint32 stride2 = stride << 1, stride3 = stride + stride2, stride4 = stride2 << 1;

            const uint32 stride2 = stride << 1;

            if (this->_NbCycles > 1 || canOverlapOne)
            {

                if (!_Clamp)
                {
                    if (this->_NbCycles == 1)
                    {
                        while (numAttrib --)
                        {
                            // fill 4 attrib with the same value at once
                            //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(OptFastFractionnalPart(it.get()));
                            *(T *) pt = _F(NLMISC::OptFastFractionnalPart(it.get()));
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride2;
                            it.advance();
                        }
                    }
                    else
                    {
                        while (numAttrib --)
                        {
                            const float time =  this->_NbCycles * (it.get());
                            // fill 4 attrib with the same value at once
                            //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(OptFastFractionnalPart(time));
                            *(T *) pt = _F(NLMISC::OptFastFractionnalPart(time));
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride2;

                            it.advance();
                        }
                    }
                }
                else
                {
                    float value;

                    if (this->_NbCycles == 1)
                    {
                        while (numAttrib --)
                        {
                            value = it.get();
                            if (value > MaxInputValue)
                            {
                                value = MaxInputValue;
                            }
                            // fill 4 attrib with the same value at once
                            //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(value);
                            *(T *) pt = _F(value);
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride2;

                            it.advance();
                        }
                    }
                    else
                    {
                        while (numAttrib --)
                        {
                            value =   this->_NbCycles * (it.get());
                            if (value > MaxInputValue)
                            {
                                value = MaxInputValue;
                            }
                            // fill 4 attrib with the same value at once
                            //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(value);
                            *(T *) pt = _F(value);
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride;
                            *(T *) (pt + stride) = *(T *) pt;
                            pt += stride2;
                            //pt += stride4; // advance of 4
                            it.advance();
                        }
                    }
                }
            }
            else
            {
                // the fastest case : it match the particle's life perfectly

                if (this->_NbCycles == 1)
                {
                    while (numAttrib --)
                    {
                        // fill 4 attrib with the same value at once
                        //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(it.get());
                        *(T *) pt = _F(it.get());
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride;
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride;
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride2;

                        //pt += stride4; // advance of 4
                        it.advance();
                    }
                }
                else
                {
                    // the particle won't cover the whole pattern during his life

                    while (numAttrib --)
                    {
                        // fill 4 attrib with the same value at once
                        *(T *) pt = _F(this->_NbCycles * it.get());
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride;
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride;
                        *(T *) (pt + stride) = *(T *) pt;
                        pt += stride2;
                        //*(T *)pt = *(T *)(pt + stride) = *(T *)(pt + stride2)  = *(T *)(pt + stride3) = _F(_NbCycles * it.get());
                        //pt += stride4; // advance of 4
                        it.advance();
                    }
                }
            }
         }


         template <typename It> void makeNByIterator(It it, void *tab, uint32 stride, uint32 numAttrib
                                                  , uint32 nbReplicate, bool canOverlapOne) const
         {

                nlassert(nbReplicate > 1);

                uint8 *pt = (uint8 *) tab;

                // loop counter
                uint k;


                if (this->_NbCycles > 1 || canOverlapOne)
                {

                    if (!_Clamp)
                    {
                        if (this->_NbCycles == 1)
                        {
                            while (numAttrib --)
                            {
                                // fill 4 attrib with the same value at once
                                *(T *)pt = _F(NLMISC::OptFastFractionnalPart(it.get()));
                                k = nbReplicate - 1;
                                do
                                {
                                    *(T *) (pt + stride) = *(T *) pt;
                                    pt += stride;
                                }
                                while (--k);
                                pt += stride;
                                it.advance();
                            }
                        }
                        else
                        {
                            while (numAttrib --)
                            {
                                const float time =  this->_NbCycles * (it.get());
                                // fill 4 attrib with the same value at once
                                *(T *)pt = _F(NLMISC::OptFastFractionnalPart(time));
                                k = nbReplicate - 1;
                                do
                                {
                                    *(T *) (pt + stride) = *(T *) pt;
                                    pt += stride;
                                }
                                while (--k);
                                pt += stride;
                                it.advance();
                            }
                        }
                    }
                    else
                    {
                        float value;
                        // clamping is on
                        if (this->_NbCycles == 1)
                        {
                            while (numAttrib --)
                            {
                                // fill 4 attrib with the same value at once
                                value = it.get();
                                if (value > MaxInputValue)
                                {
                                    value = MaxInputValue;
                                }
                                *(T *)pt = _F(value);
                                k = nbReplicate - 1;
                                do
                                {
                                    *(T *) (pt + stride) = *(T *) pt;
                                    pt += stride;
                                }
                                while (--k);
                                pt += stride;
                                it.advance();
                            }
                        }
                        else
                        {
                            while (numAttrib --)
                            {
                                value =  this->_NbCycles * (it.get());
                                if (value > MaxInputValue)
                                {
                                    value = MaxInputValue;
                                }
                                // fill 4 attrib with the same value at once
                                *(T *)pt = _F(value);
                                k = nbReplicate - 1;
                                do
                                {
                                    *(T *) (pt + stride) = *(T *) pt;
                                    pt += stride;
                                }
                                while (--k);
                                pt += stride;
                                it.advance();
                            }
                        }
                    }
                }
                else
                {
                    // the fastest case : it match the particle's life perfectly

                    if (this->_NbCycles == 1)
                    {
                        while (numAttrib --)
                        {
                            // fill 4 attrib with the same value at once
                            *(T *)pt = _F(it.get());
                            k = nbReplicate - 1;
                            do
                            {
                                *(T *) (pt + stride) = *(T *) pt;
                                pt += stride;
                            }
                            while (--k);
                            pt += stride;
                            it.advance();
                        }
                    }
                    else
                    {
                        // the particle won't cover the whole pattern during his life

                        while (numAttrib --)
                        {
                            // fill 4 attrib with the same value at once
                            *(T *)pt =  _F(this->_NbCycles * it.get());
                            k = nbReplicate - 1;
                            do
                            {
                                *(T *) (pt + stride) = *(T *) pt;
                                pt += stride;
                            }
                            while (--k);
                            pt += stride;
                            it.advance();
                        }
                    }
                }
            }



            /* template <typename T, class F> */
            void /*CPSAttribMakerT<T, F>::*/ *make(CPSLocated *loc,
                                              uint32 startIndex,
                                              void *tab,
                                              uint32 stride,
                                              uint32 numAttrib,
                                              bool /* allowNoCopy */ /* = false */,
                                              uint32 srcStep /*= (1 << 16)*/,
                                              bool  forceClampEntry /*= false*/
                                             ) const
            {

                NLMISC::OptFastFloorBegin();
                nlassert(loc);

                if (srcStep == (1 << 16))
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it(TIteratorFloatStep1(loc->getTime().begin(), startIndex));
                            makeByIterator(it, tab, stride, numAttrib, loc->getLastForever(), forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it(TIteratorFloatStep1(loc->getInvMass().begin() , startIndex));
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getSpeed().begin(), startIndex));
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1(loc->getPos().begin(), startIndex) );
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();
                    // we must alway copy the data there ...
                    return tab;
                }
                else // fixed point steps
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it(TIteratorFloatStep1616(loc->getTime().begin(), startIndex, srcStep));
                            makeByIterator(it, tab, stride, numAttrib, loc->getLastForever(), forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it( TIteratorFloatStep1616(loc->getInvMass().begin(), startIndex, srcStep));
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getSpeed().begin(), startIndex, srcStep) );
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            makeByIterator(it, tab, stride, numAttrib, true, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeByIterator(it, tab, stride, numAttrib, false, forceClampEntry);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();
                    // we must alway copy the data there ...
                    return tab;
                }
            }



            /* template <typename T, class F> */
            void /*CPSAttribMakerT<T, F>::*/make4(CPSLocated *loc,
                                               uint32 startIndex,
                                               void *tab,
                                               uint32 stride,
                                               uint32 numAttrib,
                                               uint32 srcStep /*= (1 << 16)*/
                                              ) const
            {
                NLMISC::OptFastFloorBegin();
                nlassert(loc);

                if (srcStep == (1 << 16))
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it(TIteratorFloatStep1( loc->getTime().begin(), startIndex) );
                            make4ByIterator(it, tab, stride, numAttrib, loc->getLastForever());
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it( TIteratorFloatStep1(loc->getInvMass().begin(), startIndex) );
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1(loc->getSpeed().begin(), startIndex) );
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1(loc->getPos().begin() , startIndex) );
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();
                }
                else // fixed point steps
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it(TIteratorFloatStep1616(loc->getTime().begin(), startIndex, srcStep));
                            make4ByIterator(it, tab, stride, numAttrib, loc->getLastForever());
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it( TIteratorFloatStep1616(loc->getInvMass().begin() , startIndex, srcStep));
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getSpeed().begin(), startIndex, srcStep) );
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin() , startIndex, srcStep) );
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            make4ByIterator(it, tab, stride, numAttrib, true);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            make4ByIterator(it, tab, stride, numAttrib, false);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();

                }
            }


            /* template <typename T, class F> */
            virtual void /*CPSAttribMakerT<T, F>::*/makeN(CPSLocated *loc,
                                        uint32 startIndex,
                                        void *tab,
                                        uint32 stride,
                                        uint32 numAttrib,
                                        uint32 nbReplicate,
                                        uint32 srcStep /* = (1 << 16)*/
                                    ) const
            {
                NLMISC::OptFastFloorBegin();
                nlassert(loc);
                if (srcStep == (1 << 16))
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it(TIteratorFloatStep1(loc->getTime().begin(), startIndex) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, loc->getLastForever());
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1>
                                it( TIteratorFloatStep1(loc->getInvMass().begin() , startIndex) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1(loc->getSpeed().begin(), startIndex) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1( loc->getPos().begin() , startIndex ) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1>
                                it( TIteratorVectStep1(loc->getPos().begin(), startIndex) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1>
                                it(TIteratorVectStep1(loc->getPos().begin(), startIndex));
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();
                }
                else // fixed point steps
                {
                    switch (_InputType.InputType)
                    {
                        case CPSInputType::attrDate:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it(TIteratorFloatStep1616(loc->getTime().begin(), startIndex, srcStep));
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, loc->getLastForever());
                        }
                        break;
                        case CPSInputType::attrInverseMass:
                        {
                            CPSBaseIterator<TIteratorFloatStep1616>
                                it( TIteratorFloatStep1616(loc->getInvMass().begin() , startIndex, srcStep) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrSpeed:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getSpeed().begin(), startIndex, srcStep) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;

                        case CPSInputType::attrPosition:
                        {
                            CVectNormIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrUniformRandom:
                        {
                            CRandomIterator it;
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, true);
                        }
                        break;
                        case CPSInputType::attrUserParam:
                        {
                            CDecalIterator it;
                            it.Value = loc->getUserParam(_InputType.UserParamNum);
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrLOD:
                        {

                            CFDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrSquareLOD:
                        {

                            CFSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616(loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrClampedLOD:
                        {

                            CFClampDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616( loc->getPos().begin(), startIndex, srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                        case CPSInputType::attrClampedSquareLOD:
                        {

                            CFClampSquareDot3AddIterator<TIteratorVectStep1616>
                                it( TIteratorVectStep1616( loc->getPos().begin(), startIndex,  srcStep) );
                            loc->getLODVect(it.V, it.Offset, loc->getMatrixMode());
                            makeNByIterator(it, tab, stride, numAttrib, nbReplicate, false);
                        }
                        break;
                    }

                    NLMISC::OptFastFloorEnd();
                }
            }
            // Compute a single value from the input assuming that NLMISC::OptFastFloorBegin() has been called
            virtual T getInternal(float input)
            {
                input *= this->_NbCycles;
                if (_Clamp)
                {
                    if (input >= MaxInputValue) return _F(1.f);
                    return _F(input);
                }
                else
                {
                    return (input == MaxInputValue) ? _F(MaxInputValue) :  _F(NLMISC::OptFastFractionnalPart(input));
                }
            }
};



// implementation of CPSAttribMakerT methods //
template <typename T, class F>
T  CPSAttribMakerT<T, F>::get(CPSLocated *loc, uint32 index)
{
    NLMISC::OptFastFloorBegin();
    T result;
    nlassert(loc);
    switch (_InputType.InputType)
    {
        case CPSInputType::attrDate:
            result = getInternal(loc->getTime()[index]);
        break;
        case CPSInputType::attrInverseMass:
            result=  getInternal(loc->getInvMass()[index]);
        break;
        case CPSInputType::attrSpeed:
            result = getInternal(loc->getSpeed()[index].norm());
        break;
        case CPSInputType::attrPosition:
            result = getInternal(loc->getPos()[index].norm());
        break;
        case CPSInputType::attrUniformRandom:
        {
            result =  _F(float(rand() * (1 / double(RAND_MAX))));
        }
        break;
        case CPSInputType::attrUserParam:
        {
            result = getInternal(loc->getUserParam(_InputType.UserParamNum));
        }
        break;
        case CPSInputType::attrLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            loc->getLODVect(lodVect, lodOffset, loc->getMatrixMode());
            float r = fabsf(loc->getPos()[index] * lodVect + lodOffset);
            r = this->_NbCycles * r > MaxInputValue ? MaxInputValue : r;
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrSquareLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            loc->getLODVect(lodVect, lodOffset, loc->getMatrixMode());
            float r = loc->getPos()[index] * lodVect + lodOffset;
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r * r);

            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrClampedLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            loc->getLODVect(lodVect, lodOffset, loc->getMatrixMode());

            float r = loc->getPos()[index] * lodVect + lodOffset;
            if (r < 0)
            {
                result = _F(MaxInputValue);
                break;
            }
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r);
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrClampedSquareLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            loc->getLODVect(lodVect, lodOffset, loc->getMatrixMode());

            float r = loc->getPos()[index] * lodVect + lodOffset;
            if (r < 0)
            {
                result = _F(MaxInputValue);
                break;
            }
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r * r);
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        default:
            result = T();
        break;
    }

    NLMISC::OptFastFloorEnd();
    return result;
}

template <typename T, class F>
T  CPSAttribMakerT<T, F>::get(const CPSEmitterInfo &infos)
{
    NLMISC::OptFastFloorBegin();
    T result;
    switch (_InputType.InputType)
    {
        case CPSInputType::attrDate:
        {
            result = getInternal(infos.Life);
        }
        break;
        case CPSInputType::attrInverseMass:
        {
            result = getInternal(infos.InvMass);
        }
        break;
        case CPSInputType::attrSpeed:
        {
            result = getInternal(infos.Speed.norm());
        }
        break;
        case CPSInputType::attrPosition:
        {
            result = getInternal(infos.Pos.norm());
        }
        break;
        case CPSInputType::attrUniformRandom:
        {
            result =  _F(float(rand() * (1 / double(RAND_MAX))));
        }
        break;
        case CPSInputType::attrUserParam:
        {
            result = getInternal(infos.Loc->getUserParam(_InputType.UserParamNum));
        }
        break;
        case CPSInputType::attrLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            infos.Loc->getLODVect(lodVect, lodOffset, infos.Loc->getMatrixMode());
            float r = fabsf(infos.Pos * lodVect + lodOffset);
            r = this->_NbCycles * r > MaxInputValue ? MaxInputValue : r;
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrSquareLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            infos.Loc->getLODVect(lodVect, lodOffset, infos.Loc->getMatrixMode());
            float r = infos.Pos * lodVect + lodOffset;
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r * r);

            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrClampedLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            infos.Loc->getLODVect(lodVect, lodOffset, infos.Loc->getMatrixMode());
            float r = infos.Pos * lodVect + lodOffset;
            if (r < 0)
            {
                result = _F(MaxInputValue);
                break;
            }
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r);
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        case CPSInputType::attrClampedSquareLOD:
        {
            static NLMISC::CVector lodVect;
            float lodOffset;
            infos.Loc->getLODVect(lodVect, lodOffset, infos.Loc->getMatrixMode());

            float r = infos.Pos * lodVect + lodOffset;
            if (r < 0)
            {
                result = _F(MaxInputValue);
                break;
            }
            r = this->_NbCycles * (r > MaxInputValue ? MaxInputValue : r * r);
            if (_Clamp)
            {
                result = _F(r > MaxInputValue ? MaxInputValue : r);
            }
            else result = (r == MaxInputValue) ? _F(MaxInputValue) : _F(NLMISC::OptFastFractionnalPart(r));
        }
        break;
        default:
            result = T();
        break;
    }
    NLMISC::OptFastFloorEnd();
    return result;
}

template <typename T> class CPSAttribMakerMemoryBase : public CPSAttribMaker<T>
{
public:

    CPSAttribMakerMemoryBase() : CPSAttribMaker<T>(1.f), _Scheme(NULL)
    {
        this->_HasMemory = true;
    }

    virtual void setDefaultValue(T defaultValue) { _DefaultValue = defaultValue;}

    virtual T getDefaultValue(void) const { return _DefaultValue; }



    void setScheme(CPSAttribMaker<T> *scheme)
    {
        nlassert(scheme);
        if (_Scheme) delete _Scheme;
        _Scheme = scheme;
        if (_Scheme->hasMemory())
        {
            _Scheme->resize(_T.getMaxSize(), _T.getSize());
        }
    }

    CPSAttribMaker<T> *getScheme(void) { return _Scheme; }
    const CPSAttribMaker<T> *getScheme(void) const { return _Scheme; }


    // copy ctor
    CPSAttribMakerMemoryBase(const CPSAttribMakerMemoryBase &src) : CPSAttribMaker<T>(src) // parent copy ctor
    {
        nlassert(src._Scheme);
        std::auto_ptr<CPSAttribMaker<T> > s(NLMISC::safe_cast<CPSAttribMaker<T> *>(src._Scheme->clone()));
        this->_T = src._T;
        this->_DefaultValue = src._DefaultValue;
        this->_Scheme = s.release();
    }
    ~CPSAttribMakerMemoryBase()
    {
        if (_Scheme)
        {
            delete _Scheme;
        }
    }

    virtual T get(CPSLocated * /* loc */, uint32 index)
    {
        if (index < _T.getSize()) return _T[index];
        else return _DefaultValue;
    }
    virtual T get(const CPSEmitterInfo &/* infos */) {  return _DefaultValue; }

    virtual void *make(CPSLocated * /* loc */,
                       uint32 startIndex,
                       void *output,
                       uint32 stride,
                       uint32 numAttrib,
                       bool allowNoCopy = false,
                       uint32 srcStep = (1 << 16),
                       bool /* forceClampEntry */ = false
                      ) const
    {
        if (!numAttrib) return output;
        void *tab = output;
        if (!allowNoCopy || srcStep != (1 << 16) || sizeof(T) != stride)
        {
            // we just copy what we have memorized
            if (srcStep == (1 << 16))
            {
                typename CPSAttrib<T>::const_iterator it = _T.begin() + startIndex, endIt = _T.begin() + startIndex + numAttrib;
                do
                {
                    *(T *) tab = *it;
                    ++it;
                    tab = (uint8 *) tab + stride;
                }
                while (it != endIt);
            }
            else // no constant step
            {
                uint32 fpIndex = startIndex * srcStep;
                typename CPSAttrib<T>::const_iterator startIt = _T.begin();
                while (numAttrib --)
                {
                    *(T *) tab = *(startIt + (fpIndex >> 16));
                    tab = (uint8 *) tab + stride;
                    fpIndex += srcStep;
                }
            }
            return output;
        }
        else
        {
            // the caller will read data directly in the vector ...
            return (void *) &(*(_T.begin() + startIndex));
        }
    }

    virtual void make4(CPSLocated * /* loc */,
                       uint32 startIndex,
                       void *tab,
                       uint32 stride,
                       uint32 numAttrib,
                       uint32 srcStep = (1 << 16)
                       ) const
    {
        // we just copy what we have memorized
        if (srcStep == (1 << 16))
        {
            typename CPSAttrib<T>::const_iterator it = _T.begin() + startIndex, endIt = _T.begin() + startIndex + numAttrib;
            while (it != endIt)
            {
                *(T *) tab = *it;
                tab = (uint8 *) tab + stride;
                *(T *) tab = *it;
                tab = (uint8 *) tab + stride;
                *(T *) tab = *it;
                tab = (uint8 *) tab + stride;
                *(T *) tab = *it;
                tab = (uint8 *) tab + stride;
                ++it;
            }
        }
        else
        {
            uint32 fpIndex = startIndex * srcStep;
            typename CPSAttrib<T>::const_iterator startIt = _T.begin();
            while (numAttrib --)
            {
                *(T *) tab = *(startIt + (fpIndex >> 16));
                *(T *) ((uint8 *) tab + stride) = *(T *) tab;
                tab = (uint8 *) tab + stride;
                *(T *) ((uint8 *) tab + stride) = *(T *) tab;
                tab = (uint8 *) tab + stride;
                *(T *) ((uint8 *) tab + stride) = *(T *) tab;

                tab = (uint8 *) tab + stride + stride;
                fpIndex += srcStep;
            }
        }
    }

    virtual void makeN(CPSLocated * /* loc */,
                       uint32 startIndex,
                       void *tab,
                       uint32 stride,
                       uint32 numAttrib,
                       uint32 nbReplicate,
                       uint32 srcStep = (1 << 16)
                      ) const
    {
        // we just copy what we have memorized
        uint k;
        typename CPSAttrib<T>::const_iterator it = _T.begin() + startIndex, endIt = _T.begin() + startIndex + numAttrib;
        if (srcStep == (1 << 16))
        {
            while (it != endIt)
            {

                for (k = 0; k < nbReplicate; ++k)
                {
                    *(T *) tab = *it;
                    tab = (uint8 *) tab + stride;
                }
                ++it;
            }
        }
        else
        {
            uint32 fpIndex = startIndex * srcStep;
            typename CPSAttrib<T>::const_iterator startIt = _T.begin();

            while (numAttrib --)
            {
                *(T *) tab = *(startIt + (fpIndex >> 16));
                for (k = 1; k < nbReplicate; ++k)
                {
                    *(T *) ((uint8 *) tab + stride) = *(T *) tab;
                    tab = (uint8 *) tab + stride;
                }
                tab = (uint8 *) tab + stride;
                fpIndex += srcStep;
            }

        }
    }

    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
    {

        f.serialVersion(1);
        CPSAttribMaker<T>::serial(f);
        if (f.isReading())
        {
            if (_Scheme) delete _Scheme;
        }
        f.serialPolyPtr(_Scheme);
        f.serial(_T);
        f.serial(_DefaultValue);
    }

    virtual void deleteElement(uint32 index)
    {
        nlassert(_Scheme); // you should have called setScheme !
        _T.remove(index);
        if (_Scheme->hasMemory())
        {
            _Scheme->deleteElement(index);
        }
    }
    virtual void newElement(const CPSEmitterInfo &info)
    {
        nlassert(_Scheme); // you should have called setScheme !

        // we should create the contained scheme before this one if it has memory...
        if (_Scheme->hasMemory())
        {
            _Scheme->newElement(info);
        }

        if (info.Loc)
        {
            _T.insert(_Scheme->get(info));
        }
        else
        {
            _T.insert(_DefaultValue);
        }
    }
    virtual void resize(uint32 capacity, uint32 nbPresentElements)
    {
        nlassert(capacity < (1 << 16));
        _T.resize(capacity);
        if (nbPresentElements > _T.getSize())
        {
            while (_T.getSize() != nbPresentElements)
            {
                _T.insert(_DefaultValue);
            }
        }
        else if (nbPresentElements < _T.getSize())
        {
            while (_T.getSize() != nbPresentElements)
            {
                _T.remove(_T.getSize() - 1);
            }
        }


        if (_Scheme && _Scheme->hasMemory())
        {
            _Scheme->resize(capacity,   nbPresentElements);
        }

    }
    virtual bool hasCustomInput() { return false; }

protected:
    // the attribute we memorize
    CPSAttrib<T> _T;

    // the default value for generation (when no emitter can be used)
    T _DefaultValue;

    CPSAttribMaker<T> *_Scheme;
};


template <typename T> class CPSAttribMakerMemory : public CPSAttribMakerMemoryBase<T>
{
public:
    // default ctor
    CPSAttribMakerMemory() : CPSAttribMakerMemoryBase<T>() {}
    CPSAttribMakerMemory(const CPSAttribMakerMemory &other) : CPSAttribMakerMemoryBase<T>(other) {}
};

template <>
class CPSAttribMakerMemory<uint32> : public  CPSAttribMakerMemoryBase<uint32>
{
public:
    // default ctor
    CPSAttribMakerMemory() : CPSAttribMakerMemoryBase<uint32>() {}
    // copy ctor
    CPSAttribMakerMemory(const CPSAttribMakerMemory<uint32> &other) : CPSAttribMakerMemoryBase<uint32>(other)
    {
        _MinValue = other._MinValue;
        _MaxValue = other._MaxValue;
    }
    // serial. Should update min / max when reading
    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    virtual uint32 getMinValue(void) const { return _MinValue; }
    virtual uint32 getMaxValue(void) const { return _MaxValue; }
    virtual void newElement(const CPSEmitterInfo &info);
private:
    uint32 _MinValue;
    uint32 _MaxValue;
};
template <>
class CPSAttribMakerMemory<sint32> : public  CPSAttribMakerMemoryBase<sint32>
{
public:
    // default ctor
    CPSAttribMakerMemory() : CPSAttribMakerMemoryBase<sint32>() {}
    // copy ctor
    CPSAttribMakerMemory(const CPSAttribMakerMemory<sint32> &other) : CPSAttribMakerMemoryBase<sint32>(other)
    {
        _MinValue = other._MinValue;
        _MaxValue = other._MaxValue;
    }
    // serial. Should update min / max when reading
    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    virtual sint32 getMinValue(void) const { return _MinValue; }
    virtual sint32 getMaxValue(void) const { return _MaxValue; }
    virtual void newElement(const CPSEmitterInfo &info);
private:
    sint32 _MinValue;
    sint32 _MaxValue;
};
template <>
class CPSAttribMakerMemory<float> : public  CPSAttribMakerMemoryBase<float>
{
public:
    // default ctor
    CPSAttribMakerMemory() : CPSAttribMakerMemoryBase<float>() {}
    // copy ctor
    CPSAttribMakerMemory(const CPSAttribMakerMemory<float> &other) : CPSAttribMakerMemoryBase<float>(other)
    {
        _MinValue = other._MinValue;
        _MaxValue = other._MaxValue;
    }
    // serial. Should update min / max when reading
    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    virtual float getMinValue(void) const { return _MinValue; }
    virtual float getMaxValue(void) const { return _MaxValue; }
    virtual void newElement(const CPSEmitterInfo &info);
private:
    float _MinValue;
    float _MaxValue;
};





} // NL3D


#endif // NL_PS_ATTRIB_MAKER_HELPER_H

/* End of ps_attrib_maker_helper.h */