ps_particle_basic.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_PARTICLE_BASIC_H
#define NL_PS_PARTICLE_BASIC_H

#include "nel/misc/types_nl.h"
#include "nel/misc/vector_2f.h"
#include "nel/misc/stream.h"
#include "nel/3d/ps_located.h"
#include "nel/3d/ps_plane_basis.h"
#include "nel/3d/material.h"
#include "nel/3d/ps_attrib_maker.h"

namespace NL3D
{


// class forward declarations //

class CTextureGrouped;

class CPSParticle : public CPSLocatedBindable
{
public:

    CPSParticle();

    uint32 getType(void) const { return PSParticle; }

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

    virtual bool hasParticles(void) const { nlassert(_Owner); return _Owner->getSize() != 0; }

    virtual void step(TPSProcessPass pass)
    {
        if (
            (pass == PSBlendRender && hasTransparentFaces())
            || (pass == PSSolidRender && hasOpaqueFaces())
            )
        {
            draw(pass == PSSolidRender);
        }
        else
        if (pass == PSToolRender) // edition mode only
        {
            showTool();
        }
    }

    virtual bool hasTransparentFaces(void)  = 0;

    virtual bool hasOpaqueFaces(void)  = 0;

    virtual bool hasLightableFaces() = 0;

    bool usesGlobalColorLighting() { return _UsesGlobalColorLighting; }
    // active / deactive global color lighting
    void enableGlobalColorLighting(bool enabled) { _UsesGlobalColorLighting = enabled; }
    // is global color lighting supported ?
    virtual bool supportGlobalColorLighting() const = 0;

    virtual void draw(bool opaque) {}

    virtual void showTool();

    virtual uint32 getNumWantedTris() const = 0;

    virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
    {
        sint ver = f.serialVersion(3);
        CPSLocatedBindable::serial(f);
        if (ver >= 3)
        {
            f.serial(_UsesGlobalColorLighting);
        }
        if (ver >= 2)
        {
            f.serial(_DisableAutoLOD);
        }
    }


    void    disableAutoLOD(bool disable = true) { _DisableAutoLOD = disable; }

    bool    isAutoLODDisabled() const { return _DisableAutoLOD; }

    // Change z-bias of material. this must be redefined for all renderable particles
    virtual void            setZBias(float value) = 0;
    virtual float           getZBias() const = 0;

protected:

    /*
    void notifyOwnerMaxNumFacesChanged(void) const
    {
        if (_Owner)
        {
            _Owner->notifyMaxNumFacesChanged();
        }
    }*/

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

    virtual void deleteElement(uint32 index) = 0;

    virtual void resize(uint32 size) = 0;


     void computeSrcStep(uint32 &step, uint &numToProcess);

private:
     bool   _DisableAutoLOD;
     bool   _UsesGlobalColorLighting;
};


class CPSColoredParticle
{
    public:

        void setColorScheme(CPSAttribMaker<CRGBA> *col);

        CPSAttribMaker<CRGBA> *getColorScheme(void) { return _ColorScheme; }

        const CPSAttribMaker<CRGBA> *getColorScheme(void) const { return _ColorScheme; }

        void setColor(NLMISC::CRGBA col);

        NLMISC::CRGBA getColor(void) const { return _Color; }

        CPSColoredParticle();

        virtual ~CPSColoredParticle();

        void serialColorScheme(NLMISC::IStream &f) throw(NLMISC::EStream);

    protected:

        virtual CPSLocated *getColorOwner(void) = 0;
        CRGBA _Color;

        CPSAttribMaker<CRGBA> *_ColorScheme;

        virtual void updateMatAndVbForColor(void) = 0;

        void newColorElement(const CPSEmitterInfo &info)
        {
            if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->newElement(info);
        }
        void deleteColorElement(uint32 index)
        {
            if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->deleteElement(index);
        }
        void resizeColor(uint32 size)
        {
            nlassert(size < (1 << 16));
            if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->resize(size, getColorOwner()->getSize());
        }
};


class CPSSizedParticle
{
    public:

        void setSizeScheme(CPSAttribMaker<float> *size);



        CPSAttribMaker<float> *getSizeScheme(void) { return _SizeScheme; }

        const CPSAttribMaker<float> *getSizeScheme(void) const { return _SizeScheme; }

        void setSize(float size);

        float getSize(void) const { return _ParticleSize; }

        CPSSizedParticle();

        virtual ~CPSSizedParticle();

        void serialSizeScheme(NLMISC::IStream &f) throw(NLMISC::EStream);

    protected:

        virtual CPSLocated *getSizeOwner(void) = 0;
        float _ParticleSize;
        CPSAttribMaker<float> *_SizeScheme;
        void newSizeElement(const CPSEmitterInfo &info)
        {
            if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->newElement(info);
        }
        void deleteSizeElement(uint32 index)
        {
            if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->deleteElement(index);
        }
        void resizeSize(uint32 size)
        {
            nlassert(size < (1 << 16));
            if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->resize(size, getSizeOwner()->getSize());
        }
};



class CPSRotated2DParticle
{
    public:

        void setAngle2DScheme(CPSAttribMaker<float> *scheme);

        CPSAttribMaker<float> *getAngle2DScheme(void) { return _Angle2DScheme; }

        const CPSAttribMaker<float> *getAngle2DScheme(void) const { return _Angle2DScheme; }


        void setAngle2D(float angle);

        float getAngle2D(void) const { return _Angle2D; }

        CPSRotated2DParticle();

        virtual ~CPSRotated2DParticle();

        void serialAngle2DScheme(NLMISC::IStream &f) throw(NLMISC::EStream);



        static inline const float *getRotTable(void)
        {
            nlassert(_InitializedRotTab); // must have called initRotTable at the start of the apply
            return _RotTable;
        }

        static void initRotTable(void);

    protected:
        virtual CPSLocated *getAngle2DOwner(void) = 0;

        float _Angle2D;
        CPSAttribMaker<float> *_Angle2DScheme;
        static float _RotTable[4 * 256];

        //#ifdef NL_DEBUG
            static bool _InitializedRotTab;
        //#endif

        void newAngle2DElement(const CPSEmitterInfo &info)
        {
            if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->newElement(info);
        }
        void deleteAngle2DElement(uint32 index)
        {
            if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->deleteElement(index);
        }
        void resizeAngle2D(uint32 size)
        {
            nlassert(size < (1 << 16));
            if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->resize(size, getAngle2DOwner()->getSize());
        }
};



struct CPSTexturedParticleNoAnim
{
        virtual ~CPSTexturedParticleNoAnim() {}
        virtual void                        setTexture(CSmartPtr<ITexture> tex) = 0;
        virtual ITexture                    *getTexture(void) = 0;
        virtual const ITexture              *getTexture(void) const = 0;
};


class CPSTexturedParticle
{
    public:

        void setTextureIndexScheme(CPSAttribMaker<sint32> *animOrder);

        CPSAttribMaker<sint32> *getTextureIndexScheme(void) { return _TextureIndexScheme; }

        const CPSAttribMaker<sint32> *getTextureIndexScheme(void) const { return _TextureIndexScheme; }

        void setTextureIndex(sint32 index);

        sint32 getTextureIndex(void) const { return _TextureIndex; }

        virtual void setTextureGroup(NLMISC::CSmartPtr<CTextureGrouped> texGroup);

        CTextureGrouped *getTextureGroup(void) {  return _TexGroup; }

        const CTextureGrouped *getTextureGroup(void) const { return _TexGroup; }

        virtual void setTexture(CSmartPtr<ITexture> tex);

        ITexture *getTexture(void) { return _Tex; }
        // get the texture (const version)
        const ITexture *getTexture(void) const { return _Tex; }

        CPSTexturedParticle();

        virtual ~CPSTexturedParticle();

        void serialTextureScheme(NLMISC::IStream &f) throw(NLMISC::EStream);

        void            enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest);


    protected:
        virtual CPSLocated *getTextureIndexOwner(void) = 0;

        // a single texture
        CSmartPtr<ITexture> _Tex;

        // a grouped texture
        CSmartPtr<CTextureGrouped> _TexGroup;

        CPSAttribMaker<sint32> *_TextureIndexScheme;

        // a texture index. Most of the time, a scheme of index will be used instead of that
        sint32 _TextureIndex;

        virtual void updateMatAndVbForTexture(void) = 0;

        void newTextureIndexElement(const CPSEmitterInfo &info)
        {
            if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->newElement(info);
        }
        void deleteTextureIndexElement(uint32 index)
        {
            if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->deleteElement(index);
        }
        void resizeTextureIndex(uint32 size)
        {
            nlassert(size < (1 << 16));
            if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->resize(size, getTextureIndexOwner()->getSize() );
        }
};


class CPSMultiTexturedParticle
{
public:
    CPSMultiTexturedParticle();
    virtual ~CPSMultiTexturedParticle() {}

    enum TOperator { Add = 0, Modulate, Decal, EnvBumpMap, Last = 0xff };

    void                        enableMultiTexture(bool enabled = true);
    bool                        isMultiTextureEnabled() const   { return (_MultiTexState & (uint8) MultiTextureEnabled) != 0; }

    void                        setTexture2(ITexture *tex);

    const ITexture              *getTexture2() const { return _Texture2; }
    ITexture                    *getTexture2() { return _Texture2; }

    void                        setMainTexOp(TOperator op);

    TOperator                   getMainTexOp() const       { return _MainOp; }

    // Enable the use of an alternate texture for multitexturing. When disabled, this discard the textures that may have been set.
    void                        enableAlternateTex(bool enabled = true);
    bool                        isAlternateTexEnabled() const { return (_MultiTexState & (uint8) AlternateTextureEnabled) != 0; }

    // Convert the texture to / from a bumpmap if needed. (so you just provide its heightmap)
    void                        setTexture2Alternate(ITexture *tex);

    const ITexture              *getTexture2Alternate() const { return _AlternateTexture2; }
    ITexture                    *getTexture2Alternate() { return _AlternateTexture2; }

    void                        setAlternateTexOp(TOperator op);

    TOperator                   getAlternateTexOp() const
    {
        return _AlternateOp;
    }

    void                        setScrollSpeed(uint stage, const NLMISC::CVector2f &sp)
    {
        nlassert(stage < 2);
        _TexScroll[stage] = sp;
    }
    const NLMISC::CVector2f     &getScrollSpeed(uint stage) const
    {
        nlassert(stage < 2);
        return _TexScroll[stage];
    }

    void                        setAlternateScrollSpeed(uint stage, const NLMISC::CVector2f &sp)
    {
        nlassert(stage < 2);
        _TexScrollAlternate[stage] = sp;
    }
    const NLMISC::CVector2f     &getAlternateScrollSpeed(uint stage) const
    {
        nlassert(stage < 2);
        return _TexScrollAlternate[stage];
    }

    void serialMultiTex(NLMISC::IStream &f) throw(NLMISC::EStream);

    void setupMaterial(ITexture *primary, IDriver *drv, CMaterial &mat, CVertexBuffer &vb);

    static void forceBasicCaps(bool force = true) { _ForceBasicCaps =  force; }

    static  bool areBasicCapsForced() { return _ForceBasicCaps; }

    void    setUseLocalDate(bool use);
    bool    getUseLocalDate() { return (_MultiTexState & ScrollUseLocalDate) != 0; }

    void    setUseLocalDateAlt(bool use);
    bool    getUseLocalDateAlt() { return (_MultiTexState & ScrollUseLocalDateAlternate) != 0; }

    void    setBumpFactor(float bumpFactor) { _BumpFactor = bumpFactor; touch(); }
    float   getBumpFactor() const { return _BumpFactor; }

    void            enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv);


protected:
    void                        setupMultiTexEnv(TOperator op, ITexture *tex1, ITexture *tex2, CMaterial &mat, IDriver &drv);
    TOperator                   _MainOp, _AlternateOp;
    NLMISC::CSmartPtr<ITexture> _Texture2;
    NLMISC::CSmartPtr<ITexture> _AlternateTexture2;

    NLMISC::CVector2f _TexScroll[2];
    NLMISC::CVector2f _TexScrollAlternate[2];

    enum TMultiTexState {  TouchFlag = 0x01, MultiTextureEnabled = 0x02, AlternateTextureEnabled = 0x04, AlternateTextureUsed = 0x08, EnvBumpMapUsed = 0x10, BasicCapsForced = 0x20,
                            ScrollUseLocalDate = 0x40, ScrollUseLocalDateAlternate = 0x80
                        };
    uint8   _MultiTexState;

    bool    isAlternateTextureUsed(IDriver &driver) const;
    bool    isEnvBumpMapUsed() const { return (_MultiTexState & EnvBumpMapUsed) != 0; }


    // update wrap mode for all textures
    virtual void updateTexWrapMode(IDriver &drv) = 0;
    void touch()        { _MultiTexState |= (uint8) TouchFlag; }
    void unTouch()      { _MultiTexState &= ~ (uint8) TouchFlag; }
    bool isTouched()    const { return (_MultiTexState & TouchFlag) != 0; }
    bool areBasicCapsForcedLocal() const { return (_MultiTexState & BasicCapsForced) != 0; }
    void forceBasicCapsLocal(bool force)
    {
        if (force) _MultiTexState |= BasicCapsForced;
        else _MultiTexState &= ~BasicCapsForced;
    }
    float       _BumpFactor;
    static bool _ForceBasicCaps;
};



