GUIBenchmark.h

#ifndef __GUIBENCHMARK_H__
#define __GUIBENCHMARK_H__
 
#include "eC_TList_doubleLinked.h"
 
#include "GUI.h"
#include "GUIEvent.h"
#include "GUIInputMedia.h"
#include "GUIComponentManager.h"
//#include "GfxWrap.h"
#include "GUITrace.h"
 
#include "GUIResourceManager.h"
#include "GUIImageResource.h"
 
 
class CGUIBenchmark
{
public:
    CGUIBenchmark(
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& uiStride,
        const eC_UByte& ubBitsPerPixel,
        eC_UByte* pkFramebuffer);
 
    ~CGUIBenchmark();
 
    void Run();
 
    void AddTestImage(const eC_String& kImageName);
 
    void AddTestFont(const eC_String& kFontName);
 
    void SetFontForSummary(const eC_String& kFontName);
 
    void SetSummaryWaitTime(const eC_UInt& uiWaitTime);
 
    void SetNumberOfRuns(const eC_UInt& uiNumberOfRuns) { m_uiNumberOfRuns = uiNumberOfRuns; }
 
    void SetNumberOfPrimitives(const eC_UInt& uiNumberOfPrimitives) { m_uiNumberOfPrimitives = uiNumberOfPrimitives; }
 
    void SetNumberOfTexts(const eC_UInt& uiNumberOfTexts) { m_uiNumberOfTexts = uiNumberOfTexts; }
 
    void SetNumberOfBlits(const eC_UInt& uiNumberOfBlits) { m_uiNumberOfBlits = uiNumberOfBlits; }
 
    void AllOn()
    {
        SetFillScreen(true);
 
        SetPrimitiveLine(true);
        SetPrimitiveRect(true);
        SetPrimitiveEllipse(true);
        SetPrimitiveArc(true);
        SetPrimitiveRing(true);
 
        SetTextSingle(true);
        SetTextMedium(true);
        SetTextLong(true);
 
        SetBlitImg(true);
        SetBlitImgNinePatch(true);
        SetBlitImgExt(true);
        SetBlitSubImage(true);
        SetRotate(true);
        SetRotateSubImage(true);
    }
 
    void AllOff()
    {
        SetFillScreen(false);
 
        SetPrimitiveLine(false);
        SetPrimitiveRect(false);
        SetPrimitiveEllipse(false);
        SetPrimitiveArc(false);
        SetPrimitiveRing(false);
 
        SetTextSingle(false);
        SetTextMedium(false);
        SetTextLong(false);
 
        SetBlitImg(false);
        SetBlitImgNinePatch(false);
        SetBlitImgExt(false);
        SetBlitSubImage(false);
        SetRotate(false);
        SetRotateSubImage(false);
    }
 
    void SetFillScreen(const eC_Bool& bActive) { m_bFillScreenActive = bActive; }
 
    void SetPrimitiveLine(const eC_Bool& bActive) { m_bPrimitiveLineActive = bActive; }
    void SetPrimitiveRect(const eC_Bool& bActive) { m_bPrimitiveRectActive = bActive; }
    void SetPrimitiveEllipse(const eC_Bool& bActive) { m_bPrimitiveEllipseActive = bActive; }
    void SetPrimitiveArc(const eC_Bool& bActive) { m_bPrimitiveArcActive = bActive; }
    void SetPrimitiveRing(const eC_Bool& bActive) { m_bPrimitiveRingActive = bActive; }
 
    void SetTextSingle(const eC_Bool& bActive) { m_bTextSingleActive = bActive; }
    void SetTextMedium(const eC_Bool& bActive) { m_bTextMediumActive = bActive; }
    void SetTextLong(const eC_Bool& bActive) { m_bTextLongActive = bActive; }
 
    void SetBlitImg(const eC_Bool& bActive) { m_bBlitImgActive = bActive; }
    void SetBlitImgNinePatch(const eC_Bool& bActive) { m_bBlitImgNinePatchActive = bActive; }
    void SetBlitImgExt(const eC_Bool& bActive) { m_bBlitImgExtActive = bActive; }
    void SetBlitSubImage(const eC_Bool& bActive) { m_bBlitSubImageActive = bActive; }
    void SetRotate(const eC_Bool& bActive) { m_bRotateActive = bActive; }
    void SetRotateSubImage(const eC_Bool& bActive) { m_bRotateSubImageActive = bActive; }
 
    // helper classes
private:
    class InputHelper : public CGUIInputMedia
    {
    public:
        InputHelper();
 
        virtual CGUIEvent* GetEvent(eC_UInt uiIdleTime);
    };
 
    class GUIHelper : public CGUI
    {
    public:
        GUIHelper(const eC_UInt& uiWidth, const eC_UInt& uiHeight);
 
        void Refresh();
 
        void SetColor(const eC_UInt& uiColor = 0);
 
