DebugViewer.hpp

#pragma once
#include "graphics/Program.hpp"
#include "graphics/GPUTypes.hpp"
 
class Texture;
class Mesh;
 
class DebugViewer {
 
public:
 
    explicit DebugViewer();
 
    void track(const Texture * tex);
 
    void track(const Mesh * mesh);
 
    void trackState(const std::string & name);
 
    void untrack(const Texture * tex);
 
    void untrack(const Mesh * mesh);
 
    void pushMarker(const std::string& category, const std::string& label, const glm::vec4& color);
 
    void insertMarker(const std::string& category, const std::string& label, const glm::vec4& color);
 
    void popMarker(const std::string& category);
 
    void nextFrame();
 
    void interface();
 
    ~DebugViewer() = default;
 
    DebugViewer(const DebugViewer &) = delete;
 
    DebugViewer & operator=(const DebugViewer &) = delete;
 
    DebugViewer(DebugViewer &&) = delete;
 
    DebugViewer & operator=(DebugViewer &&) = delete;
 
public:
 
    static void setDefault(DebugViewer * viewer);
 
    static void trackDefault(const Texture * tex);
 
    static void trackDefault(const Mesh * mesh);
 
    static void trackStateDefault(const std::string & name);
 
    static void untrackDefault(const Texture * tex);
 
    static void untrackDefault(const Mesh * mesh);
 
    static void pushMarkerDefault(const std::string& category, const std::string& label, const glm::vec4& color);
 
    static void insertMarkerDefault(const std::string& category, const std::string& label, const glm::vec4& color);
 
    static void popMarkerDefault(const std::string& category);
 
private:
 
    static DebugViewer * _shared; 
 
private:
 
    struct TextureInfos {
        const Texture * tex = nullptr; 
        std::string name; 
        std::unique_ptr<Texture> display; 
        std::string displayName; 
        glm::vec2 range = glm::vec2(0.0f, 1.0f); 
        glm::bvec4 channels = glm::bvec4(true, true, true, false); 
        int mip = 0; 
        int layer = 0; 
        bool gamma = false; 
        bool visible = false; 
    };
 
    struct MeshInfos {
        const Mesh * mesh = nullptr; 
        std::string name; 
        bool visible = false; 
    };
 
    struct StateInfos {
        GPUState state; 
        bool visible = false; 
        bool populated = false; 
    };
 
    struct MarkerInfos {
        std::string name; 
        glm::vec4 color; 
        uint index; 
        std::vector<MarkerInfos> markers; 
    };
 
    struct MarkerCategoryInfos {
        std::vector<MarkerInfos> markers; 
        int  frequency = 1; 
        int  offset = 0; 
        uint depth = 0; 
        bool visible = false;  
        bool record = true; 
    };
 
    void displayMetrics();
 
    void displayMarker(const MarkerInfos& marker);
 
    void displayMarkers(const std::string & name, MarkerCategoryInfos& category);
 
    void displayState(const std::string & name, StateInfos & infos);
 
    void displayMesh(MeshInfos & mesh);
 
    void registerTexture(const std::string & name, const Texture * tex, TextureInfos & infos);
 
    void displayTexture(const std::string & prefix, TextureInfos & tex);
 
    void updateDisplay(const TextureInfos & tex);
 
    std::vector<TextureInfos> _textures; 
    std::vector<TextureInfos> _drawables; 
    std::vector<MeshInfos> _meshes; 
    std::unordered_map<std::string, StateInfos> _states; 
    std::unordered_map<std::string, MarkerCategoryInfos> _markers; 
 
    Program * _texDisplay; 
    uint64_t _frameCounter = 0; 
    uint _textureId  = 0; 
    uint _drawableId = 0; 
    uint _meshId     = 0; 
    uint _winId      = 0; 
    uint _markerId   = 0; 
 
};