ps_force.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_FORCE_H
#define NL_PS_FORCE_H

#include "nel/misc/types_nl.h"
#include "nel/3d/ps_located.h"
#include "nel/3d/ps_util.h"
#include "nel/3d/ps_attrib_maker.h"
#include "nel/3d/ps_edit.h"
#include "nel/3d/ps_direction.h"
#include "nel/3d/particle_system.h"


namespace NL3D {

class CPSEmitterInfo;

class CPSForce : public CPSTargetLocatedBindable
{
public:

    CPSForce();

    uint32              getType(void) const { return PSForce; }



    virtual uint32      getPriority(void) const { return 4000; }

    virtual bool        doesProduceBBox(void) const { return false; }

    virtual void        step(TPSProcessPass pass);


    virtual void        computeForces(CPSLocated &target) = 0;

    virtual void        show() = 0;

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

    virtual bool         isIntegrable(void) const { return false; }

    virtual void         attachTarget(CPSLocated *ptr);

    void                  releaseTargetRsc(CPSLocated *target);


     virtual void integrate(float date, CPSLocated *src, uint32 startIndex, uint32 numObjects, NLMISC::CVector *destPos = NULL, NLMISC::CVector *destSpeed = NULL,
                            bool accumulate = false,
                            uint posStride = sizeof(NLMISC::CVector), uint speedStride = sizeof(NLMISC::CVector)
                            ) const
     {
         nlassert(0); // not an integrable force
     }


    virtual void integrateSingle(float startDate, float deltaT, uint numStep,
                                 const CPSLocated *src, uint32 indexInLocated,
                                 NLMISC::CVector *destPos,
                                 bool accumulate = false,
                                 uint posStride = sizeof(NLMISC::CVector)) const
    {
         nlassert(0); // not an integrable force
    }






protected:
    friend class CPSLocated;
    friend class CPSForceIntensity;

    void                registerToTargets(void);

    void                 cancelIntegrable(void);

    void                 renewIntegrable(void);

    virtual void         basisChanged(TPSMatrixMode systemBasis);

    virtual void newElement(const CPSEmitterInfo &info) = 0;

    virtual void deleteElement(uint32 index) = 0;

    virtual void resize(uint32 size) = 0;
};


class CPSForceIntensity
{
public:

    // ctor
    CPSForceIntensity() : _IntensityScheme(NULL)
    {
    }

    virtual ~CPSForceIntensity();


    float getIntensity(void) const  { return _K; }

    virtual void setIntensity(float value);

    virtual void setIntensityScheme(CPSAttribMaker<float> *scheme);

    // deriver have here the opportunity to setup the functor object. The default does nothing
    virtual void setupFunctor(uint32 indexInLocated) { }

    CPSAttribMaker<float> *getIntensityScheme(void) { return _IntensityScheme; }
    const CPSAttribMaker<float> *getIntensityScheme(void) const { return _IntensityScheme; }
    void serialForceIntensity(NLMISC::IStream &f) throw(NLMISC::EStream);

protected:

    virtual CPSLocated *getForceIntensityOwner(void) = 0;


    // the intensity ...
    float _K;
    CPSAttribMaker<float> *_IntensityScheme;