        void SetColor(const eC_UByte& ubRed, const eC_UByte& ubGreen, const eC_UByte& ubBlue, const eC_UByte& ubAlpha);
 
        void Clear(const eC_UInt& uiColor = 0);
 
        void Clear(const eC_UByte& ubRed, const eC_UByte& ubGreen, const eC_UByte& ubBlue, const eC_UByte& ubAlpha);
 
    private:
        eC_UInt m_uiWidth;
        eC_UInt m_uiHeight;
    };
 
private:
    eC_UInt BenchmarkFillScreen();
 
    eC_UInt BenchmarkLine();
 
    eC_UInt BenchmarkRect(const eC_Bool& bFilled);
 
    eC_UInt BenchmarkEllipse(const eC_Bool& bFilled);
 
    eC_UInt BenchmarkArc(const eC_Bool& bFilled);
 
    eC_UInt BenchmarkRing(const eC_Bool& bFilled);
 
    // text
    eC_UInt BenchmarkText_Single();
 
    eC_UInt BenchmarkText_Medium();
 
    eC_UInt BenchmarkText_Long();
 
    eC_UInt BenchmarkBlitImg_IDXY();
 
    eC_UInt BenchmarkBlitImgExt_IDXYWHSA(const eC_Value& vFactor, const eC_UByte& ubAlpha);
 
    eC_UInt BenchmarkBlitImgNinePatch_IDRNA(
        const eC_Value& vFactorX,
        const eC_Value& vFactorY,
        const eC_UByte& ubAlpha);
 
    eC_UInt BenchmarkBlitImgExt_IDRRA(const eC_Value& vFactor, const eC_UByte& ubAlpha);
 
    eC_UInt BenchmarkBlitImgExt_IDXYWHXYWHAAN(
        const eC_UInt uiSrcX,
        const eC_UInt uiSrcY,
        const eC_UInt uiSrcWidth,
        const eC_UInt uiSrcHeight,
        const eC_Value& vFactor,
        const eC_UByte& ubAlpha);
 
    eC_Bool SetTestImage(const eC_String& kImageName);
 
    eC_Bool SetTestFont(
        const eC_String& kFontName,
        const eC_UInt& uiFontSize);
 
    eC_Bool StartTest();
 
    eC_UInt EndTest();
 
    eC_UInt GetTime();
 
    void PrintSummary();
 
    void PrintSummaryLine(const eC_String& kText, eC_Value& vNextLine, eC_Value& vNextColumn);
 
    inline eC_Value GetXPos(const eC_UInt& uiRuns, const eC_UInt& uiActions)
    {
        // have -50 to 50 variance
        if (uiActions % 2)
            return eC_FromInt(((uiRuns + 10) * uiActions * ((m_uiNumberOfRuns + 5) * 2 - uiActions)) % (m_uiWidth + 100) - eC_FromFloat(50.3f));
        else
            return eC_FromInt(((uiRuns + 20) * uiActions * ((m_uiNumberOfRuns + 7) * 2 - uiActions)) % (m_uiWidth + 100) - eC_FromFloat(49.7f));
    }
 
    inline eC_Value GetYPos(const eC_UInt& uiRuns, const eC_UInt& uiActions)
    {
        // have -50 to 50 variance
        if (uiActions % 2)
            return eC_FromInt(((uiRuns + 20) * uiActions * ((m_uiNumberOfRuns + 5) / 2 - uiActions)) % (m_uiHeight + 100) - eC_FromFloat(49.7f));
        else
            return eC_FromInt(((uiRuns + 10) * uiActions * ((m_uiNumberOfRuns + 7) / 2 - uiActions)) % (m_uiHeight + 100) - eC_FromFloat(50.3f));
    }
 
    inline void GetX2Pos(const eC_UInt& uiRuns, const eC_UInt& uiActions, eC_Value& vX1, eC_Value& vX2)
    {
        if (uiActions % 2)
            vX1 = eC_FromInt(((uiRuns + 10) * uiActions * ((m_uiNumberOfRuns + 5) * 3 - uiActions)) % (m_uiWidth + 100) - eC_FromFloat(50.3f));
        else
            vX1 = eC_FromInt(((uiRuns + 20) * uiActions * ((m_uiNumberOfRuns + 7) * 3 - uiActions)) % (m_uiWidth + 100) - eC_FromFloat(49.7f));
        vX2 = vX1 + eC_Abs(eC_FromInt(((uiRuns + 10) * uiActions * ((m_uiNumberOfRuns + 5) * 3 - uiActions)) % (m_uiWidth + 100)));
    }
 
