Explosion.cpp

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.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Entity/Explosion.h>
#include <PVLE/3D/Commons.h>
#include <PVLE/Util/Math.h>
#include <PVLE/Physics/Utility.h>
#include <PVLE/Physics/Contact.h>
#include <PVLE/Physics/Body.h>
//#include <PVLE/Physics/World.h>
#include <PVLE/Game/PVLEGame.h>
#include <algorithm>

#include <osg/CullFace>
#include <osg/BlendFunc>
#include <osg/Billboard>
#include <osg/Geode>
#include <osg/ShapeDrawable>
#include <osg/Material>
#include <osg/ImageSequence>
#include <osg/Texture2D>
#include <osg/Depth>

#include <osg/LightSource>
#include <PVLE/Util/DebugGlobals.h>

#include <limits.h>

ExplosionParams::ExplosionParams()
    : renderMode(RENDER_BILLBOARD_DEPTH_ALWAYS), 
    maxRadius(1), growingSpeed(1),
    maxForce(0),
    colorAttenuationPow(1.5f),
    //quadraticForceAttenuation(?), linearForceAttenuation(?),
    //createAnimation(true),
    diffuseColor(1,.9f,.3f,.75f), emissionColor(.8f,.4f,0,1),
    spriteEmission(.9f, .9f, .9f, 1),
    lightDiffuse(1,.8f,0,1),
    lightLinearAttenuation(.003f),
    lightNumber(7), pLSM(NULL), lightBasePriority(1), pLightStateSet(NULL)
{
}


Explosion::Explosion(bool createAnimation, const C3DPhy * pInheritTeamAndPlayer) :
    C3DPhy(pInheritTeamAndPlayer),
    radius(0),
    pSpriteIS(NULL), pSphere(NULL), pLight(NULL),
    spriteTime(0)
{
    init(createAnimation);
}


Explosion::Explosion(const ExplosionParams & params, bool createAnimation, const C3DPhy * pInheritTeamAndPlayer) :
    ExplosionParams(params),
    C3DPhy(pInheritTeamAndPlayer),
    radius(0),
    pSpriteIS(NULL), pSphere(NULL), pLight(NULL),
    spriteTime(0)
{
    init(createAnimation);
}


void Explosion::init(bool createAnimation) {
    ASSERT(maxRadius>0);
    std::fill(vParams, vParams+WeaponEnergy::MAX_WEAPON_ENERGY, 0.f);

    // Physics
    if (maxForce>0) {
        Physics::Geom * pGeom = Physics::createCanonicalSphereGeom(radius);
        addGeom(pGeom);
    }
//growingSpeed/=3;      // DEBUG

    // 3D - Root
    setModel(new osg::MatrixTransform);

    // 3D - Sphere
    {
        pSphere = createShapeGeodeSphere(maxRadius);        // Cannot put radius==0 or it won't be created
        pModel->addChild(pSphere);
        osg::StateSet * pStateSet = pSphere->getOrCreateStateSet();

        //pStateSet->setAttributeAndModes(new osg::CullFace(osg::CullFace::FRONT_AND_BACK), osg::StateAttribute::OFF);          // No cull-face (Sukender: Doesn't seem to work with my laptop's GL driver... Strange thing!)
        pStateSet->setAttributeAndModes(new osg::CullFace(osg::CullFace::FRONT), osg::StateAttribute::OFF);         // No cull-face
        pStateSet->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK), osg::StateAttribute::OFF);          // No cull-face

        pStateSet->setAttributeAndModes(new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA));    // Alpha
        pStateSet->setAttributeAndModes(new osg::Depth(osg::Depth::LEQUAL, 0, 1, false));                                       // Draw "Less or equal" (in case 3D and geoms are the same)
        pStateSet->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);                                                            // Draw back to front
        //pStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);                                                                // No lighting
        boost::polymorphic_downcast<osg::Geode *>(pSphere->getChild(0))->getDrawable(0)->setUseDisplayList(false);

        osg::Material * pMaterial = new osg::Material();
        pMaterial->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4f(0,0,0,0));
        //pMaterial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4f(0,0,0,0));
        pStateSet->setAttributeAndModes(pMaterial);
    }

    // 3D - Sprite
    if (createAnimation) {
        pSpriteIS = new osg::ImageSequence;
        pSpriteIS->setLength(growingSpeed>0 ? maxRadius / growingSpeed : 1);
        //pSpriteIS->setMode(osg::ImageSequence::PAGE_AND_DISCARD_USED_IMAGES);     // OSG's cache will do the rest :)
        pSpriteIS->setMode(osg::ImageSequence::PRE_LOAD_ALL_IMAGES);        // Doesn't seem to work with PAGE_AND_DISCARD_USED_IMAGES
        //pSpriteIS->setLoopingMode(osg::ImageStream::NO_LOOPING);          // Texture is not shown with this ! (OSG 2.7.1)
        pSpriteIS->play();      // Default behaviour is to play something

        osg::Texture2D* pTexture = new osg::Texture2D;
        pTexture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
        pTexture->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);
        pTexture->setWrap(osg::Texture::WRAP_S,osg::Texture::CLAMP);
        pTexture->setWrap(osg::Texture::WRAP_T,osg::Texture::CLAMP);
        //pTexture->setResizeNonPowerOfTwoHint(false);
        pTexture->setImage(pSpriteIS);

        osg::Geode * pSprite = NULL;
        if (renderMode == RENDER_SPRITE) pSprite = new osg::Geode;
        else {
            osg::Billboard * billboard = new osg::Billboard;
            billboard->setMode(osg::Billboard::POINT_ROT_EYE);
            pSprite = billboard;
        }

        pModel->addChild(pSprite);
        float spriteSize = maxRadius * 1.4f;
        pSprite->addDrawable(osg::createTexturedQuadGeometry(osg::Vec3(spriteSize/2,0,-spriteSize/2), osg::Vec3(-spriteSize,0,0), osg::Vec3(0,0,spriteSize)));
        osg::StateSet * pStateSet = pSprite->getOrCreateStateSet();
        pStateSet->setTextureAttributeAndModes(0,pTexture,osg::StateAttribute::ON);

        pStateSet->setAttributeAndModes(new osg::CullFace(osg::CullFace::FRONT_AND_BACK), osg::StateAttribute::OFF);            // No cull-face
        pStateSet->setAttributeAndModes(new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE));                    // Alpha (additive)
        if (renderMode == RENDER_BILLBOARD_DEPTH_ALWAYS) {
            pStateSet->setAttributeAndModes(new osg::Depth(osg::Depth::ALWAYS, 0, 1, false));                                   // No depth test
        } else {
            pStateSet->setAttributeAndModes(new osg::Depth(osg::Depth::LEQUAL, 0, 1, false));                                   // Draw "Less or equal"
        }
        pStateSet->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);                                                            // Draw back to front
        //pStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);                                                                // No lighting

        osg::Material * pMaterial = new osg::Material();
        pMaterial->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4f(0,0,0,spriteEmission.w()));
        //pMaterial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(color.x()/2.f, color.y()/2.f, color.z()/2.f, color.w()));
        pMaterial->setEmission(osg::Material::FRONT_AND_BACK, spriteEmission);
        //pMaterial->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
        pStateSet->setAttributeAndModes(pMaterial);

        //osg::Material * pMaterial = new osg::Material();
        //pMaterial->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4f(1,1,1,1));
        //pStateSet->setAttributeAndModes(pMaterial);
    }

    // 3D - Light
    if (pLightStateSet) {
        if (pLSM) lightNumber = pLSM->request(this, lightBasePriority, new LSCallback(), true);
        if (lightNumber != UINT_MAX) createLight(lightNumber);
    }

    bind();
}


void Explosion::createLight(UINT lightNumber) {
    ASSERT(pLightStateSet);
    ASSERT(lightNumber != UINT_MAX);

    pLight = new osg::LightSource;
    pModel->addChild(pLight);
    osg::Light * pLightParams = new osg::Light;
    pLightParams->setAmbient(osg::Vec4());
    pLightParams->setDiffuse(lightDiffuse);
    pLightParams->setSpecular(lightDiffuse);
    pLightParams->setPosition(osg::Vec4f(0,0,0,1));
    pLightParams->setLinearAttenuation(lightLinearAttenuation);
    //pLightParams->setQuadraticAttenuation(.0002f);
    pLightParams->setLightNum(lightNumber);
    pLight->setLight(pLightParams);

    pLight->setStateSetModes(*pLightStateSet, osg::StateAttribute::ON);     // Illuminate the root node
    //pLight->setLocalStateSetModes(osg::StateAttribute::OFF);
    //pLight->setLocalStateSetModes(osg::StateAttribute::ON);
}


Explosion::~Explosion() {
    if (pLightStateSet && pLight) {
        pLight->setStateSetModes(*pLightStateSet, osg::StateAttribute::OFF);        // No problem here since we handle light manager's onSourceTaken()
    }
    if (pLSM) pLSM->remove(this);

    // TODO Destroy sound if it has ended, or else ensure it will be when necessary.
}



void Explosion::step(dReal stepSize) {
    spriteTime += stepSize;
    if (growingSpeed<=0) radius = maxRadius;
    else {
        radius += growingSpeed * stepSize;
        if (radius >= maxRadius) {
            // Explosion has ended.
            radius = maxRadius;
            //if (pSpriteIS && pSpriteIS->getStatus() != osg::ImageStream::PLAYING)
            //if (pSpriteIS && spriteTime >= pSpriteIS->getLength() * pSpriteIS->getTimeMultiplier())
            if (pSpriteIS && spriteTime >= pSpriteIS->getLength() * pSpriteIS->getTimeMultiplier() * .97)       // There is an error margin because NO_LOOP doesn't work
                onTTLZero();        // Destroy only if animation has ended.
        }
    }

    // Update physics
    if (maxForce>0) {
        ASSERT(!vGeoms.empty());
        boost::polymorphic_downcast<Physics::SphereHandler *>( vGeoms[0]->getHandler() )->setRadius(radius);
    }

    // Update 3D
    osg::Geode * pGeode = boost::polymorphic_downcast<osg::Geode *>(pSphere->getChild(0));
    boost::polymorphic_downcast<osg::Sphere *>(pGeode->getDrawable(0)->getShape())->setRadius(radius);
    //pGeode->dirtyBound();

    ASSERT(maxRadius>0 && radius>=0);
    float growth = radius / maxRadius;
    float attenuation = 1 - powf(growth, colorAttenuationPow);
    clamp(attenuation, 0.f, 1.f);

    //setColor(pSphere, osg::Vec4(color.x(), color.y(), color.z(), color.w() * attenuation));
    //boost::polymorphic_downcast<osg::ShapeDrawable *>(pGeode->getDrawable(0))->setColor(osg::Vec4(color.x(), color.y(), color.z(), color.w() * attenuation));

    osg::StateSet * pStateSet = pSphere->getOrCreateStateSet();
    osg::Material * pMaterial = boost::polymorphic_downcast<osg::Material *>(pStateSet->getAttribute(osg::StateAttribute::MATERIAL));
    ASSERT(pMaterial);
    // Warning! Only the diffuse alpha is taken into account when displaying.
    pMaterial->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4(diffuseColor.x(), diffuseColor.y(), diffuseColor.z(), diffuseColor.w() * attenuation));
    //pMaterial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(1,0,0,1));
    pMaterial->setEmission(osg::Material::FRONT_AND_BACK, osg::Vec4(emissionColor.x(), emissionColor.y(), emissionColor.z(), emissionColor.w() * attenuation));
    pStateSet->setAttributeAndModes(pMaterial);

    if (pLightStateSet && pLight) {
        osg::Light * pLightParams = pLight->getLight();
        //pLightParams->setAmbient(osg::Vec4());
        pLightParams->setDiffuse(lightDiffuse * attenuation);
        //pLightParams->setDiffuse(osg::Vec4(lightDiffuse.x(), lightDiffuse.y(), lightDiffuse.z(), lightDiffuse.w() * attenuation));
        pLightParams->setSpecular(lightDiffuse * attenuation);
    }
    if (pLSM) {
        pLSM->updatePriority(this, static_cast<LightSourceManager::Priority>(lightBasePriority * attenuation));
    }

    // No call to C3DPhy::step() here
}

