Explosion.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program 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 this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#ifndef ENT_EXPLOSION_H
#define ENT_EXPLOSION_H

#include <PVLE/Export.h>
#include <PVLE/Entity/3DPhy.h>
#include <PVLE/Entity/WeaponEnergy.h>
#include <PVLE/3D/LightSourceManager.h>
#include <osg/Vec4>
//#include <osg/ImageSequence>
namespace osg {
    class Group;
    class Geode;
    class Billboard;
    class ImageSequence;
    class LightSource;
    class StateSet;
}
class LightSourceManager;


class PVLE_EXPORT ExplosionParams {
public:
    ExplosionParams();
    enum ERenderMode {
        RENDER_SPRITE,          
        RENDER_BILLBOARD,       
        RENDER_BILLBOARD_DEPTH_ALWAYS       
    };
    ERenderMode renderMode;

    float maxRadius;                    
    float growingSpeed;                 

    float maxForce;                     
    //float quadraticForceAttenuation;  ///< Quadratc attenuation of the force (attenuation * distance * distance).
    //float linearForceAttenuation;     ///< Linear attenuation of the force (attenuation * distance).

    float colorAttenuationPow;          
    osg::Vec4f diffuseColor;            
    osg::Vec4f emissionColor;           

    osg::Vec4f lightDiffuse;            
    float lightLinearAttenuation;       
    osg::StateSet * pLightStateSet;     
    //float quadraticForceAttenuation;
    //float linearForceAttenuation;

    // Discardable parameters
    UINT lightNumber;                   
    LightSourceManager * pLSM;                          
    LightSourceManager::Priority lightBasePriority;     
    osg::Vec4f spriteEmission;          
    //float spriteSize;                 ///< Animated sprite size, or <=0 to disable sprite creation.
};


class PVLE_EXPORT Explosion : public C3DPhy, protected ExplosionParams {
public:
    virtual EContainerType getType() const { return OTHER; }

    Explosion(bool createAnimation = true, const C3DPhy * pInheritTeamAndPlayer = NULL);

    Explosion(const ExplosionParams & params, bool createAnimation = true, const C3DPhy * pInheritTeamAndPlayer = NULL);

    virtual void step(dReal stepSize);

    inline osg::ImageSequence * getAnimation() { return pSpriteIS; }
    inline const osg::ImageSequence * getAnimation() const { return pSpriteIS; }

    virtual bool hitBefore(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, Physics::Body *& inout_pThisBody, Physics::Body *& inout_pOtherBody);
    //virtual void hitAfter(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, bool contactJointCreated);


    void setParam(WeaponEnergy::EEneryType energyType, float value) { ASSERT(energyType != WeaponEnergy::PERFORANT); vParams[energyType] = value; }
    float getParam(WeaponEnergy::EEneryType energyType) const { return vParams[energyType]; }

protected:
    class LSCallback : public LightSourceUserCallback {
    public:
        virtual bool onSourceTaken(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber);
        virtual bool onSourceAvailable(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber);
        virtual void onUserDropped(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject);
    };
    friend class LSCallback;

    float vParams[WeaponEnergy::MAX_WEAPON_ENERGY];     // Protected because we disallow WeaponEnergy::PERFORANT.

    float radius;           

    osg::Group * pSphere;               
    //osg::Geode * pSprite;             ///< Animated sprite, or NULL.
    osg::ImageSequence * pSpriteIS;     
    float spriteTime;
    osg::LightSource * pLight;

    virtual ~Explosion();

    void init(bool createAnimation = true);
    void createLight(UINT lightNumber);
};


#endif  // ENT_EXPLOSION_H

---