StelRendererStatistics.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * 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 2
 * of the License, or (at your option) any later version.
 *
 * 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, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELRENDERERSTATISTICS_HPP_
#define _STELRENDERERSTATISTICS_HPP_


enum StatisticSwapMode
{
    StatisticSwapMode_SetToZero,
    StatisticSwapMode_DoNothing
};

class StelRendererStatistics
{
friend class StelQGLRenderer;
public:
    StelRendererStatistics()
        : iterationIndex(0)
        , statisticCount(0)
    {
        memset(statistics,         '\0', MAX_STATISTICS * sizeof(double));
        memset(previousStatistics, '\0', MAX_STATISTICS * sizeof(double));
        memset(statisticNames,     '\0', MAX_STATISTICS * sizeof(const char*));
        memset(swapModes,          '\0', MAX_STATISTICS * sizeof(StatisticSwapMode));
    }

    bool getNext(const char*& name, double& value)
    {
        Q_ASSERT_X(iterationIndex <= statisticCount, Q_FUNC_INFO,
                   "Statistics iteration index out of bounds");
        if(iterationIndex == statisticCount)
        {
            return false;
        }

        name  = statisticNames[iterationIndex];
        value = previousStatistics[iterationIndex];
        ++iterationIndex;

        return true;
    }

    void resetIteration()
    {
        iterationIndex = 0;
    }

    double& operator [] (int index)
    {
        Q_ASSERT_X(index >= 0 && index < statisticCount, Q_FUNC_INFO,
                   "Index of a statistic out of range");
        return statistics[index];
    }

    int addStatistic
        (const char* name, const StatisticSwapMode swapMode = StatisticSwapMode_DoNothing)
    {
        Q_ASSERT_X(statisticCount < MAX_STATISTICS, Q_FUNC_INFO,
                   "Can't add any more statistics (at most 48 are supported)");
        swapModes[statisticCount]    = swapMode;
        statisticNames[statisticCount] = name;
        ++statisticCount;
        return statisticCount - 1;
    }

    void swap()
    {
        memcpy(previousStatistics, statistics, MAX_STATISTICS * sizeof(double));
        for(int s = 0; s < statisticCount; ++s)
        {
            if(swapModes[s] == StatisticSwapMode_SetToZero)
            {
                statistics[s] = 0.0f;
            }
            else if(swapModes[s] != StatisticSwapMode_DoNothing)
            {
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown statistic swap mode");
            }
        }
    }

private:
    int iterationIndex;

    static const int MAX_STATISTICS = 40;

    double statistics[MAX_STATISTICS];

    double previousStatistics[MAX_STATISTICS];

    const char* statisticNames[MAX_STATISTICS];

    StatisticSwapMode swapModes[MAX_STATISTICS];

    int statisticCount;
};

#endif // _STELRENDERERSTATISTICS_HPP_