bool Explosion::hitBefore(Physics::Contact * pContacts, unsigned int nbContacts, Physics::Contact * pMaxEnergyContact, Physics::Geom & thisGeom, Physics::Geom & otherGeom, Physics::Body *& inout_pThisBody, Physics::Body *& inout_pOtherBody) {
    ASSERT(maxForce>0);     // Or else no physics comutations is needed.
    if (radius == maxRadius) return false;

    //C3DPhy::hitBefore();
    ASSERT(&thisGeom == vGeoms[0]);
    if (inout_pOtherBody) {
        const osg::Vec3f & contactPos = pMaxEnergyContact->getPos();
        osg::Vec3 force(contactPos - dGeomGetPositionV(thisGeom));
        float len = force.length();
        if (len > 0) {
            ASSERT(maxRadius>0 && radius>=0);
            float growth = radius / maxRadius;
            //float attenuation = 1 - powf(growth, forceAttenuationPow);
            float attenuation = 1 - growth*growth;
            clamp(attenuation, 0.f, 1.f);
            force *= maxForce * attenuation / len;

            dBodyEnable(*inout_pOtherBody);
            dBodyAddForceAtPos(*inout_pOtherBody, force, contactPos);
        }
    }

    C3DPhy * pOther3DPhy = NULL;
    IGeomCollisionContainer * pContainer = otherGeom.getCollisionContainer();
    if (pContainer) pOther3DPhy = pContainer->as3DPhy();

    // Test for friendly fire
    float friendlyFireCoef = 1;
    if (pTeam && pTeam == pOther3DPhy->getTeam()) {
        // Transfer energies with a coefficient, which is a Game parameter.
        // Note that cinetic energy is not multiplied by a coef (Or it would be done on every collision).
        friendlyFireCoef = PVLEGameHolder::instance().get()->getFriendlyFire();
    }

    if (friendlyFireCoef>0) {
        // Transfer all energies
        ASSERT(maxRadius>0 && radius>=0);
        float growth = radius / maxRadius;
        float attenuation = 1 - powf(growth, colorAttenuationPow);
        clamp(attenuation, 0.f, 1.f);
        ASSERT(vParams[WeaponEnergy::PERFORANT] == 0);
        for(int it=0; it!=WeaponEnergy::MAX_WEAPON_ENERGY; ++it) {
            pOther3DPhy->isHitBy(static_cast<WeaponEnergy::EEneryType>(it), vParams[it] * attenuation * friendlyFireCoef, pMaxEnergyContact->getPos());
        }
    }

    return false;
}


bool Explosion::LSCallback::onSourceTaken(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber) {
    Explosion & exp = *boost::polymorphic_cast<Explosion*>(pUserObject);        // Workaround - Cannot use polymorphic_downcast here
    if (exp.pLightStateSet && exp.pLight) {
        ASSERT(exp.pLight->getLight()->getLightNum() == lightNumber);
        exp.pLight->setStateSetModes(*exp.pLightStateSet, osg::StateAttribute::OFF);
        exp.pLight = NULL;
    }

    if (_nestedCallback.valid()) return _nestedCallback->onSourceTaken(pLightSourceManager, pUserObject, lightNumber);
    else return true;
}


bool Explosion::LSCallback::onSourceAvailable(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject, UINT lightNumber) {
    if (_nestedCallback.valid()) return _nestedCallback->onSourceAvailable(pLightSourceManager, pUserObject, lightNumber);

    Explosion & exp = *boost::polymorphic_cast<Explosion*>(pUserObject);        // Workaround - Cannot use polymorphic_downcast here
    exp.createLight(lightNumber);
    return true;
}

void Explosion::LSCallback::onUserDropped(LightSourceManager * pLightSourceManager, osg::Referenced * pUserObject) {
    Explosion & exp = *boost::polymorphic_cast<Explosion*>(pUserObject);        // Workaround - Cannot use polymorphic_downcast here
    exp.pLSM = NULL;
}

---