class CPSRotated3DPlaneParticle
{
    public:

        void setPlaneBasisScheme(CPSAttribMaker<CPlaneBasis> *basisMaker);


        CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) { return _PlaneBasisScheme; }

        const CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) const { return _PlaneBasisScheme; }

        void setPlaneBasis(const CPlaneBasis &basis);

        CPlaneBasis getPlaneBasis(void) const { return _PlaneBasis; }

        CPSRotated3DPlaneParticle();

        virtual ~CPSRotated3DPlaneParticle();

        void serialPlaneBasisScheme(NLMISC::IStream &f) throw(NLMISC::EStream);

    protected:

        virtual CPSLocated *getPlaneBasisOwner(void) = 0;

        CPSAttribMaker<CPlaneBasis> *_PlaneBasisScheme;

        CPlaneBasis _PlaneBasis; // constant basis..

        void newPlaneBasisElement(const CPSEmitterInfo &info)
        {
            if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->newElement(info);
        }
        void deletePlaneBasisElement(uint32 index)
        {
            if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->deleteElement(index);
        }
        void resizePlaneBasis(uint32 size)
        {
            nlassert(size < (1 << 16));
            if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->resize(size, getPlaneBasisOwner()->getSize());
        }
};


struct CPSHintParticleRotateTheSame
{
    virtual ~CPSHintParticleRotateTheSame() {}

    virtual void hintRotateTheSame(uint32 nbConfiguration
                            , float minAngularVelocity = NLMISC::Pi
                            , float maxAngularVelocity = NLMISC::Pi
                          ) = 0;

    virtual void disableHintRotateTheSame(void) = 0;


    virtual uint32 checkHintRotateTheSame(float &minAngularVelocity, float &maxAngularVelocity) const = 0;
};


struct CPSTailParticle
{
    virtual ~CPSTailParticle() {}

    virtual void setColorFading(bool onOff = true) = 0;

    virtual bool getColorFading(void) const = 0;


    virtual void setTailNbSeg(uint32 nbSeg) = 0;

    // get the number of segments in the tail
    virtual uint32 getTailNbSeg(void) const = 0;


};


struct CPSShapeParticle
{
    virtual ~CPSShapeParticle() {}

    virtual void setShape(const std::string &shape) = 0;

    virtual std::string getShape(void) const = 0;
};


class CPSMaterial
{
public:
    CPSMaterial();

    enum TBlendingMode { add, modulate, alphaBlend, alphaTest };

    void serialMaterial(NLMISC::IStream &f) throw(NLMISC::EStream);

    void setBlendingMode(CPSMaterial::TBlendingMode mode);

    CPSMaterial::TBlendingMode getBlendingMode(void) const;


    void forceModulateConstantColor(bool force, const NLMISC::CRGBA &col = NLMISC::CRGBA::White);

    void forceTexturedMaterialStages(uint numStages);

    // enable / disable z-test (default is enabled)
    void enableZTest(bool enabled);
    // test if z test is enabled
    bool isZTestEnabled() const;

    // set z-bias
    void setZBias(float value) { _Mat.setZBias(value); }
    float getZBias() const { return _Mat.getZBias(); }



protected:
    CMaterial _Mat;
};


//==========================================================================
inline void SetupModulatedStage(CMaterial &m, uint stage, CMaterial::TTexSource src1, CMaterial::TTexSource src2)
{
    m.texEnvOpRGB(stage, CMaterial::Modulate);
    m.texEnvOpAlpha(stage, CMaterial::Modulate);
    m.texEnvArg0RGB(stage, src1, CMaterial::SrcColor);
    m.texEnvArg1RGB(stage, src2, CMaterial::SrcColor);
    m.texEnvArg0Alpha(stage, src1, CMaterial::SrcAlpha);
    m.texEnvArg1Alpha(stage, src2, CMaterial::SrcAlpha);
}




} // NL3D


#endif // NL_PS_PARTICLE_BASIC_H

/* End of ps_particle_basic.h */