RendererTexture.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 "Forward.hpp"
#include "CeresEngine/Texture/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
 
namespace CeresEngine {
 
    enum class RendererTextureFlag {
        Compressed = 1u << 0u,
 
        Converted = 1u << 1u,
    };
 
    using RendererTextureFlags = Flags<RendererTextureFlag>;
    CE_FLAGS_OPERATORS(RendererTextureFlag)
 
    
    enum class RendererTextureState {
        Pending,
 
        Uploading,
 
        Relocating,
 
        Uploaded,
    };
 
    enum class RendererTextureType {
        Texture1D,
 
        Texture2D,
 
        Texture3D,
 
        CubeMap,
    };
 
    enum class RendererTextureInternalFlag {
        HasMipMaps = (1u << 0u),
    };
 
    using RendererTextureInternalFlags = Flags<RendererTextureInternalFlag>;
    CE_FLAGS_OPERATORS(RendererTextureInternalFlag)
 
    
    using RendererTextureID = UInt32;
 
    class RendererTexture : public RefCounted<RendererTexture> {
    private:
        RendererTextureManager& mManager;
 
        UInt32 mID;
 
        RendererTextureFlags mFlags;
 
        RendererTextureState mState = RendererTextureState::Pending;
 
        RendererTextureType mType = RendererTextureType::Texture2D;
 
        TexturePtr mResource;
 
        GPUImagePtr mImage;
 
    public:
        explicit RendererTexture(RendererTextureManager& manager, const TexturePtr& engineImage);
 
        ~RendererTexture();
 
    public:
        Event<void()> didChangeImage;
 
    public:
        [[nodiscard]] RendererTextureFlags getFlags() const noexcept { return mFlags; }
 
        [[nodiscard]] bool isCompressed() const noexcept { return mFlags.isSet(RendererTextureFlag::Compressed); }
 
        [[nodiscard]] bool isConverted() const noexcept { return mFlags.isSet(RendererTextureFlag::Converted); }
 
        [[nodiscard]] RendererTextureState getState() const noexcept { return mState; }
 
        [[nodiscard]] bool isPending() const noexcept { return mState == RendererTextureState::Pending; }
 
        [[nodiscard]] bool isUploading() const noexcept { return mState == RendererTextureState::Uploading; }
 
        [[nodiscard]] bool isRelocating() const noexcept { return mState == RendererTextureState::Relocating; }
 
        [[nodiscard]] bool isUploaded() const noexcept { return mState == RendererTextureState::Uploaded; }
 
        [[nodiscard]] RendererTextureType getType() const noexcept { return mType; }
 
        [[nodiscard]] bool is2D() const noexcept { return mType == RendererTextureType::Texture2D; }
 
        [[nodiscard]] bool isCubeMap() const noexcept { return mType == RendererTextureType::CubeMap; }
 
        [[nodiscard]] bool isReady() const noexcept { return isRelocating() || isUploaded(); }
 
        [[nodiscard]] explicit operator bool() const noexcept { return isReady(); }
 
        [[nodiscard]] const SPtr<Texture>& getResource() const noexcept { return mResource; }
 
        [[nodiscard]] const GPUImagePtr& getImage() const noexcept { return mImage; }
 
        [[nodiscard]] static const GPUImagePtr& getImage(const RendererTexture& texture) { return texture.getImage(); }
 
        [[nodiscard]] static GPUImagePtr getImage(const RendererTexture* const texture) { return texture != nullptr ? texture->getImage() : nullptr; }
 
        [[nodiscard]] static GPUImagePtr getImage(const RendererTexturePtr& texture) { return texture != nullptr ? texture->getImage() : nullptr; }
 
    private:
        friend class RendererTextureManager;
 
        void setFlags(RendererTextureFlags flags);
 
        void setState(RendererTextureState state);
 
        void setImage(GPUImagePtr&& image);
 
    public:
        [[nodiscard]] Async<> uploadPixelData();
    };
 
    using RendererTexturePtr = RC<RendererTexture>;
 
    class RendererTextureManager {
    private:
        struct TextureInfo {
            RendererTexture* rendererTexture;
        };
 
    private:
        Renderer& mRenderer [[maybe_unused]];
 
        GPUDevice& mDevice;
 
        HashMap<Texture*, TextureInfo> mTexturesByResource;
 
        Vector<RendererTexture*> mTextures;
 
        bool mDirty = false;
 
    private: // Bindless
        GPUResourceSetDescriptor mResourceSetDescriptor;
 
        GPUResourceSetPtr mResourceSet;
 
    public:
        explicit RendererTextureManager(Renderer& renderer, GPUDevice& device);
 
        ~RendererTextureManager();
 
    public:
        void prepare();
 
    public:
        [[nodiscard]] GPUImagePtr getImage(const TexturePtr& image);
 
        [[nodiscard]] RendererTexturePtr get(const TexturePtr& image) { return getOrCreate(image); }
 
    public: // Bindless rendering
        [[nodiscard]] GPUResourceSet& getResourceSet() const { return *mResourceSet; }
 
    public:
        [[nodiscard]] Renderer& getRenderer() const { return mRenderer; }
 
    private:
        friend class RendererTexture;
 
        [[nodiscard]] RendererTexturePtr getOrCreate(const TexturePtr& image);
 
        [[nodiscard]] RendererTexturePtr create(const TexturePtr& image);
 
        void notifyDestroy(RendererTexture* texture) noexcept;
    };
} // namespace CeresEngine