FrameClock.h

////////////////////////////////////////////////////////////
//
// FrameClock - Utility class for tracking frame statistics.
// Copyright (C) 2013 Lee R (lee-r@outlook.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////

#ifndef FRAMECLOCK_H_INCLUDED
#define FRAMECLOCK_H_INCLUDED

#include <limits>
#include <cassert>
#include <algorithm>

#include <SFML/System/Time.hpp>
#include <SFML/System/Clock.hpp>

namespace sfx
{
    namespace detail
    {
        // Utility function to disambiguate from macro 'max'.
        template<typename T>
        inline T limit()
        {
            return (std::numeric_limits<T>::max)();
        }
    }	// namespace detail

    class FrameClock
    {
    public:

        // Constructs a FrameClock object with sample depth 'depth'.
        explicit FrameClock(std::size_t depth = 100)
        {
            assert(depth >= 1);
            m_sample.data.resize(depth);

            m_freq.minimum = detail::limit<float>();
            m_time.minimum = sf::microseconds(detail::limit<sf::Int64>());
        }

        // Resets all times to zero and discards accumulated samples.
        void clear()
        {
            FrameClock(getSampleDepth()).swap(*this);
        }

        // Begin frame timing.
        // Should be called once at the start of each new frame.
        void beginFrame()
        {
            m_clock.restart();
        }

        // End frame timing.
        // Should be called once at the end of each frame.
        // Returns: Time elapsed since the matching FrameClock::beginFrame.
        sf::Time endFrame()
        {
            m_time.current = m_clock.getElapsedTime();

            m_sample.accumulator -= m_sample.data[m_sample.index];
            m_sample.data[m_sample.index] = m_time.current;

            m_sample.accumulator += m_time.current;
            m_time.elapsed       += m_time.current;

            if (++m_sample.index >= getSampleDepth())
            {
                m_sample.index = 0;
            }

            if (m_time.current != sf::microseconds(0))
            {
                m_freq.current = 1.0f / m_time.current.asSeconds();
            }

            if (m_sample.accumulator != sf::microseconds(0))
            {
                const float smooth = static_cast<float>(getSampleDepth());
                m_freq.average = smooth / m_sample.accumulator.asSeconds();
            }

            const sf::Int64 smooth = static_cast<sf::Int64>(getSampleDepth());
            m_time.average = sf::microseconds(m_sample.accumulator.asMicroseconds() / smooth);

            if (m_freq.current < m_freq.minimum)
                m_freq.minimum = m_freq.current;
            if (m_freq.current > m_freq.maximum)
                m_freq.maximum = m_freq.current;

            if (m_time.current < m_time.minimum)
                m_time.minimum = m_time.current;
            if (m_time.current > m_time.maximum)
                m_time.maximum = m_time.current;

            ++m_freq.elapsed;

            return m_time.current;
        }

        // Sets the number of frames to be sampled for averaging.
        // 'depth' must be greater than or equal to 1.
        void setSampleDepth(std::size_t depth)
        {
            assert(depth >= 1);
            FrameClock(depth).swap(*this);
        }

        // Returns: The number of frames to be sampled for averaging.
        std::size_t getSampleDepth() const
        {
            return m_sample.data.size();
        }

        // Returns: The total accumulated frame time.
        sf::Time getTotalFrameTime() const
        {
            return m_time.elapsed;
        }

        // Returns: The total accumulated number of frames.
        sf::Uint64 getTotalFrameCount() const
        {
            return m_freq.elapsed;
        }

        // Returns: Time elapsed during the last 'FrameClock::beginFrame/endFrame' pair.
        sf::Time getLastFrameTime() const
        {
            return m_time.current;
        }

        // Returns: The shortest measured frame time.
        sf::Time getMinFrameTime() const
        {
            return m_time.minimum;
        }

        // Returns: The longest measured frame time.
        sf::Time getMaxtFrameTime() const
        {
            return m_time.maximum;
        }

        // Returns: Average frame time over the last getSampleDepth() frames.
        sf::Time getAverageFrameTime() const
        {
            return m_time.average;
        }

        // Returns: Frames per second, considering the pervious frame only.
        float getFramesPerSecond() const
        {
            return m_freq.current;
        }

        // Returns: The lowest measured frames per second.
        float getMinFramesPerSecond() const
        {
            return m_freq.minimum;
        }

        // Returns: The highest measured frames per second.
        float getMaxFramesPerSecond() const
        {
            return m_freq.maximum;
        }

        // Returns: Average frames per second over the last getSampleDepth() frames.
        float getAverageFramesPerSecond() const
        {
            return m_freq.average;
        }

        // Swaps the value of this FrameClock instance with 'other'.
        void swap(FrameClock& other)
        {
            this->m_time.swap(other.m_time);
            this->m_freq.swap(other.m_freq);
            this->m_sample.swap(other.m_sample);
            std::swap(this->m_clock, other.m_clock);
        }

    private:

        template<typename T, typename U>
        struct Range
        {
            Range()
                : minimum()
                , maximum()
                , average()
                , current()
                , elapsed()
            {}
            void swap(Range& other)
            {
                std::swap(this->minimum, other.minimum);
                std::swap(this->maximum, other.maximum);
                std::swap(this->average, other.average);
                std::swap(this->current, other.current);
                std::swap(this->elapsed, other.elapsed);
            }
            T minimum;
            T maximum;
            T average;
            T current;
            U elapsed;
        };

        Range<sf::Time, sf::Time> m_time;
        Range<float, sf::Uint64>  m_freq;

        struct SampleData
        {
            SampleData()
                : accumulator()
                , data()
                , index()
            {}
            sf::Time accumulator;
            std::vector<sf::Time> data;
            std::vector<sf::Time>::size_type index;
            void swap(SampleData& other)
            {
                std::swap(this->accumulator, other.accumulator);
                std::swap(this->data,        other.data);
                std::swap(this->index,       other.index);
            }
        } m_sample;

        sf::Clock m_clock;
    };
}	// namespace sfx

#endif	// FRAMECLOCK_H_INCLUDED