GPUImage.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 "GPUFormat.hpp"
#include "GPUMemory.hpp"
#include "GPUResource.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 "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Math/Offset.hpp"
#include "CeresEngine/Texture/TextureFormat.hpp"
 
#include <ostream>
#include <utility>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() GPUImageType : UInt32 {
        Image1D, 
        Image2D, 
        Image3D, 
        ImageCube, 
        Image1DArray, 
        Image2DArray, 
        ImageCubeArray, 
        Image2DMS, 
        Image2DMSArray, 
        None = ~0u,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUImageUsageFlags {
        Attachment = (1u << 0u),
 
        Sample = (1u << 1u),
 
        Storage = (1u << 2u),
    };
 
    using GPUImageUsage = Flags<GPUImageUsageFlags>;
    CE_FLAGS_OPERATORS(GPUImageUsageFlags);
 
    enum class CE_SCRIPT_EXPORT() GPUImageLayout {
        DontCare,
        Attachment,
        DepthAttachment,
        ShaderAccess,
        Present
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageSubresource final {
        CE_SCRIPT_EXPORT()
        UInt32 baseArrayLayer = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 numArrayLayers = 1;
 
        CE_SCRIPT_EXPORT()
        UInt32 baseMipLevel = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 numMipLevels = 1;
 
        friend bool operator==(const GPUImageSubresource& lhs, const GPUImageSubresource& rhs);
        friend bool operator!=(const GPUImageSubresource& lhs, const GPUImageSubresource& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(baseArrayLayer);
            CE_REFL_DATA(numArrayLayers);
            CE_REFL_DATA(baseMipLevel);
            CE_REFL_DATA(numMipLevels);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageLocation final {
        TOffset3<UInt32> offset = {0, 0, 0};
 
        CE_SCRIPT_EXPORT()
        UInt32 arrayLayer = 0;
 
        CE_SCRIPT_EXPORT()
        UInt32 mipLevel = 0;
 
        friend bool operator==(const GPUImageLocation& lhs, const GPUImageLocation& rhs);
        friend bool operator!=(const GPUImageLocation& lhs, const GPUImageLocation& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(offset);
            CE_REFL_DATA(arrayLayer);
            CE_REFL_DATA(mipLevel);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageRegion final {
        CE_SCRIPT_EXPORT()
        GPUImageSubresource subresource;
 
        TOffset3<UInt32> offset = {0, 0, 0};
 
        TExtent3<UInt32> extent = {0, 0, 0};
 
        friend bool operator==(const GPUImageRegion& lhs, const GPUImageRegion& rhs);
        friend bool operator!=(const GPUImageRegion& lhs, const GPUImageRegion& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(subresource);
            CE_REFL_DATA(offset);
            CE_REFL_DATA(extent);
        }
    };
 
    enum class CE_SCRIPT_EXPORT() GPUImageSwizzle {
        Zero,
 
        One,
 
        Red,
 
        Green,
 
        Blue,
 
        Alpha
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageSwizzleRGBA final {
        CE_SCRIPT_EXPORT()
        GPUImageSwizzle r = GPUImageSwizzle::Red;
 
        CE_SCRIPT_EXPORT()
        GPUImageSwizzle g = GPUImageSwizzle::Green;
 
        CE_SCRIPT_EXPORT()
        GPUImageSwizzle b = GPUImageSwizzle::Blue;
 
        CE_SCRIPT_EXPORT()
        GPUImageSwizzle a = GPUImageSwizzle::Alpha;
 
        friend bool operator==(const GPUImageSwizzleRGBA& lhs, const GPUImageSwizzleRGBA& rhs);
        friend bool operator!=(const GPUImageSwizzleRGBA& lhs, const GPUImageSwizzleRGBA& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(r);
            CE_REFL_DATA(g);
            CE_REFL_DATA(b);
            CE_REFL_DATA(a);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUImageType type = GPUImageType::Image2D;
 
        CE_SCRIPT_EXPORT()
        GPUImageUsage usage = GPUImageUsageFlags::Sample;
 
        CE_SCRIPT_EXPORT()
        GPUMemoryProperties memoryProperty = GPUMemoryProperty::DeviceLocal;
 
        Format format = Format::RGBA8UNorm;
 
        TExtent3<UInt32> extent = {1, 1, 1};
 
        CE_SCRIPT_EXPORT()
        UInt32 arrayLayers = 1;
 
        CE_SCRIPT_EXPORT()
        UInt32 mipLevels = 1;
 
        CE_SCRIPT_EXPORT()
        UInt32 samples = 1;
 
        GPUImageLayout initialLayout = GPUImageLayout::DontCare;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        friend bool operator==(const GPUImageDescriptor& lhs, const GPUImageDescriptor& rhs);
        friend bool operator!=(const GPUImageDescriptor& lhs, const GPUImageDescriptor& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(usage);
            CE_REFL_DATA(memoryProperty);
            CE_REFL_DATA(format);
            CE_REFL_DATA(extent);
            CE_REFL_DATA(arrayLayers);
            CE_REFL_DATA(mipLevels);
            CE_REFL_DATA(samples);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUImage : public TDeviceObject<GPUImageDescriptor, GPUResource> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUImage(const GPUImage&) = delete;
        GPUImage& operator=(const GPUImage&) = delete;
 
        GPUImage(GPUImage&&) = delete;
        GPUImage& operator=(GPUImage&&) = delete;
 
    public:
#if 0
        Async<ByteBuffer> read(BufferSize offset = 0, BufferSize size = ~0u);
 
        Async<ByteBuffer> read(CommandBuffer& commandBuffer, BufferSize offset = 0,
                BufferSize size = ~0u);
 
        Async<> write(ByteBuffer&& rawData, BufferSize offset = 0, BufferSize size = ~0u);
 
        Async<> write(CommandBuffer& commandBuffer, ByteBuffer&& rawData,
                BufferSize offset = 0, BufferSize size = ~0u);
#endif
 
    public:
        CE_SCRIPT_EXPORT()
        virtual GPUImageViewPtr createView(const GPUImageViewDescriptor& descriptor) = 0;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UInt32 numMipLevels(UInt32 width, UInt32 height = 1, UInt32 depth = 1) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UInt32 numMipLevels(const GPUImageDescriptor& imageDesc) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UInt32 bufferSize(Format format, UInt32 numTexels) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UInt32 size(const GPUImageDescriptor& imageDesc) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static bool isMipMapped(const GPUImageDescriptor& imageDesc) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static bool isArray(GPUImageType type) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static bool isMultiSample(GPUImageType type) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static bool isCube(GPUImageType type) noexcept;
    };
 
    struct CE_SCRIPT_EXPORT() GPUImageViewDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUImageType type = GPUImageType::Image2D;
 
        CE_SCRIPT_EXPORT()
        Format format = Format::Undefined;
 
        CE_SCRIPT_EXPORT()
        GPUImageSubresource subresource;
 
        CE_SCRIPT_EXPORT()
        GPUImageSwizzleRGBA swizzle;
 
        CE_SCRIPT_EXPORT()
        String name;
 
        friend bool operator==(const GPUImageViewDescriptor& lhs, const GPUImageViewDescriptor& rhs);
        friend bool operator!=(const GPUImageViewDescriptor& lhs, const GPUImageViewDescriptor& rhs);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(format);
            CE_REFL_DATA(subresource);
            CE_REFL_DATA(swizzle);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUImageView : public TDeviceObject<GPUImageViewDescriptor> {
    public:
        CE_SCRIPT_EXPORT()
        GPUImage& image;
 
    public:
        explicit GPUImageView(GPUImage& image, const GPUImageViewDescriptor& descriptor);
 
        ~GPUImageView() override;
 
        GPUImageView(const GPUImageView&) = delete;
        GPUImageView& operator=(const GPUImageView&) = delete;
 
        GPUImageView(GPUImageView&&) = delete;
        GPUImageView& operator=(GPUImageView&&) = delete;
    };
 
    StringView toString(GPUImageType type);
 
    std::ostream& operator<<(std::ostream& os, GPUImageType type);
 
    StringView toString(GPUImageLayout layout);
 
    std::ostream& operator<<(std::ostream& os, GPUImageLayout layout);
 
    String toString(const GPUImageDescriptor& descriptor);
 
    std::ostream& operator<<(std::ostream& os, const GPUImageDescriptor& descriptor);
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUImageSubresource);
 
CE_REFLECT_HASH(CeresEngine::GPUImageLocation);
 
CE_REFLECT_HASH(CeresEngine::GPUImageRegion);
 
CE_REFLECT_HASH(CeresEngine::GPUImageSwizzleRGBA);
 
CE_REFLECT_HASH(CeresEngine::GPUImageDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUImageViewDescriptor);