fps.h

Go to the documentation of this file.

/* MAINTAINER: Martin */

#ifndef _FPS_H
#define _FPS_H

// TODO: implement better algorithm for fps computing
class Fps
{
public:
        void init(unsigned int atime)
        { 
                mFps = 0.0f; mFrameStamp = mFramesRendered = 0;
                mTimeStamp = atime;
                mUpdateTimeTreshold = DEFAULT_FPS_UPDATE_THRESHOLD;
        }

        void onFrameRendered(void)
        { ++mFramesRendered; }

        bool update(unsigned int atime)
        {
                // overflow check
                if (atime < mTimeStamp){
                        // skip one period
                        mFrameStamp = mFramesRendered;
                        mTimeStamp = atime;
                        return false;
                }

                atime -= mTimeStamp; // delta-time
        
                if (atime >= getTreshold())
                {
                        // if fps overflew, return old fps count
                        if (mFramesRendered >= mFrameStamp)
                                mFps = float(1000 * (mFramesRendered - mFrameStamp)) / atime;
                        mFrameStamp = mFramesRendered;
                        mTimeStamp += atime;
                        return true;
                }
                return false;
        }
        
        unsigned int getTreshold(void)
        { return mUpdateTimeTreshold; }

        void setTreshold(unsigned int treshold_ms)
        { mUpdateTimeTreshold = treshold_ms; }

        unsigned int get(void)
        { return (unsigned int)mFps; }

private:
        unsigned int mFramesRendered;           
        unsigned int mTimeStamp;                        
        unsigned int mFrameStamp;                       
        unsigned int mUpdateTimeTreshold;       
        float mFps;                                                     

public:
        static const unsigned int DEFAULT_FPS_UPDATE_THRESHOLD = 100; 
};
/*
class Fps2
{
public:
        Fps2(int bufferSize)
                : mTimeStamps(bufferSize)
        { 
                clear();
        }
        
        void clear()
        {
                mCounter = mTimeStamps.size();  // how many buffer felds to fill
                mIndex = 0;                                             // start at zero index
                mTotal = 0;                                             // set sum of the buffer to zero
                mFps = 0;                                               // reset fps
        }

        void onFrameRendered(unsigned int atime)
        {
                int size = mTimeStamps.size();
                int delta = atime - mTimeStamps[mIndex];        // delta time
                mIndex = (mIndex + 1) % size;                           // shift head to tail
                mTotal += delta;                                                        // add delta to total

                // is the buffer full?
                if (!mCounter)
                        mTotal -= mTimeStamps[mIndex];  // full -> subtract tail from total
                else {
                        if (mCounter == size){ // the first time
                                mTotal -= delta;
                        }
                        --mCounter;
                }
                
                // set new time stamp (removes tail) and compute average fps
                mTimeStamps[mIndex] = atime;
                mFps = (mTotal > 0) ? (size - mCounter) / mTotal : 0; 
                
                mPreviousTime = atime;
        }

        unsigned int get(void)
        { return (unsigned int)mFps; }

private:
        float mFps;                                                     ///< \brief the number of frames per second
        std::vector<unsigned int> mTimeStamps;
        int mIndex, mCounter, mPreviousTime;
        
};
*/

#endif

---