    inline void GetY2Pos(const eC_UInt& uiRuns, const eC_UInt& uiActions, eC_Value& vY1, eC_Value& vY2)
    {
        if (uiActions % 2)
            vY1 = eC_FromInt(((uiRuns + 20) * uiActions * ((m_uiNumberOfRuns + 5) / 3 - uiActions)) % (m_uiHeight + 100) - eC_FromFloat(49.7f));
        else
            vY1 = eC_FromInt(((uiRuns + 10) * uiActions * ((m_uiNumberOfRuns + 7) / 3 - uiActions)) % (m_uiHeight + 100) - eC_FromFloat(50.3f));
        vY2 = vY1 + eC_Abs(eC_FromInt(((uiRuns + 20) * uiActions * ((m_uiNumberOfRuns + 5) / 3 - uiActions)) % (m_uiWidth + 100)));
    }
 
private:
    struct TimeData_t
    {
        TimeData_t() :
            DataPresent(false),
            Name(""),
            TimePerRun(eC_FromInt(0)),
            OperationsPerSecond(0),
            HasAdditionalData(false),
            FactorX(eC_FromInt(0)),
            FactorY(eC_FromInt(0)),
            Alpha(0)
        {}
 
        TimeData_t(
            const eC_String& kName,
            const eC_Value& vTimePerRun,
            const eC_UInt& uiOperationsPerSecond,
            const eC_Bool& bHasAdditionalData = false,
            const eC_Value& vFactorX = eC_FromInt(0),
            const eC_Value& vFactorY = eC_FromInt(0),
            const eC_UByte& ubAlpha = 0) :
            DataPresent(true),
            Name(kName),
            TimePerRun(vTimePerRun),
            OperationsPerSecond(uiOperationsPerSecond),
            HasAdditionalData(bHasAdditionalData),
            FactorX(vFactorX),
            FactorY(vFactorY),
            Alpha(ubAlpha)
        {}
 
        eC_Bool DataPresent;
        eC_String Name;
        eC_Value TimePerRun;
        eC_UInt OperationsPerSecond;
        eC_Bool HasAdditionalData;
        eC_Value FactorX;
        eC_Value FactorY;
        eC_UByte Alpha;
    };
 
private:
    // sizes and framebuffer access
    eC_UInt m_uiWidth;
    eC_UInt m_uiHeight;
    eC_UInt m_uiStride;
    eC_UByte m_ubBitsPerPixel;
    eC_UByte* m_pkFrameBuffer;
 
    // helpers
    eC_UInt m_uiNumberOfRuns;
    eC_UInt m_uiNumberOfPrimitives;
    eC_UInt m_uiNumberOfTexts;
    eC_UInt m_uiNumberOfBlits;
    GUIHelper* m_pkGUI;
    CGfxWrap* m_pkGfxWrap;
    InputHelper* m_pkInput;
 
    // image
    eC_TListDoubleLinked<eC_String*> m_kImageList;
    ImageResource_t m_eImageID;
    eC_UInt m_uiImageWidth;
    eC_UInt m_uiImageHeight;
 
    // font
    eC_TListDoubleLinked<eC_String*> m_kFontList;
    FontResource_t m_eFontID;
 
    // summary
    eC_String m_kSummaryFontName;
    FontResource_t m_eSummaryFontID;
    eC_UInt m_uiWaitTime;
 
    // time
    eC_Time64 m_tTime;
    eC_UInt m_uiStartMS;
    eC_UInt m_uiEndMS;
 
    // test-flags
 
    // fill screen
    eC_Bool m_bFillScreenActive;
    TimeData_t m_kFillScreenData;
 
    // primitives
    eC_Bool m_bPrimitiveLineActive;
    TimeData_t m_kLineData;
    eC_Bool m_bPrimitiveRectActive;
    TimeData_t m_kRectData[2];
    eC_Bool m_bPrimitiveEllipseActive;
    TimeData_t m_kEllipseData[2];
    eC_Bool m_bPrimitiveArcActive;
    TimeData_t m_kArcData[2];
    eC_Bool m_bPrimitiveRingActive;
    TimeData_t m_kRingData[2];
 
    // texts
    eC_Bool m_bTextSingleActive;
    TimeData_t m_kTextSingleData;
    eC_Bool m_bTextMediumActive;
    TimeData_t m_kTextMediumData;
    eC_Bool m_bTextLongActive;
    TimeData_t m_kTextLongData;
 
    // blits
    eC_Bool m_bBlitImgActive;
    TimeData_t m_kBlitImgData;
    eC_Bool m_bBlitImgNinePatchActive;
    TimeData_t m_kBlitImgNinePatchData[10];
    eC_Bool m_bBlitImgExtActive;
    TimeData_t m_kBlitImgExtData[4];
    eC_Bool m_bBlitSubImageActive;
    TimeData_t m_kBlitSubImageData[4];
    eC_Bool m_bRotateActive;
    TimeData_t m_kRotateData;
    eC_Bool m_bRotateSubImageActive;
    TimeData_t m_kRotateSubImageData;
 
    eC_Value m_vNextLine;
    eC_Value m_vNextColumn;
};
 
#endif