gpu/src/gpu/Context.h

//
//  Context.h
//  interface/src/gpu
//
//  Created by Sam Gateau on 10/27/2014.
//  Copyright 2014 High Fidelity, Inc.
//  Copyright 2024 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_gpu_Context_h
#define hifi_gpu_Context_h
 
#include <assert.h>
#include <mutex>
#include <queue>
 
#include "Texture.h"
#include "Pipeline.h"
#include "Frame.h"
#include "PointerStorage.h"
#include "Backend.h"
 
namespace gpu {
class Context {
public:
    using Size = Resource::Size;
    typedef BackendPointer (*CreateBackend)();
 
    template <class T>
    static void init() {
        std::call_once(_initialized, [] {
            _createBackendCallback = T::createBackend;
            T::init();
        });
    }
 
    Context();
    ~Context();
 
    void shutdown();
 
    const std::string& getBackendVersion() const;
 
    void beginFrame(const glm::mat4& renderView = glm::mat4(), const glm::mat4& renderPose = glm::mat4());
 
    void appendFrameBatch(const BatchPointer& batch);
 
    FramePointer endFrame();
 
    static BatchPointer acquireBatch(const char* name = nullptr);
 
    static void releaseBatch(Batch* batch);
 
    void recycle() const;
 
    void executeBatch(Batch& batch) const;
 
    void executeBatch(const char* name, std::function<void(Batch&)> lambda) const;
 
    void executeFrame(const FramePointer& frame) const;
 
    void consumeFrameUpdates(const FramePointer& frame) const;
 
    const BackendPointer& getBackend() const { return _backend; }
 
    void enableStereo(bool enable = true);
 
    bool isStereo();
 
    void setStereoProjections(const mat4 eyeProjections[2]);
 
    void setStereoViews(const mat4 eyeViews[2]);
 
    void getStereoProjections(mat4* eyeProjections) const;
 
    void getStereoViews(mat4* eyeViews) const;
 
    void downloadFramebuffer(const FramebufferPointer& srcFramebuffer, const Vec4i& region, QImage& destImage);
 
    // Reporting stats of the context
    void resetStats() const;
 
    void getStats(ContextStats& stats) const;
 
    void getFrameStats(ContextStats& stats) const;
 
    static PipelinePointer createMipGenerationPipeline(const ShaderPointer& pixelShader);
 
    double getFrameTimerGPUAverage() const;
 
    double getFrameTimerBatchAverage() const;
 
    static Size getFreeGPUMemSize();
 
    static Size getUsedGPUMemSize();
 
    static uint32_t getBufferGPUCount();
 
    static Size getBufferGPUMemSize();
 
    static uint32_t getTextureGPUCount();
 
    static uint32_t getTextureResidentGPUCount();
 
    static uint32_t getTextureFramebufferGPUCount();
 
    static uint32_t getTextureResourceGPUCount();
 
    static uint32_t getTextureExternalGPUCount();
 
    static Size getTextureGPUMemSize();
 
    static Size getTextureResidentGPUMemSize();
 
    static Size getTextureFramebufferGPUMemSize();
 
    static Size getTextureResourceGPUMemSize();
 
    static Size getTextureExternalGPUMemSize();
 
    static uint32_t getTexturePendingGPUTransferCount();
 
    static Size getTexturePendingGPUTransferMemSize();
 
    static Size getTextureResourcePopulatedGPUMemSize();
 
    static Size getTextureResourceIdealGPUMemSize();
 
    struct ProgramsToSync {
        ProgramsToSync(const std::vector<gpu::ShaderPointer>& programs, std::function<void()> callback, size_t rate) :
            programs(programs), callback(callback), rate(rate) {}
 
        std::vector<gpu::ShaderPointer> programs;
        std::function<void()> callback;
        size_t rate;
    };
 
    void pushProgramsToSync(const std::vector<uint32_t>& programIDs, std::function<void()> callback, size_t rate = 0);
 
    void pushProgramsToSync(const std::vector<gpu::ShaderPointer>& programs, std::function<void()> callback, size_t rate = 0);
 
    void processProgramsToSync();
 
protected:
    Context(const Context& context) = delete;
 
    std::shared_ptr<Backend> _backend;
 
    bool _frameActive{ false };
 
    FramePointer _currentFrame;
 
    RangeTimerPointer _frameRangeTimer;
 
    StereoState _stereo;
 
    std::mutex _programsToSyncMutex;
 
    std::queue<ProgramsToSync> _programsToSyncQueue;
 
    gpu::Shaders _syncedPrograms;
 
    size_t _nextProgramToSyncIndex { 0 };
 
    mutable ContextStats _frameStats;
 
    static CreateBackend _createBackendCallback;
 
    static std::once_flag _initialized;
 
    static void clearBatches();
 
    static std::mutex _batchPoolMutex;
 
    static std::list<Batch*> _batchPool;
 
    friend class Shader;
    friend class Backend;
};
typedef std::shared_ptr<Context> ContextPointer;
 
void doInBatch(const char* name, const std::shared_ptr<gpu::Context>& context, const std::function<void(Batch& batch)>& f);
 
};  // namespace gpu
 
#endif