RendererRenderable.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/Renderer/Resources/Forward.hpp"
 
#include "RendererGeometry.hpp"
#include "RendererRenderableSettings.hpp"
#include "RendererRendering.hpp"
#include "RendererSceneObject.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/Math/Transform.hpp"
#include "CeresEngine/RenderAPI/GPUBuffer.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/Scene/Renderable.hpp"
 
namespace CeresEngine {
 
    CE_DECL_RENDERER_OBJECT(RendererRenderable);
 
    enum class RendererRenderableFlag {
    };
 
    using RendererRenderableFlags = Flags<RendererRenderableFlag>;
    CE_FLAGS_OPERATORS(RendererRenderableFlag)
 
    
    enum class RendererRenderableDirtyFlag {
        None = 0,
 
        Transform = (1u << 0u),
 
        Component = (1u << 1u),
 
        UniformBuffer = (1u << 2u),
 
        Flags = (1u << 3u),
 
        All = 0xFFFF,
    };
 
    using RendererRenderableDirtyFlags = Flags<RendererRenderableDirtyFlag>;
    CE_FLAGS_OPERATORS(RendererRenderableDirtyFlag)
 
    
    struct RendererRenderableParams {
        alignas(4) UInt32 type;
 
        alignas(16) Vector3f position;
 
        alignas(16) Matrix4f model;
        alignas(16) Matrix4f invModel;
 
        alignas(16) Matrix4f normalMatrix;
        alignas(16) Matrix4f invNormalMatrix;
    };
 
    struct RendererRenderableInfo {
        Matrix4 model, invModel;
 
        Matrix3 normalMatrix, invNormalMatrix;
 
        AABox boundingBox;
 
        Sphere boundingSphere;
    };
 
    class RendererRenderable final : public TRendererSceneObject<RendererRenderable>, public IRendererGeometryProvider {
        using super = TRendererSceneObject<RendererRenderable>;
        friend class RendererRenderableManager;
 
    public:
        class Element;
 
    private:
        RenderableComponent mComponent;
 
        RendererRenderableFlags mFlags;
 
        RendererRenderableDirtyFlags mDirtyFlags = RendererRenderableDirtyFlag::All;
 
        RendererRenderableInfo mInfo;
 
        RendererRenderableParams mParameters;
 
        GPUDynamicBindlessBuffer<RendererRenderableParams> mUniformBuffer;
 
        RendererMeshPtr mMesh;
 
        Vector<SPtr<RendererMaterial>> mMaterial;
 
        Vector<Element> mRenderElements;
 
        Vector<SubMesh> mSubMeshes;
 
    private:
        EventConnection mOnVertexBufferChangedConnection;
 
        EventConnection mOnIndexBufferChangedConnection;
 
    public:
        explicit RendererRenderable(RendererRenderableManager& manager, RendererScene& scene);
 
        ~RendererRenderable() noexcept final;
 
    public:
        void synchronize(const Transform& trasnform, const RenderableComponent& component);
 
        void prepare(RendererContext& context);
 
        void draw(GPUCommandBuffer& commandBuffer, const ConvexVolume* viewFrustum = nullptr) const;
 
        void draw(GPUCommandBuffer& commandBuffer, UInt32 subMeshIndex) const;
 
        void drawMeshOnly(GPUCommandBuffer& commandBuffer, const ConvexVolume* viewFrustum = nullptr) const;
 
    public:
        [[nodiscard]] const RendererRenderableSettings& getSettings() const { return mComponent.rendererSettings; }
 
        [[nodiscard]] const RendererRenderableFlags& getFlags() const noexcept { return mFlags; }
 
        void setFlags(const RendererRenderableFlags& flags);
 
        [[nodiscard]] const RendererRenderableDirtyFlags& getDirtyFlags() const noexcept { return mDirtyFlags; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirtyFlags != RendererRenderableDirtyFlag::None; }
 
        void markAsDirty(const RendererRenderableDirtyFlags& flags = RendererRenderableDirtyFlag::All) noexcept;
 
