GPUQuery.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Common.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Chrono.hpp"
 
#include <chrono>
 
namespace CeresEngine {
 
    class GPUQuery {};
 
    // ---------------------------------------------------------------------------------------------
 
    using GPUTimerQueryResult = TimeInterval;
 
    struct GPUTimerQueryDescriptor {
        UInt32 numberOfTimers = 1;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {}
    };
 
    class GPUTimerQuery : public GPUQuery, public TDeviceObject<GPUTimerQueryDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUTimerQuery(const GPUTimerQuery&) = delete;
        GPUTimerQuery& operator=(const GPUTimerQuery&) = delete;
 
        GPUTimerQuery(GPUTimerQuery&&) = delete;
        GPUTimerQuery& operator=(GPUTimerQuery&&) = delete;
 
    public: // Events
        Event<void(GPUTimerQueryResult)> didComplete;
 
    public:
        virtual void begin(GPUCommandBuffer& commandBuffer, UInt32 timerIndex = 0) = 0;
 
        virtual void end(GPUCommandBuffer& commandBuffer, UInt32 timerIndex = 0) = 0;
 
        [[nodiscard]] virtual bool isComplete(UInt32 timerIndex = 0) const = 0;
 
        virtual void wait(UInt32 timerIndex = 0) const = 0;
 
        [[nodiscard]] virtual GPUTimerQueryResult getValue(UInt32 timerIndex = 0) const = 0;
 
        virtual void reset() = 0;
 
    public:
        class Scope {
        private:
            GPUCommandBuffer* mCommandBuffer = nullptr;
 
            GPUTimerQuery* mQuery = nullptr;
 
            UInt32 mTimerIndex = 0;
 
        public:
            explicit Scope(GPUCommandBuffer& commandBuffer, GPUTimerQuery& query, const UInt32 timerIndex = 0)
                    : mCommandBuffer(&commandBuffer), mQuery(&query), mTimerIndex(timerIndex) {
                mQuery->begin(*mCommandBuffer, mTimerIndex);
            }
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPUTimerQuery& query, const UInt32 timerIndex = 0) : Scope(*commandBuffer, query, timerIndex) {}
 
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPUTimerQueryPtr& query, const UInt32 timerIndex = 0) : Scope(commandBuffer, *query, timerIndex) {}
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPUTimerQueryPtr& query, const UInt32 timerIndex = 0)
                    : Scope(*commandBuffer, *query, timerIndex) {}
 
            ~Scope() noexcept { reset(); }
 
        public:
            void reset() {
                if(mQuery != nullptr) {
                    mQuery->end(*mCommandBuffer, mTimerIndex);
                    mQuery = nullptr;
                    mCommandBuffer = nullptr;
                }
            }
        };
 
        template<typename Func> decltype(auto) with(GPUCommandBuffer& commandBuffer, Func&& func) {
            const Scope scope(commandBuffer, *this);
            return func();
        }
 
        template<typename Func> decltype(auto) with(GPUCommandBuffer& commandBuffer, const UInt32 timerIndex, Func&& func) {
            const Scope scope(commandBuffer, *this, timerIndex);
            return func();
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct GPUOcclusionQueryDescriptor {
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {}
    };
 
    class GPUOcclusionQuery : public GPUQuery, public TDeviceObject<GPUOcclusionQueryDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUOcclusionQuery(const GPUOcclusionQuery&) = delete;
        GPUOcclusionQuery& operator=(const GPUOcclusionQuery&) = delete;
 
        GPUOcclusionQuery(GPUOcclusionQuery&&) = delete;
        GPUOcclusionQuery& operator=(GPUOcclusionQuery&&) = delete;
 
    public:
        virtual void begin(GPUCommandBuffer& commandBuffer) = 0;
 
        virtual void end(GPUCommandBuffer& commandBuffer) = 0;
 
    public:
        class Scope {
        private:
            GPUCommandBuffer* mCommandBuffer = nullptr;
 
            GPUOcclusionQuery* mQuery = nullptr;
 
        public:
            explicit Scope(GPUCommandBuffer& commandBuffer, GPUOcclusionQuery& query)
                    : mCommandBuffer(&commandBuffer), mQuery(&query) {
                mQuery->begin(*mCommandBuffer);
            }
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, GPUOcclusionQuery& query) : Scope(*commandBuffer, query) {}
 
            explicit Scope(GPUCommandBuffer& commandBuffer, const GPUOcclusionQueryPtr& query) : Scope(commandBuffer, *query) {}
 
            explicit Scope(const GPUCommandBufferPtr& commandBuffer, const GPUOcclusionQueryPtr& query)
                    : Scope(*commandBuffer, *query) {}
 
            ~Scope() noexcept { reset(); }
 
        public:
            void reset() {
                if(mQuery != nullptr) {
                    mQuery->end(*mCommandBuffer);
                    mQuery = nullptr;
                    mCommandBuffer = nullptr;
                }
            }
        };
 
        template<typename Func> decltype(auto) with(GPUCommandBuffer& commandBuffer, Func&& func) {
            const Scope scope(commandBuffer, *this);
            return func();
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUTimerQueryDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUOcclusionQueryDescriptor);