GPU.hpp

#pragma once
 
#include "resources/Mesh.hpp"
#include "resources/Texture.hpp"
#include "resources/Buffer.hpp"
#include "graphics/GPUTypes.hpp"
#include "graphics/Program.hpp"
#include "Common.hpp"
 
#include <functional>
 
// Forward declarations.
class Window;
struct GPUContext;
 
class GPU {
 
    friend class GPUTexture; 
    friend class GPUBuffer; 
    friend class GPUMesh; 
    friend class Program; 
    friend class Swapchain; 
    friend class PipelineCache; 
 
public:
 
    struct Metrics {
        // Global statistics.
        unsigned long long uploads = 0; 
        unsigned long long downloads = 0; 
        unsigned long long textures = 0; 
        unsigned long long buffers = 0; 
        unsigned long long programs = 0; 
        unsigned long long pipelines = 0; 
 
        // Per-frame statistics.
        unsigned long long drawCalls = 0; 
        unsigned long long quadCalls = 0; 
        unsigned long long pipelineBindings = 0; 
        unsigned long long renderPasses = 0; 
        unsigned long long meshBindings = 0; 
        unsigned long long blitCount = 0; 
 
        void resetPerFrameMetrics(){
            drawCalls = 0;
            quadCalls = 0;
            pipelineBindings = 0;
            renderPasses = 0;
            meshBindings = 0;
            blitCount = 0;
        }
    };
    
    static bool setup(const std::string & appName);
 
    static bool setupWindow(Window * window);
 
    static void createGraphicsProgram(Program & program, const std::string & vertexContent, const std::string & fragmentContent, const std::string & tessControlContent, const std::string & tessEvalContent, const std::string & debugInfos);
 
    static void createComputeProgram(Program & program, const std::string & computeContent, const std::string & debugInfos);
 
    static void bindProgram(const Program & program);
 
    static void beginRender(const Load & depthOp, const Load & stencilOp, const Texture * depthStencil, const Load & colorOp, const Texture * color0 = nullptr, const Texture * color1 = nullptr, const Texture * color2 = nullptr, const Texture * color3 = nullptr);
 
    static void beginRender(const Load& colorOp, const Texture* color0, const Texture* color1 = nullptr, const Texture* color2 = nullptr, const Texture* color3 = nullptr);
 
    static void beginRender(const Load& depthOp, const Load& stencilOp, const Texture* depthStencil);
 
    static void beginRender(uint layer, uint mip, const Load & depthOp, const Load & stencilOp, const Texture * depthStencil, const Load & colorOp, const Texture * color0 = nullptr, const Texture * color1 = nullptr, const Texture * color2 = nullptr, const Texture * color3 = nullptr);
 
    static void beginRender(uint layer, uint mip, const Load& colorOp, const Texture* color0, const Texture* color1 = nullptr, const Texture* color2 = nullptr, const Texture* color3 = nullptr);
 
    static void beginRender(uint layer, uint mip, const Load& depthOp, const Load& stencilOp, const Texture* depthStencil);
 
    static void beginRender(const Window & window, const Load & depthOp = Load::Operation::DONTCARE, const Load & stencilOp = Load::Operation::DONTCARE, const Load & colorOp = Load::Operation::DONTCARE);
 
 
    static void endRender();
 
    static void saveTexture(Texture & texture, const std::string & path, Image::Save options);
 
    static void setupTexture(Texture & texture);
 
    static void uploadTexture(const Texture & texture);
 
    static void downloadTextureSync(Texture & texture);
 
    static void downloadTextureSync(Texture & texture, int level);
 
    static GPUAsyncTask downloadTextureAsync(const Texture& texture, const glm::uvec2& offset, const glm::uvec2& size, uint layerCount, std::function<void(const Texture&)> callback);
 
    static void cancelAsyncOperation(const GPUAsyncTask& id);
    
    static void generateMipMaps(const Texture & texture);
 
    static void clearTexture(const Texture & texture, const glm::vec4& color);
 
    static void clearDepth(const Texture & texture, float depth);
 
    static void setupBuffer(Buffer & buffer);
 
    static void uploadBuffer(const Buffer & buffer, size_t size, uchar * data, size_t offset = 0);
 
    static void downloadBufferSync(const Buffer & buffer, size_t size, uchar * data, size_t offset = 0);
 
    static void flushBuffer(const Buffer & buffer, size_t size, size_t offset);
 
    static void setupMesh(Mesh & mesh);
 
    static void drawMesh(const Mesh & mesh);
 
    static void drawTesselatedMesh(const Mesh & mesh, uint patchSize);
 
    static void drawQuad();
 
    static void dispatch(uint width, uint height, uint depth);
 
    static void flush();
 
    static void nextFrame();
 
    static void deviceInfos(std::string & vendor, std::string & renderer, std::string & version, std::string & shaderVersion);
 
    static std::vector<std::string> supportedExtensions();
 
    static void setViewport(int x, int y, int w, int h);
 
    static void setViewport(const Texture& tex);
 
    static void setDepthState(bool test);
 
    static void setDepthState(bool test, TestFunction function, bool write);
 
    static void setStencilState(bool test, bool write);
 
    static void setStencilState(bool test, TestFunction function, StencilOp fail, StencilOp pass, StencilOp depthFail, uchar value);
 
    static void setBlendState(bool test);
 
    static void setBlendState(bool test, BlendEquation equation, BlendFunction src, BlendFunction dst);
 
    static void setCullState(bool cull);
 
    static void setCullState(bool cull, Faces culledFaces);
 
    static void setPolygonState(PolygonMode mode);
 
    static void setColorState(bool writeRed, bool writeGreen, bool writeBlue, bool writeAlpha);
 
    static void getState(GPUState & state);
 
    static const Metrics & getMetrics();
 
    static void blitDepth(const Texture & src, const Texture & dst);
 
    static void blit(const Texture & src, const Texture & dst, Filter filter);
 
    static void blit(const Texture & src, const Texture & dst, size_t lSrc, size_t lDst, Filter filter);
 
    static void blit(const Texture & src, const Texture & dst, size_t lSrc, size_t lDst, size_t mipSrc, size_t mipDst, Filter filter);
 
    static GPUContext* getInternal();
 
    static void cleanup();
 
private:
 
    static void bindAttachments(uint layer, uint mip, const Load& colorOp, const Load& depthOp, const Load& stencilOp, const Texture* depthStencil, const Texture* color0, const Texture* color1, const Texture* color2, const Texture* color3);
    
    static void bindGraphicsPipelineIfNeeded();
 
    static void bindComputePipelineIfNeeded();
 
    static void endRenderingIfNeeded();
 
    static void beginFrameCommandBuffers();
 
    static void submitFrameCommandBuffers();
 
    static void clean(GPUTexture & tex);
 
    static void clean(GPUMesh & mesh);
 
    static void clean(GPUBuffer & buffer);
 
    static void clean(Program & program);
 
    static void processDestructionRequests();
 
    static void processAsyncTasks(bool forceAll = false);
 
    static GPUState _state; 
    static GPUState _lastState; 
    static Metrics _metrics; 
    static Metrics _metricsPrevious; 
    static Mesh _quad; 
 
};