RendererMesh.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/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/Mesh/Mesh.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/RenderAPI/GPUPipelineLayout.hpp"
 
namespace CeresEngine {
 
    enum class RendererMeshFlag {
        Optimized,
    };
 
    using RendererMeshFlags = Flags<RendererMeshFlag>;
    CE_FLAGS_OPERATORS(RendererMeshFlag)
 
    
    enum class RendererMeshState {
        Pending,
 
        Uploading,
 
        Relocating,
 
        Uploaded,
    };
 
    enum class RendererMeshDrawFlag {
        NoCoalescing = (1 << 0u),
 
        AssumeVertexBufferIsAlreadyBound = (1 << 1u),
 
        AssumeIndexBufferIsAlreadyBound = (1 << 2u),
 
        AssumeBuffersAreAlreadyBound = AssumeVertexBufferIsAlreadyBound | AssumeIndexBufferIsAlreadyBound,
 
        Default = 0,
    };
 
    using RendererMeshDrawFlags = Flags<RendererMeshDrawFlag>;
    CE_FLAGS_OPERATORS(RendererMeshDrawFlag);
 
    class RendererMesh : public RefCounted<RendererMesh> {
    private:
        RendererMeshManager& mManager;
 
        RendererMeshFlags mFlags;
 
        RendererMeshState mState = RendererMeshState::Pending;
 
        SPtr<Mesh> mResource;
 
        GPUVertexBuffer mVertexBuffer;
 
        GPUIndexBuffer mIndexBuffer;
 
        GPUVertexFormat mVertexFormat;
 
        VertexDeclaration mVertexDeclaration;
 
        Vector<SubMesh> mSubMeshes;
 
    public:
        explicit RendererMesh(RendererMeshManager& manager, const MeshPtr& engineMesh);
 
        ~RendererMesh();
 
    public:
        Event<void()> didChangeVertexBuffer;
 
        Event<void()> didChangeIndexBuffer;
 
    public:
        void bind(GPUCommandBuffer& commandBuffer) const;
 
        void draw(GPUCommandBuffer& commandBuffer, const Optional<const ConvexVolume&>& viewFrustum = {},
            const RendererMeshDrawFlags& flags = RendererMeshDrawFlag::Default) const;
 
        void draw(GPUCommandBuffer& commandBuffer, UInt32 subMeshIdx, const Optional<const ConvexVolume&>& viewFrustum = {},
            const RendererMeshDrawFlags& flags = RendererMeshDrawFlag::Default) const;
 
        void draw(GPUCommandBuffer& commandBuffer, const Span<UInt32>& subMeshIndices, const Optional<const ConvexVolume&>& viewFrustum = {},
            const RendererMeshDrawFlags& flags = RendererMeshDrawFlag::Default) const;
 
        void draw(GPUCommandBuffer& commandBuffer, const SubMesh& subMesh, const Optional<const ConvexVolume&>& viewFrustum = {},
            const RendererMeshDrawFlags& flags = RendererMeshDrawFlag::Default) const;
 
    public:
        [[nodiscard]] RendererMeshFlags getFlags() const noexcept { return mFlags; }
 
        [[nodiscard]] RendererMeshState getState() const noexcept { return mState; }
 
        [[nodiscard]] bool isPending() const noexcept { return mState == RendererMeshState::Pending; }
 
        [[nodiscard]] bool isUploading() const noexcept { return mState == RendererMeshState::Uploading; }
 
        [[nodiscard]] bool isRelocating() const noexcept { return mState == RendererMeshState::Relocating; }
 
        [[nodiscard]] bool isUploaded() const noexcept { return mState == RendererMeshState::Uploaded; }
 
        [[nodiscard]] bool isReady() const noexcept { return isRelocating() || isUploaded(); }
 
        [[nodiscard]] explicit operator bool() const noexcept { return isReady(); }
 
        [[nodiscard]] const SPtr<Mesh>& getResource() const noexcept { return mResource; }
 
        [[nodiscard]] const GPUVertexBuffer& getVertexBuffer() const noexcept { return mVertexBuffer; }
 
        [[nodiscard]] const GPUIndexBuffer& getIndexBuffer() const noexcept { return mIndexBuffer; }
 
        [[nodiscard]] const GPUVertexFormat& getVertexFormat() const noexcept { return mVertexFormat; }
 
        [[nodiscard]] const VertexDeclaration& getVertexDeclaration() const noexcept { return mVertexDeclaration; };
 
        [[nodiscard]] AABox getBoundingBox() const noexcept;
 
        [[nodiscard]] Sphere getBoundingSphere() const noexcept;
 
        [[nodiscard]] const Vector<SubMesh>& getSubMeshes() const noexcept { return mSubMeshes; }
 
    private:
        friend class RendererMeshManager;
 
        void setFlags(RendererMeshFlags flags);
 
        void setState(RendererMeshState state);
 
        void setBuffers(GPUVertexBuffer&& vertexBuffer, GPUIndexBuffer&& indexBuffer, const GPUVertexFormat& vertexFormat);
 
    private: // Uploading
        Async<> uploadMesh();
    };
 
    using RendererMeshPtr = RC<RendererMesh>;
 
    class RendererMeshManager {
    private:
        struct MeshInfo {
            RendererMesh* rendererMesh;
 
            bool isLoading = false;
 
            bool isLoaded = false;
        };
 
    private:
        Renderer& mRenderer [[maybe_unused]];
 
        GPUDevice& mDevice;
 
        HashMap<Mesh*, MeshInfo> mMeshes;
 
    public:
        explicit RendererMeshManager(Renderer& renderer, GPUDevice& device);
 
        ~RendererMeshManager();
 
    public:
        [[nodiscard]] GPUVertexBuffer getVertexBuffer(const HMesh& mesh);
 
        [[nodiscard]] GPUIndexBuffer getIndexBuffer(const HMesh& mesh);
 
        [[nodiscard]] RendererMeshPtr get(const MeshPtr& mesh) { return getOrCreate(mesh); }
 
    private:
        friend class RendererMesh;
 
        [[nodiscard]] RendererMeshPtr getOrCreate(const MeshPtr& mesh);
 
        [[nodiscard]] RendererMeshPtr create(const MeshPtr& mesh);
 
        void notifyDestroy(const RendererMesh* mesh) noexcept;
    };
 
} // namespace CeresEngine