    void newForceIntensityElement(const CPSEmitterInfo &info)
    {
        if (_IntensityScheme && _IntensityScheme->hasMemory()) _IntensityScheme->newElement(info);
    }
    void deleteForceIntensityElement(uint32 index)
    {
        if (_IntensityScheme && _IntensityScheme->hasMemory()) _IntensityScheme->deleteElement(index);
    }
    void resizeForceIntensity(uint32 size)
    {
        if (_IntensityScheme && _IntensityScheme->hasMemory()) _IntensityScheme->resize(size, getForceIntensityOwner()->getSize());
    }
};


class CPSForceIntensityHelper : public CPSForce, public CPSForceIntensity
{
public:
    void serial(NLMISC::IStream &f) throw(NLMISC::EStream) ;

protected:
    virtual CPSLocated *getForceIntensityOwner(void) { return _Owner; }
    virtual void newElement(const CPSEmitterInfo &info) { newForceIntensityElement(info); }
    virtual void deleteElement(uint32 index) { deleteForceIntensityElement(index); }
    virtual void resize(uint32 size) { resizeForceIntensity(size); }

};




template <class T> class CIsotropicForceT : public CPSForce
{
public:

    virtual void computeForces(CPSLocated &target);


    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
    {
        f.serialVersion(1);
        CPSForce::serial(f);
        f.serial(_F); // serial the functor object 5does nothing most of the time ...)
    }


     void show()  {}



     virtual void setupFunctor(uint32 /* index */) {}

protected:

    T _F;



    virtual void newElement(const CPSEmitterInfo &/* info */) {}
    virtual void deleteElement(uint32 /* index */) {}
    virtual void resize(uint32 /* size */) {}


};

// implementation of method of the template class  CHomogenousForceT //


template <class T> void CIsotropicForceT<T>::computeForces(CPSLocated &target)
{
    nlassert(CParticleSystem::InsideSimLoop);
    for (uint32 k = 0; k < _Owner->getSize(); ++k)
    {
        setupFunctor(k);
        TPSAttribVector::iterator speedIt = target.getSpeed().begin(), endSpeedIt = target.getSpeed().end();
        TPSAttribVector::const_iterator posIt = target.getPos().begin();
        TPSAttribFloat::const_iterator invMassIt = target.getInvMass().begin();

        for (; speedIt != endSpeedIt; ++speedIt, ++posIt, ++invMassIt)
        {
            _F(*posIt, *speedIt, *invMassIt);
        }
    }
}


class CPSDirectionnalForce : public CPSForceIntensityHelper, public CPSDirection
{
    public:
    virtual void computeForces(CPSLocated &target);

    virtual void show();



    CPSDirectionnalForce(float i = 1.f)
    {
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("DirectionnalForce");
        setIntensity(i);
        _Dir = NLMISC::CVector(0, 0, -1);
    }

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


    NLMISC_DECLARE_CLASS(CPSDirectionnalForce);



        virtual void setDir(const NLMISC::CVector &dir) { _Dir = dir; }
        virtual NLMISC::CVector getDir(void) const  { return _Dir; }
        // Tells that a global vector value of the system can be used as a direction
        virtual bool supportGlobalVectorValue() const { return true; }
        virtual void                enableGlobalVectorValue(const std::string &name);
        // See if the direction is bound to a global variable. Return an empty string if not
        virtual std::string         getGlobalVectorValueName() const;
protected:
    NLMISC::CVector                             _Dir;
    CParticleSystem::CGlobalVectorValueHandle   _GlobalValueHandle; // a global vector value may override the value of _Dir (example of use : global direction for wind)
};


class CPSGravity : public CPSForceIntensityHelper
{
public:
    virtual void computeForces(CPSLocated &target);

    virtual void show();



    CPSGravity(float g = 9.8f)
    {
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("Gravity");
        setIntensity(g);
    }

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

    NLMISC_DECLARE_CLASS(CPSGravity);


    virtual bool         isIntegrable(void) const;

    virtual void integrate(float date, CPSLocated *src, uint32 startIndex, uint32 numObjects, NLMISC::CVector *destPos = NULL, NLMISC::CVector *destSpeed = NULL,
                            bool accumulate = false,
                            uint posStride = sizeof(NLMISC::CVector), uint speedStride = sizeof(NLMISC::CVector)
                            ) const;

    virtual void integrateSingle(float startDate, float deltaT, uint numStep,
                                 const CPSLocated *src, uint32 indexInLocated,
                                 NLMISC::CVector *destPos,
                                 bool accumulate = false,
                                 uint posStride = sizeof(NLMISC::CVector)) const;

protected:
    virtual void setIntensity(float value);
    virtual void setIntensityScheme(CPSAttribMaker<float> *scheme);
};


class CPSCentralGravity : public CPSForceIntensityHelper
{
public:
    virtual void computeForces(CPSLocated &target);

    virtual void show();



    CPSCentralGravity(float i = 1.f)
    {
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("CentralGravity");
        setIntensity(i);
    }

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


    NLMISC_DECLARE_CLASS(CPSCentralGravity);
};


class CPSSpring : public CPSForceIntensityHelper
{
public:

    CPSSpring(float k = 1.0f)
    {
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("Spring");
        setIntensity(k);
    }


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


    virtual void computeForces(CPSLocated &target);

    virtual void show();


    NLMISC_DECLARE_CLASS(CPSSpring);

};



class CPSFluidFrictionFunctor
{
public:
    CPSFluidFrictionFunctor() : _K(1.f)
    {
    }

    virtual ~CPSFluidFrictionFunctor() {}

    #ifdef NL_OS_WINDOWS
        __forceinline
    #endif
     void operator() (const NLMISC::CVector &pos, NLMISC::CVector &speed, float invMass)
     {
        speed -= (CParticleSystem::EllapsedTime * _K * invMass * speed);
     }

     virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
     {
         f.serialVersion(1);
         // we don't save intensity info : it is saved by the owning object (and set before each use of this functor)
     }

     // get the friction coefficient
     float getK(void) const { return _K; }

     // set the friction coefficient
     void setK(float coeff) { _K = coeff; }
protected:
    // the friction coeff
    float _K;
};


class CPSFluidFriction : public CIsotropicForceT<CPSFluidFrictionFunctor>, public CPSForceIntensity
{
public:
    // create the force with a friction coefficient
    CPSFluidFriction(float frictionCoeff = 1.f)
    {
        setIntensity(frictionCoeff);
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("FluidFriction");
    }

    // inherited from CIsotropicForceT
    virtual void setupFunctor(uint32 index)
    {
        _F.setK(_IntensityScheme ? _IntensityScheme->get(_Owner, index) : _K);
    }

    NLMISC_DECLARE_CLASS(CPSFluidFriction)


    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
    {
        f.serialVersion(1);
        CIsotropicForceT<CPSFluidFrictionFunctor>::serial(f);
        serialForceIntensity(f);
        if (f.isReading())
        {
            registerToTargets();
        }
    }


protected:
    virtual CPSLocated *getForceIntensityOwner(void) { return _Owner; }
    virtual void newElement(const CPSEmitterInfo &info) { newForceIntensityElement(info); }
    virtual void deleteElement(uint32 index) { deleteForceIntensityElement(index); }
    virtual void resize(uint32 size) { resizeForceIntensity(size); }
};


class CPSBrownianForce : public CPSForceIntensityHelper
{
public:
    // create the force with a friction coefficient
    CPSBrownianForce(float intensity = 1.f);

    NLMISC_DECLARE_CLASS(CPSBrownianForce)

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

    virtual bool         isIntegrable(void) const;

    virtual void integrate(float date, CPSLocated *src, uint32 startIndex, uint32 numObjects, NLMISC::CVector *destPos = NULL, NLMISC::CVector *destSpeed = NULL,
                            bool accumulate = false,
                            uint posStride = sizeof(NLMISC::CVector), uint speedStride = sizeof(NLMISC::CVector)
                            ) const;

    virtual void integrateSingle(float startDate, float deltaT, uint numStep,
                                 const CPSLocated *src, uint32 indexInLocated,
                                 NLMISC::CVector *destPos,
                                 bool accumulate = false,
                                 uint posStride = sizeof(NLMISC::CVector)) const;

    static void initPrecalc();

    void setIntensity(float value);
    void setIntensityScheme(CPSAttribMaker<float> *scheme);

    virtual void computeForces(CPSLocated &target);

    void show()  {}


    void    setParametricFactor(float factor) {  _ParametricFactor = factor; }
    float   getParametricFactor() const { return _ParametricFactor; }

protected:
    virtual CPSLocated *getForceIntensityOwner(void) { return _Owner; }
    virtual void newElement(const CPSEmitterInfo &info) { newForceIntensityElement(info); }
    virtual void deleteElement(uint32 index) { deleteForceIntensityElement(index); }
    virtual void resize(uint32 size) { resizeForceIntensity(size); }

    float  _ParametricFactor; // tells how fast this force act on a particle when parametric motion is used
    static NLMISC::CVector PrecomputedPos[]; // after the sequence we must be back to the start position
    static NLMISC::CVector PrecomputedSpeed[];

    static NLMISC::CVector PrecomputedImpulsions[];

};



struct CPSTurbulForceFunc
{
    virtual ~CPSTurbulForceFunc() {}

    #ifdef NL_OS_WINDOWS
        __forceinline
    #endif
    void operator() (const NLMISC::CVector &pos, NLMISC::CVector &speed, float invMass)
    {
        nlassert(0);

        // TODO : complete that

    /*  static const NLMISC::CVector v1(1.235f, - 45.32f, 157.5f);
        static const NLMISC::CVector v2(-0.35f, 7.77f, 220.77f);


        speed += ellapsedTime * _Intensity
               * NLMISC::CVector(2.f * (-0.5f + CPSUtil::buildPerlinNoise(_Scale * pos, _NumOctaves))
                         , 2.f * (-0.5f +  CPSUtil::buildPerlinNoise(_Scale * (pos +  v1) , _NumOctaves))
                         , 2.f * (-0.5f +  CPSUtil::buildPerlinNoise(_Scale * (pos +  v2) , _NumOctaves))
                         );
                         */
    }

    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
     {
        f.serialVersion(1);
        f.serial(_Scale, _NumOctaves);
     }

