CameraShake.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/3D/CameraShake.h>
#include <PVLE/Util/Math.h>
#include <PVLE/Util/Rand.h>
#include <PVLE/Util/Util.h>
#include <osg/Transform>
#include <osgViewer/View>
#include <osgGA/MatrixManipulator>
#include <boost/cast.hpp>

//#include <boost/integer_traits.hpp>


void CameraShakeParams::setAngles(const osg::Vec3f & dir) {
    float len = dir.length();
    if (len==0) {
        // Default values
        angleTheta = 0;
        anglePhi = 0;
        return;
    }
    angleTheta = atan2(dir.y(), dir.x());
    anglePhi = acos(dir.z() / len);
}

void CameraShakeParams::setAnglesRandom() {
    angleTheta = rand(0, 2*osg::PI);
    anglePhi = rand(0, osg::PI);        // Not 2*PI
}

class CameraShakeUpdateCallback : public osg::NodeCallback {
public:
    CameraShakeUpdateCallback() : time0(-1) {}
    virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) {
        // On update traversal, compute world pos and affect cameras
        // Note: doing it on cull traversal would be a mistake since we should not move the camera, and that culling may remove the effect (if not disabled).
        CameraShake * pCS = boost::polymorphic_downcast<CameraShake *>(node);
        //if (!pCS->ended())
        if (time0<0) time0 = nv->getFrameStamp()->getSimulationTime();
        pCS->curTime = nv->getFrameStamp()->getSimulationTime() - time0;
        pCS->updateCameras( osg::computeWorldToLocal(nv->getNodePath()).getTrans() );
    }
protected:
    double time0;
};


CameraShake::CameraShake() : curTime(0), curNumHalfOscillation(0) {
    addUpdateCallback(new CameraShakeUpdateCallback);
}

CameraShake::CameraShake(const CameraShakeParams & params) : params(params), curTime(0), curNumHalfOscillation(0) {
    addUpdateCallback(new CameraShakeUpdateCallback);
}

CameraShake::CameraShake(const CameraShake & v, const osg::CopyOp& copyop) : params(v.params), curTime(0), curNumHalfOscillation(0) {
    addUpdateCallback(new CameraShakeUpdateCallback);
}

CameraShake::~CameraShake() {
    // Reset cameras if needed.
    BOOST_FOREACH(CameraData & cameraData, vCameras) {
        if (!cameraData.pCamera.valid()) continue;      // Simply ignore deleted cameras (don't remove it since the effect should not last long).
        setCamera(cameraData, osg::Vec3());
    }
}

void CameraShake::updateCameras(const osg::Vec3f & pos) {
    const float baseTimeAmplitude = timedAmplitude();
    const float period = 1/params.frequency;
    const float oscillation = math_fmodf(curTime, period) / period;

    // Update angles
    const float numHalfOscillation = static_cast<UINT>(curTime / period * 2);
    if (curNumHalfOscillation < numHalfOscillation) {
        curNumHalfOscillation = numHalfOscillation;
        params.angleTheta = math_fmodf(params.angleTheta + rand(-params.dispersionTheta, params.dispersionTheta), static_cast<float>(osg::PI*2));
        params.anglePhi   = math_fmodf(params.anglePhi   + rand(-params.dispersionPhi  , params.dispersionPhi  ), static_cast<float>(osg::PI));     // Not 2*PI
    }

    // Update cameras
    BOOST_FOREACH(CameraData & cameraData, vCameras) {
        if (!cameraData.pCamera.valid()) continue;      // Simply ignore deleted cameras (don't remove it since the effect should not last long).
        float curAmplitude = baseTimeAmplitude;
        if (params.distanceModel != CameraShakeParams::DIST_NONE) {
            float distance = (cameraData.pCamera->getViewMatrix().getTrans() - pos).length();
            if (distance > 1) curAmplitude /= params.distanceModel == CameraShakeParams::DIST_LINEAR ? distance : distance*distance;
        }

        float oscillationAmplitude = sin(oscillation * osg::PI*2);
        curAmplitude *= oscillationAmplitude;
        float sinPhi = sin(params.anglePhi);
        osg::Vec3f newOffset(cos(params.angleTheta)*sinPhi*curAmplitude, sin(params.angleTheta)*sinPhi*curAmplitude, cos(params.anglePhi)*curAmplitude);
        //osg::Vec3f newOffset(rand(-curAmplitude*.5f, curAmplitude*.5f), rand(-curAmplitude*.5f, curAmplitude*.5f), rand(-curAmplitude*.5f, curAmplitude*.5f));
        setCamera(cameraData, newOffset);
    }
}

void CameraShake::setCamera(CameraData & cameraData, const osg::Vec3f & newOffset) {
    ASSERT(cameraData.pCamera.valid());
    osg::View * pView = cameraData.pCamera->getView();
    if (pView && pView->getCamera() == cameraData.pCamera.get()) {
        // The current camera is the master camera of a view, so maybe it has a manipulator that drives it.
        osgViewer::View * pView2 = dynamic_cast<osgViewer::View *>(pView);
        if (pView2 && pView2->getCameraManipulator()) {
            osg::Matrix mat = pView2->getCameraManipulator()->getMatrix();
            mat.setTrans(mat.getTrans() + newOffset - cameraData.curOffset);
            pView2->getCameraManipulator()->setByMatrix(mat);
        }
    }
    // TODO Needs to use "-newOffset" ??
    osg::Matrix & mat = cameraData.pCamera->getViewMatrix();
    mat.setTrans(mat.getTrans() + newOffset - cameraData.curOffset);
    cameraData.curOffset = newOffset;
}

---