FPSCalc.cs

Go to the documentation of this file.

using UnityEngine;
using System.Text;
using System.Collections.Generic;

namespace HKI.Core.Debuging
{
    [System.Serializable]
    public class FPSCalc
    {
        // Enums
        [System.Serializable]
        public enum GraphStyles
        {
            Solid,
            Gradient,
            FPSBased
        }

        // Public variables
        [SerializeField] Color32 GraphColor = Color.white;
        [SerializeField] Color32 LowColor = Color.red;
        [SerializeField] int LowThreshold = 15;
        [SerializeField] Color32 MediumColor = Color.yellow;
        [SerializeField] int MediumThreshold = 30;
        [SerializeField] Color32 GoodColor = Color.green;
        [SerializeField] int GoodThreshold = 60;
        [SerializeField] Color32 HighColor = Color.cyan;

        [SerializeField] int GraphWidth = 400;
        [SerializeField] int GraphHeight = 50;
        
        [SerializeField] GraphStyles GraphStyle = GraphStyles.Solid;
        
        // Private variables
        float newPeriod = 0;
        ulong totalFrames = 0;
        int intervalTotalFrames = 0;
        int intervalFrameSum = 0;

        int currentFps;
        float currentFrametime;
        bool minChanged = false;
        int minFps = 999999;
        float minFrametime = 0.0f;
        bool maxChanged = false;
        int maxFps = 0;
        float maxFrametime = 0.0f;
        int avgFps = 0;
        float avgFrametime = 0.0f;

        float updateInterval = 0.2f;

        const float msTimeFactor = 1000.0f;

        Color[] cleanGraph = null;
        Texture2D graphTexture = null;
        List<int> fpsGraphBarsVal = null;

        int graphDataPoints = 200;

        string lowHexColorString = "";
        string mediumHexColorString = "";
        string goodHexColorString = "";
        string highHexColorString = "";

        const string fpsFTStringPart1 = "<color=#";
        const string fpsFTStringPart2a = "><size=40>";
        const string fpsFTStringPart2b = "><size=25>";
        const string fpsFTStringPart3 = "</size>\n(";
        const string fpsFTStringPart4 = " ms)</color>";

        const string format = "n2";

        StringBuilder sb = new StringBuilder(80);

        // Getter
        public Texture2D GraphTexture { get { return graphTexture; } }

        public string CurrentFPSAndFrameTimeString { get { return FPSAndFrameTimeToString(currentFps, currentFrametime); } }
        public string CurrentFPSAndFrameTimeStringSmall { get { return FPSAndFrameTimeToStringSmall(currentFps, currentFrametime); } }
        public string AvgFPSAndFrameTimeString { get { return FPSAndFrameTimeToString(avgFps, avgFrametime); } }

        public bool MinFPSChanged { get { return minChanged; } }
        public string MinFPSAndFrameTimeString { get { minChanged = false; return FPSAndFrameTimeToString(minFps, minFrametime); } }

        public bool MaxFPSChanged { get { return maxChanged; } }
        public string MaxFPSAndFrameTimeString { get { maxChanged = false; return FPSAndFrameTimeToString(maxFps, maxFrametime); } }

        // Setter
        public float SetUpdateInterval { set { updateInterval = value; } }

        // Interface functions
        public void Init()
        {
            graphTexture = new Texture2D(GraphWidth, GraphHeight);
            graphTexture.wrapMode = TextureWrapMode.Clamp;
            graphTexture.filterMode = FilterMode.Point;

            graphTexture.Apply();

            cleanGraph = new Color[GraphWidth * GraphHeight];

            graphDataPoints = GraphWidth / 2;
            fpsGraphBarsVal = new List<int>(graphDataPoints);

            for (int i = 0; i < graphDataPoints; i++)
                fpsGraphBarsVal.Add(0);

            graphTexture = new Texture2D(GraphWidth, GraphHeight);

            Color emptyColor = new Color(0, 0, 0, 0);

            for (int i = 0; i < GraphWidth; i++)
            {
                for (int j = 0; j < GraphHeight; j++)
                    cleanGraph[i * GraphHeight + j] = emptyColor;
            }

            graphTexture.SetPixels(cleanGraph);
            graphTexture.Apply();

            lowHexColorString = ColorToHEX(LowColor);
            mediumHexColorString = ColorToHEX(MediumColor);
            goodHexColorString = ColorToHEX(GoodColor);
            highHexColorString = ColorToHEX(HighColor);

        }