    float _Scale;
    float _Intensity;
    uint32 _NumOctaves;
};



// the turbulence force

class CPSTurbul : public CIsotropicForceT<CPSTurbulForceFunc>, public CPSForceIntensity
{
public:
    // create the force with a friction coefficient
    CPSTurbul(float scale = 1.f , uint numOctaves = 4)
    {
        nlassert(numOctaves > 0);
        setScale(scale);
        setNumOctaves(numOctaves);
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("Turbulence");
    }


    float getScale(void) const { return _F._Scale; }
    void setScale(float scale) { _F._Scale = scale; }


    uint getNumOctaves(void) const { return _F._NumOctaves; }
    void setNumOctaves(uint numOctaves) { _F._NumOctaves = numOctaves; }


    NLMISC_DECLARE_CLASS(CPSTurbul)

    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
    {
        f.serialVersion(1);
        CIsotropicForceT<CPSTurbulForceFunc>::serial(f);
        serialForceIntensity(f);
        if (f.isReading())
        {
            registerToTargets();
        }
    }

    // inherited from CIsotropicForceT
    virtual void setupFunctor(uint32 index)
    {
        _F._Intensity = (_IntensityScheme ? _IntensityScheme->get(_Owner, index) : _K);
    }

protected:
    virtual CPSLocated *getForceIntensityOwner(void) { return _Owner; }
    virtual void newElement(const CPSEmitterInfo &info) { newForceIntensityElement(info); }
    virtual void deleteElement(uint32 index) { deleteForceIntensityElement(index); }
    virtual void resize(uint32 size) { resizeForceIntensity(size); }
};




class CPSCylindricVortex : public CPSForceIntensityHelper, public IPSMover
{
public:
    virtual void computeForces(CPSLocated &target);

    virtual void show();


    CPSCylindricVortex(float intensity = 1.f) : _RadialViscosity(.1f), _TangentialViscosity(.1f)
    {
        setIntensity(intensity);
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("Cylindric Vortex");
    }

    // inherited from IPSMover
    virtual bool supportUniformScaling(void) const { return true; }
    virtual bool supportNonUniformScaling(void) const { return false; }
    virtual void setScale(uint32 k, float scale) { _Radius[k] = scale; }
    virtual NLMISC::CVector getScale(uint32 k) const { return NLMISC::CVector(_Radius[k], _Radius[k], _Radius[k]); }
    virtual bool onlyStoreNormal(void) const { return true; }
    virtual NLMISC::CVector getNormal(uint32 index) { return _Normal[index]; }
    virtual void setNormal(uint32 index, NLMISC::CVector n) { _Normal[index] = n; }

    virtual void setMatrix(uint32 index, const NLMISC::CMatrix &m);
    virtual NLMISC::CMatrix getMatrix(uint32 index) const;


    void setRadialViscosity(float v) { _RadialViscosity = v; }
    float getRadialViscosity(void) const { return _RadialViscosity; }

    void setTangentialViscosity(float v) { _TangentialViscosity = v; }
    float getTangentialViscosity(void) const { return _TangentialViscosity; }

    NLMISC_DECLARE_CLASS(CPSCylindricVortex);



    // serialization
    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);





protected:

    virtual CPSLocated *getForceIntensityOwner(void) { return _Owner; }

    // the normal of the vortex
    CPSAttrib<NLMISC::CVector> _Normal;
    // radius of the vortex
    TPSAttribFloat _Radius;

    // radial viscosity : when it is near of 1, if tends to set the radial componenent of speed to 0
    float _RadialViscosity;

    // tangential viscosity : when set to 1, the tangential speed immediatly reach what it would be in a real vortex (w = 1 / r2)
    float _TangentialViscosity;

    virtual void newElement(const CPSEmitterInfo &info);
    virtual void deleteElement(uint32 index);
    virtual void resize(uint32 size);

};




class CPSMagneticForce : public CPSDirectionnalForce
{
    public:
    CPSMagneticForce(float i = 1.f)  : CPSDirectionnalForce(i)
    {
        if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("MagneticForce");
    }
    virtual void computeForces(CPSLocated &target);
    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    NLMISC_DECLARE_CLASS(CPSMagneticForce);
};





} // NL3D


#endif // NL_PS_FORCE_H

/* End of ps_force.h */