Simulation.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 GAME_SIMULATION_H
#define GAME_SIMULATION_H

#include <PVLE/Export.h>
#include <PVLE/Util/Assert.h>
#include <PVLE/Util/Callback.h>
#include <PVLE/Util/Util.h>
#include <osg/observer_ptr>

class Simulation;


class PVLE_EXPORT SimulationCallback : public Util::Callback<SimulationCallback> {
public:
    virtual void simulationChanged(Simulation *) =0;
};



class PVLE_EXPORT Simulation {
public:
    Simulation();
    ~Simulation();      // No need to be virtual

    //inline void setBasePhyFreq(UINT freq) {
    //  ASSERT(freq>0);
    //  basePhyFreq = freq;
    //  basePhyStep = 1./freq;
    //}
    //inline UINT getBasePhyFreq() const { return basePhyFreq; }

    // Sets the base step size, that is to say the size (in seconds) of the steps without any modifier.
    inline void setBasePhyStep(double step) {
        ASSERT(step>0);
        //basePhyFreq = static_cast<UINT>(1/step);
        //ASSERT(basePhyFreq>0);
        basePhyStep = step;
        if (pCB.valid()) pCB->simulationChanged(this);
    }
    // Returns the base step size, that is to say the size (in seconds) of the steps without any modifier.
    inline UINT getBasePhyStep() const { return basePhyStep; }

    inline double getCurPhyStep() const { return basePhyStep * phySpeedStep; }
    inline double getCurPhyNbStepsPerSec() const { return phySpeedNum / basePhyStep; }

    inline double getPhySpeedNum() const { return phySpeedNum; }
    inline void setPhySpeedNum(double factor) {
        if (factor<=0) {
            pause(true);
            return;
        }
        phySpeedNum = factor;
        if (pCB.valid()) pCB->simulationChanged(this);
    }

    inline double getPhySpeedStep() const { return phySpeedStep; }
    inline void setPhySpeedStep(double factor) {
        if (factor<=0) {
            pause(true);
            return;
        }
        phySpeedStep = factor;
        if (pCB.valid()) pCB->simulationChanged(this);
    }

    //static const double MAX_DELTA_S_PHYSICS;

    //static const double DEFAULT_SIM_DURATION = .05;       // Default time during which nothing is rendered in "simulation" mode

    //enum EComputeMode {
    //  REAL_TIME,      ///< Mode where computations are done for real-time rendering.
    //  COMPUTE         ///< Mode where computations are done as fast as possible.
    //};
    //EComputeMode mode;

    inline bool isPaused() const { return paused; }
    inline void pause(bool set = true) { paused = set;     if (pCB.valid()) pCB->simulationChanged(this); }
    inline void togglePause()          { paused = !paused; if (pCB.valid()) pCB->simulationChanged(this); }

    osg::observer_ptr<SimulationCallback> pCB;

    void addOrSetCallback(SimulationCallback * _pCB) {
        if (pCB.valid()) pCB->addNestedCallback(_pCB);
        else pCB = _pCB;
    }

protected:
    //UINT basePhyFreq;     ///< Physics base frequency (Hz) - Defines the step size (Can be altered by phySpeedStep)
    double basePhyStep;     
    double phySpeedNum;
    double phySpeedStep;
    bool paused;
};




#include <PVLE/Util/Singleton.h>
#include <boost/cast.hpp>

class /*PVLE_EXPORT*/ SimulationHolder : public Util::Singleton<SimulationHolder> {
public:
    Simulation * get() { return pObj; }

    template<class T>
    T * get() { return boost::polymorphic_downcast<T *>(pObj); }

    void set(Simulation * pObj) { this->pObj = pObj; }

protected:
    Simulation * pObj;
};


#endif  // GAME_SIMULATION_H

---