performance_profiler.h

#pragma once

#include "core/debug/debug_window.h"
#include "util/string.h"
#include "util/map.h"
#include "util/ring_buffer.h"
#include "util/utility.h"
#include "util/vector.h"
#include "renderer/imgui/imgui.h"

#define BLOWBOX_PROFILER_HISTORY_MAX_SAMPLE_COUNT 2000
#define BLOWBOX_PROFILER_HISTORY_MIN_SAMPLE_COUNT 2

namespace blowbox
{
    class GpuResource;

    enum ProfilerBlockType
    {
        ProfilerBlockType_GAME,
        ProfilerBlockType_CORE,
        ProfilerBlockType_RENDERER,
        ProfilerBlockType_CONTENT,
        ProfilerBlockType_MISC,
        ProfilerBlockType_COUNT
    };

    class PerformanceProfiler : public DebugWindow
    {
    public:
        class ProfilerBlock
        {
            friend class PerformanceProfiler;
            friend class CompareProfilerBlockSingleFrame;
        public:
            ProfilerBlock();

            ProfilerBlock(const String& block_name, const ProfilerBlockType& block_type = ProfilerBlockType_MISC);

            ~ProfilerBlock();

            void Restart();

            void Finish();
        private:
            String block_name_;             
            ProfilerBlockType block_type_;  
            double start_time_;             
            double end_time_;               
            bool finished_;                 
        };

        struct ProfilerBlockFrameData
        {
            double total_time;              
            String block_name;              
            ProfilerBlockType block_type;   
        };

        PerformanceProfiler();
        ~PerformanceProfiler();

        void RenderMenu() override;

        void RenderWindow() override;

        void NewFrame();

        void CatchNextFrame();

    protected:
        struct ProfilerBlockTime
        {
            double start_time;              
            double end_time;                
        };

        struct ProfilerBlockData
        {
            RingBuffer<ProfilerBlockTime> block_times;  
            double average_block_time;                  
            double last_recalculation;                  
            double best_block_time;                     
            double best_block_time_overall;             
            double worst_block_time;                    
            double worst_block_time_overall;            
        };

        void AddProfilerBlock(ProfilerBlock& profiler_block);

        String ConvertBlockTypeToString(ProfilerBlockType type);

    private:
        float last_bounds_reset_time_;                                                      
        float bounds_reset_interval_;                                                       
        int history_sample_count_;                                                          

    private:
        bool show_window_;                                                                  

        bool catch_frame_;                                                                  
        bool catch_next_frame_;                                                             
        Vector<ProfilerBlock> collected_profiler_blocks_single_frame_;                      
        Map<String, ProfilerBlockFrameData> condensed_profiler_block_times_;                
        Vector<ProfilerBlockFrameData> profiler_blocks_single_frame_;                       

        Map<String, ProfilerBlockData> profiler_blocks_[ProfilerBlockType_COUNT];           
        float contiguous_block_times[BLOWBOX_PROFILER_HISTORY_MAX_SAMPLE_COUNT];            

        ImGuiTextFilter profiler_block_filters_[ProfilerBlockType_COUNT];                   
    
    protected:

        struct CompareProfilerBlockSingleFrame
        {
            inline bool operator() (const PerformanceProfiler::ProfilerBlockFrameData& a, const PerformanceProfiler::ProfilerBlockFrameData& b)
            {
                return (a.total_time > b.total_time);
            }
        };
    };
}