149 lines
6.3 KiB
C++
149 lines
6.3 KiB
C++
/****************************************************************************
|
|
* Copyright (C) 2009 Daniel Chappuis *
|
|
****************************************************************************
|
|
* This file is part of ReactPhysics3D. *
|
|
* *
|
|
* ReactPhysics3D is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Lesser General Public License as published *
|
|
* by the Free Software Foundation, either version 3 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* ReactPhysics3D 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 Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public License *
|
|
* along with ReactPhysics3D. If not, see <http://www.gnu.org/licenses/>. *
|
|
***************************************************************************/
|
|
|
|
#ifndef TIMER_H
|
|
#define TIMER_H
|
|
|
|
// Libraries
|
|
#include "../physics/physics.h"
|
|
#include <stdexcept>
|
|
#include <iostream>
|
|
|
|
// Namespace ReactPhysics3D
|
|
namespace reactphysics3d {
|
|
|
|
// TODO : Now we are using the "Time" class in this class but we should a
|
|
// time class from the standard library
|
|
|
|
/* -------------------------------------------------------------------
|
|
Class Timer :
|
|
This class will take care of the time in the physics engine.
|
|
-------------------------------------------------------------------
|
|
*/
|
|
class Timer {
|
|
private :
|
|
Time timeStep; // Timestep dt of the physics engine (timestep > 0.0)
|
|
Time time; // Current time of the physics engine
|
|
Time currentDisplayTime; // Current display time
|
|
Time deltaDisplayTime; // Current time difference between two display frames
|
|
double accumulator; // Used to fix the time step and avoid strange time effects
|
|
bool isRunning; // True if the timer is running
|
|
|
|
public :
|
|
Timer(const Time& initialTime, const Time& timeStep) throw(std::invalid_argument); // Constructor
|
|
Timer(const Timer& timer); // Copy-constructor
|
|
virtual ~Timer(); // Destructor
|
|
|
|
Time getTimeStep() const; // Return the timestep of the physics engine
|
|
void setTimeStep(const Time& timeStep) throw(std::invalid_argument); // Set the timestep of the physics engine
|
|
Time getTime() const; // Return the current time
|
|
void setTime(const Time& time); // Set the current time
|
|
bool getIsRunning() const; // Return if the timer is running
|
|
void setIsRunning(bool isRunning); // Set if the timer is running
|
|
double getAccumulator() const; // Return the accumulator value
|
|
void setCurrentDisplayTime(const Time& displayTime); // Set the current display time
|
|
|
|
void update(); // Update the timer by adding some time value (or timeStep by default) to the current time
|
|
double getInterpolationFactor() const; // Compute and return the interpolation factor between two body states
|
|
void updateDisplayTime(const Time& newDisplayTime); // Set the new currentDisplayTime value
|
|
};
|
|
|
|
// --- Inline functions --- //
|
|
|
|
// Return the timestep of the physics engine
|
|
inline Time Timer::getTimeStep() const {
|
|
return timeStep;
|
|
}
|
|
|
|
// Set the timestep of the physics engine
|
|
inline void Timer::setTimeStep(const Time& timeStep) throw(std::invalid_argument) {
|
|
// Check if the timestep is different from zero
|
|
if (timeStep.getValue() != 0.0) {
|
|
this->timeStep = timeStep;
|
|
}
|
|
else {
|
|
// We throw an exception
|
|
throw std::invalid_argument("Exception in Timer : the timestep has to be different from zero");
|
|
}
|
|
}
|
|
|
|
// Return the current time
|
|
inline Time Timer::getTime() const {
|
|
return time;
|
|
}
|
|
|
|
// Set the current time
|
|
inline void Timer::setTime(const Time& time) {
|
|
this->time = time;
|
|
}
|
|
|
|
// Return if the timer is running
|
|
inline bool Timer::getIsRunning() const {
|
|
return isRunning;
|
|
}
|
|
|
|
// Set if the timer is running
|
|
inline void Timer::setIsRunning(bool isRunning) {
|
|
this->isRunning = isRunning;
|
|
}
|
|
|
|
// Return the accumulator value
|
|
inline double Timer::getAccumulator() const {
|
|
return accumulator;
|
|
}
|
|
|
|
// Set the current display time
|
|
inline void Timer::setCurrentDisplayTime(const Time& currentDisplayTime) {
|
|
this->currentDisplayTime = currentDisplayTime;
|
|
}
|
|
|
|
// Update the timer by adding the timeStep to the current time
|
|
inline void Timer::update() {
|
|
// Check if the timer is running
|
|
if (isRunning) {
|
|
// Update the current time of the physics engine
|
|
time.setValue(time.getValue() + timeStep.getValue());
|
|
|
|
// Update the accumulator value
|
|
accumulator -= timeStep.getValue();
|
|
}
|
|
}
|
|
|
|
// Compute and return the interpolation factor between two body states
|
|
inline double Timer::getInterpolationFactor() const {
|
|
// Compute and return the interpolation factor
|
|
return (accumulator / timeStep.getValue());
|
|
}
|
|
|
|
// Set the new currentDisplayTime value
|
|
inline void Timer::updateDisplayTime(const Time& newDisplayTime) {
|
|
// Compute the delta display time between two display frames
|
|
deltaDisplayTime.setValue(newDisplayTime.getValue() - currentDisplayTime.getValue());
|
|
|
|
// Update the current display time
|
|
currentDisplayTime.setValue(newDisplayTime.getValue());
|
|
|
|
// Update the accumulator value
|
|
accumulator += deltaDisplayTime.getValue();
|
|
}
|
|
|
|
} // End of the ReactPhysics3D namespace
|
|
|
|
#endif
|