        public void Update()
        {
            float deltaTime = Time.unscaledDeltaTime;
            float time = Time.time;

            totalFrames++;
            intervalTotalFrames++;
            intervalFrameSum += (int)(1.0f / (deltaTime));
            if (time > newPeriod)
            {
                currentFrametime = deltaTime * msTimeFactor;

                currentFps = intervalFrameSum / intervalTotalFrames;
                intervalTotalFrames = 0;
                intervalFrameSum = 0;

                avgFps = (int)(totalFrames / time);
                avgFrametime = time / totalFrames * msTimeFactor;

                if (currentFps < minFps)
                {
                    minFps = currentFps;
                    minFrametime = currentFrametime;
                    minChanged = true;
                }

                if (currentFps > maxFps)
                {
                    maxFps = currentFps;
                    maxFrametime = currentFrametime;
                    maxChanged = true;
                }

                newPeriod += updateInterval;

                UpdateGraph();
            }
        }

        public void ResetMinAndMaxFPS()
        {
            minFps = 999999;
            maxFps = 0;
        }

        // Helper functions
        void UpdateGraph()
        {
            fpsGraphBarsVal.Add(currentFps);
            fpsGraphBarsVal.RemoveAt(0);

            float max = 100;
            for (int i = 0; i < fpsGraphBarsVal.Count; i++)
            {
                if (fpsGraphBarsVal[i] > max)
                    max = fpsGraphBarsVal[i];
            }

            graphTexture.SetPixels(cleanGraph);

            for (int i = 0; i < GraphWidth; i += 2)
            {
                for (int j = 0; j < (int)((fpsGraphBarsVal[i / 2] / max) * GraphHeight); j++)
                {
                    switch (GraphStyle)
                    {
                        case GraphStyles.Solid:
                            graphTexture.SetPixel(i, j, GraphColor);
                            graphTexture.SetPixel(i + 1, j, GraphColor);
                            break;
                        case GraphStyles.Gradient:
                            graphTexture.SetPixel(i, j, new Color(1 - (0.02f * j), 0.02f * j, 0));
                            graphTexture.SetPixel(i + 1, j, new Color(1 - (0.02f * j), 0.02f * j, 0));
                            break;
                        case GraphStyles.FPSBased:
                            graphTexture.SetPixel(i, j, GetColor(fpsGraphBarsVal[i / 2]));
                            graphTexture.SetPixel(i + 1, j, GetColor(fpsGraphBarsVal[i / 2]));
                            break;
                    }
                }
            }

            graphTexture.wrapMode = TextureWrapMode.Clamp;
            graphTexture.filterMode = GraphStyle == GraphStyles.Gradient ? FilterMode.Bilinear : FilterMode.Point;
            graphTexture.Apply();
        }
        
        string FPSAndFrameTimeToString(int fps, float frametime)
        {
            sb.Clear();
            sb.Append(fpsFTStringPart1);

            if (fps <= LowThreshold)
                sb.Append(lowHexColorString);
            else if (fps <= MediumThreshold)
                sb.Append(mediumHexColorString);
            else if (fps <= GoodThreshold)
                sb.Append(goodHexColorString);
            else
                sb.Append(highHexColorString);

            sb.Append(fpsFTStringPart2a);

            sb.Append(fps.ToString());

            sb.Append(fpsFTStringPart3);

            sb.Append(frametime.ToString(format));

            sb.Append(fpsFTStringPart4);

            return sb.ToString();
        }

        string FPSAndFrameTimeToStringSmall(int fps, float frametime)
        {
            sb.Clear();
            sb.Append(fpsFTStringPart1);

            if (fps <= LowThreshold)
                sb.Append(lowHexColorString);
            else if (fps <= MediumThreshold)
                sb.Append(mediumHexColorString);
            else if (fps <= GoodThreshold)
                sb.Append(goodHexColorString);
            else
                sb.Append(highHexColorString);

            sb.Append(fpsFTStringPart2b);

            sb.Append(fps.ToString());

            sb.Append(fpsFTStringPart3);

            sb.Append(frametime.ToString(format));

            sb.Append(fpsFTStringPart4);

            return sb.ToString();
        }
        string ColorToHEX(Color32 color)
        {
            return color.r.ToString("X2") + color.g.ToString("X2") + color.b.ToString("X2");
        }

        Color GetColor(int fps)
        {
            if (fps <= LowThreshold)
                return LowColor;
            if (fps <= MediumThreshold)
                return MediumColor;
            if (fps <= GoodThreshold)
                return GoodColor;

            return HighColor;
        }
    }
}