RendererTerrain.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 "CeresEngine/Renderer/Forward.hpp"
 
#include "RendererRendering.hpp"
#include "RendererSceneObject.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Math/Transform.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
 
#include "CeresEngine/Scene/Terrain/TerrainRenderable.hpp"
 
namespace CeresEngine {
 
    CE_DECL_RENDERER_OBJECT(RendererTerrain);
 
    class RendererTerrainChunk;
 
    enum class RendererTerrainFlag {
    };
 
    using RendererTerrainFlags = Flags<RendererTerrainFlag>;
    CE_FLAGS_OPERATORS(RendererTerrainFlag)
 
    
    enum class RendererTerrainDirtyFlag {
        None = 0,
 
        Transform = (1u << 0u),
 
        Component = (1u << 1u),
 
        UniformBuffer = (1u << 2u),
 
        Flags = (1u << 3u),
 
        All = 0xFFFF,
    };
 
    using RendererTerrainDirtyFlags = Flags<RendererTerrainDirtyFlag>;
    CE_FLAGS_OPERATORS(RendererTerrainDirtyFlag)
 
    
    struct RendererTerrainParams final {
        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 RendererTerrainInfo final {};
 
    class RendererTerrain final : public TRendererSceneObject<RendererTerrain> {
        using super = TRendererSceneObject<RendererTerrain>;
        friend class RendererTerrainManager;
 
    private:
        class Element;
 
        TerrainRenderableComponent mComponent;
 
        RendererTerrainFlags mFlags;
 
        RendererTerrainDirtyFlags mDirtyFlags = RendererTerrainDirtyFlag::All;
 
        bool mDirty = true;
 
        RendererTerrainInfo mInfo;
 
        RendererTerrainParams mParameters;
 
        GPUDynamicBindlessBuffer<RendererTerrainParams> mUniformBuffer;
 
        SPtr<RendererMaterial> mMaterial;
        Vector<UPtr<Element>> mElements;
 
        bool mInitialized = false;
 
    public:
        explicit RendererTerrain(RendererTerrainManager& manager, RendererScene& scene);
 
        ~RendererTerrain() noexcept final;
 
    public:
        void synchronize(const Transform& transform, const TerrainRenderableComponent& component);
 
        void prepare(RendererContext& context);
 
        void draw(GPUCommandBuffer& commandBuffer);
 
    public:
        [[nodiscard]] const RendererTerrainFlags& getFlags() const noexcept { return mFlags; }
 
        void setFlags(const RendererTerrainFlags& flags);
 
        [[nodiscard]] const RendererTerrainDirtyFlags& getDirtyFlags() const noexcept { return mDirtyFlags; }
 
        [[nodiscard]] bool isDirty() const noexcept { return mDirtyFlags != RendererTerrainDirtyFlag::None; }
 
        void markAsDirty(const RendererTerrainDirtyFlags& flags = RendererTerrainDirtyFlag::All) noexcept;
 
        [[nodiscard]] const RendererTerrainInfo& getInfo() const { return mInfo; }
 
        [[nodiscard]] RendererTerrainInfo& getInfo() { return mInfo; }
 
        [[nodiscard]] const GPUBindlessBuffer& getUniformBuffer() const { return mUniformBuffer; }
 
        [[nodiscard]] const SPtr<RendererMaterial>& getMaterial() const noexcept { return mMaterial; }
 
        [[nodiscard]] const Vector<UPtr<Element>>& getElements() const noexcept { return mElements; }
 
    private:
        class Element final : public RendererElement {
        private:
            RendererTerrain& mTerrain;
 
            Vector3i mPosition [[maybe_unused]];
            RendererMeshPtr mMesh;
 
        public:
            explicit Element(RendererTerrain& terrain, MeshPtr mesh);
            ~Element() final = default;
 
        public:
            [[nodiscard]] const GPUVertexFormat& getVertexFormat() const noexcept final;
 
            void draw(GPUCommandBuffer& commandBuffer) const final;
 
            [[nodiscard]] const GPUVertexBuffer& getVertexBuffer() const noexcept final;
 
            [[nodiscard]] const GPUIndexBuffer& getIndexBuffer() const noexcept final;
 
            [[nodiscard]] const RendererMeshPtr& getMesh() const noexcept { return mMesh; }
 
            [[nodiscard]] const RendererMaterial& getMaterial() const noexcept final { return *mTerrain.mMaterial; }
 
            [[nodiscard]] AABox getBoundingBox() const final;
 
            [[nodiscard]] Sphere getBoundingSphere() const final;
        };
    };
 
    class RendererTerrainManager final : public TRendererSceneObjectManager<RendererTerrainManager, RendererTerrain> {
        using super = TRendererSceneObjectManager<RendererTerrainManager, RendererTerrain>;
 
    private:
        using UniformBufferType = GPUDynamicStridedBindlessBufferArray<RendererTerrainParams>;
 
        Vector<UPtr<RendererTerrain>> mTerrains;
 
        UniformBufferType mUniformBuffer;
 
    public:
        explicit RendererTerrainManager(Renderer& renderer);
 
        ~RendererTerrainManager();
 
    public:
        Async<> prepare(RendererContext& context);
 
    private: // Terrain interface
        friend class RendererTerrain;
 
        void markAsDirty(RendererTerrain* const terrain);
    };
 
} // namespace CeresEngine