        [[nodiscard]] const RendererRenderableInfo& getInfo() const { return mInfo; }
 
        [[nodiscard]] RendererRenderableInfo& getInfo() { return mInfo; }
 
        [[nodiscard]] const Vector<Element>& getRenderElements() const { return mRenderElements; }
 
        [[nodiscard]] const GPUBindlessBuffer& getUniformBuffer() const { return mUniformBuffer; }
 
        [[nodiscard]] const GPUVertexBuffer& getVertexBuffer() const;
 
        [[nodiscard]] const GPUIndexBuffer& getIndexBuffer() const;
 
        [[nodiscard]] const RendererMeshPtr& getRendererMesh() const { return mMesh; }
        [[nodiscard]] const HMesh& getMesh() const { return mComponent.mesh; }
 
        [[nodiscard]] Material& getMaterial() const;
        [[nodiscard]] RendererMaterial& getRendererMaterial(UInt32 subMesh) const;
        [[nodiscard]] const Vector<SPtr<RendererMaterial>>& getRendererMaterials() const { return mMaterial; }
 
        [[nodiscard]] const AABox& getBoundingBox() const { return mInfo.boundingBox; }
 
        [[nodiscard]] const Sphere& getBoundingSphere() const { return mInfo.boundingSphere; }
 
    public:
        [[nodiscard]] bool frustumCull(const ConvexVolume& frustum) const noexcept;
 
        [[nodiscard]] bool frustumCull(const ConvexVolume& frustum, UInt32 subMeshIndex) const noexcept;
 
    public: // IRendererGeometryProvider
        [[nodiscard]] Generator<RendererGeometry> enumerateGeometry(
            const RendererGeometryEnumerationRequest& enumerationRequest = RendererGeometryEnumerationRequest()) const final;
 
    private:
        void onVertexBufferChanged();
 
        void onIndexBufferChanged();
 
    public:
        class Element final : public RendererElement {
        private:
            RendererRenderable& mRenderable;
 
            SubMesh mSubMesh;
 
            UInt32 mSubMeshIndex;
 
        public:
            explicit Element(RendererRenderable& renderable, const SubMesh& subMesh, UInt32 subMeshIndex);
            ~Element() final = default;
 
        public:
            [[nodiscard]] const GPUVertexFormat& getVertexFormat() const noexcept final;
 
            void draw(GPUCommandBuffer& commandBuffer) const final;
 
            [[nodiscard]] const GPUVertexBuffer& getVertexBuffer() const noexcept final { return mRenderable.getVertexBuffer(); }
 
            [[nodiscard]] const GPUIndexBuffer& getIndexBuffer() const noexcept final { return mRenderable.getIndexBuffer(); }
 
            [[nodiscard]] const RendererMaterial& getMaterial() const noexcept final;
 
            [[nodiscard]] AABox getBoundingBox() const final { return mRenderable.mTransform * mSubMesh.boundingBox; }
 
            [[nodiscard]] Sphere getBoundingSphere() const final { return mRenderable.mTransform * mSubMesh.boundingSphere; }
        };
    };
 
    class RendererRenderableManager final : public TRendererSceneObjectManager<RendererRenderableManager, RendererRenderable> {
        using super = TRendererSceneObjectManager<RendererRenderableManager, RendererRenderable>;
 
    private:
        using UniformBufferType = GPUDynamicStridedBindlessBufferArray<RendererRenderableParams>;
 
        Vector<UPtr<RendererRenderable>> mRenderables;
 
        HashSet<RendererRenderable*> mDirtyRenderables;
 
        UniformBufferType mUniformBuffer;
 
    public:
        explicit RendererRenderableManager(Renderer& renderer);
 
        ~RendererRenderableManager() noexcept final;
 
    public:
        Async<> prepare(RendererContext& context);
 
    private: // Renderable interface
        friend class RendererRenderable;
 
        void markAsDirty(RendererRenderable* const renderable);
    };
 
} // namespace CeresEngine