GPUBuffer.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 "Forward.hpp"
 
#include "GPUMemory.hpp"
#include "GPUResource.hpp"
#include "GPUVertexFormat.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Buffer.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include <function2/function2.hpp>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() GPUBufferType {
        Generic,
 
        Vertex,
 
        Index,
 
        Uniform,
 
        Storage,
 
        Indirect,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUBufferUsageFlag {
        Automatic = 0u,
 
        Source = (1u << 0u),
 
        Destination = (1u << 1u),
 
        Uniform = (1u << 2u),
 
        Index = (1u << 3u),
 
        Vertex = (1u << 4u),
        Storage = (1u << 5u),
 
        Indirect = (1u << 6u),
    };
 
    using GPUBufferUsage = Flags<GPUBufferUsageFlag>;
    CE_FLAGS_OPERATORS(GPUBufferUsageFlag);
 
    using GPUBufferSize = GPUMemorySize;
 
    using GPUBufferData = GPUMemoryData;
 
    struct CE_SCRIPT_EXPORT() GPUBufferDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUBufferType type = GPUBufferType::Vertex;
 
        CE_SCRIPT_EXPORT()
        GPUBufferUsage usage = GPUBufferUsageFlag::Automatic;
 
        CE_SCRIPT_EXPORT()
        GPUMemoryProperties memoryProperty = GPUMemoryProperty::HostVisible;
 
        CE_SCRIPT_EXPORT()
        GPUBufferSize size = 0;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(usage);
            CE_REFL_DATA(memoryProperty);
            CE_REFL_DATA(size);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUBuffer : public TDeviceObject<GPUBufferDescriptor, GPUResource> {
    public:
        static inline const constexpr GPUBufferSize whole = ~0UL;
 
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUBuffer(const GPUBuffer&) = delete;
        GPUBuffer& operator=(const GPUBuffer&) = delete;
 
        GPUBuffer(GPUBuffer&&) = delete;
        GPUBuffer& operator=(GPUBuffer&&) = delete;
 
    public:
        [[nodiscard]] Async<ByteBuffer> read(GPUBufferSize offset = 0, GPUBufferSize size = whole);
 
        [[nodiscard]] Async<ByteBuffer> read(GPUCommandBuffer& commandBuffer, GPUBufferSize offset = 0, GPUBufferSize size = whole);
 
        Async<> write(ByteBuffer&& rawData, GPUBufferSize offset = 0, GPUBufferSize size = whole);
 
        Async<> write(GPUCommandBuffer& commandBuffer, ByteBuffer&& rawData, GPUBufferSize offset = 0, GPUBufferSize size = whole);
 
        [[nodiscard]] virtual GPUBufferData map() = 0;
 
        CE_SCRIPT_EXPORT()
        virtual void unmap() = 0;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        virtual GPUBufferSize getSize() const = 0;
 
        CE_SCRIPT_EXPORT()
        virtual void flush(GPUBufferSize offset = 0, GPUBufferSize size = whole) = 0;
 
        CE_SCRIPT_EXPORT()
        virtual void invalidate(GPUBufferSize offset = 0, GPUBufferSize size = whole) = 0;
 
    public:
        template<typename Block> void data(Block&& block) {
            const GPUBufferData mapped = map();
            block(mapped);
            unmap();
        }
    };
 
    struct GPUBufferViewDescriptor {
        UInt64 offset = 0;
        UInt64 size = GPUBuffer::whole;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(offset);
            CE_REFL_DATA(size);
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUBufferDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUBufferViewDescriptor);