Mesh.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 "PrimitiveTopology.hpp"
#include "VertexDeclaration.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
#include "CeresEngine/Foundation/Container/Span.hpp"
 
#include "CeresEngine/Math/Geometry.hpp"
#include "CeresEngine/RenderAPI/GPUBufferObject.hpp"
#include "CeresEngine/Resource/Resource.hpp"
 
namespace CeresEngine {
 
    using RawVertexBufferView = MemoryView<Byte>;
    using ConstRawVertexBufferView = MemoryView<const Byte>;
 
    template<typename T> using VertexBufferView = StridedMemoryView<T>;
    template<typename T> using ConstVertexBufferView = VertexBufferView<const T>;
 
    using RawIndexBufferView = MemoryView<Byte>;
    using ConstRawIndexBufferView = MemoryView<const Byte>;
 
    template<typename T> using IndexBufferView = StridedMemoryView<T>;
    template<typename T> using ConstIndexBufferView = IndexBufferView<const T>;
 
    using VertexCount = unsigned int;
 
    using VertexIndex = unsigned int;
 
    using VertexIndexSet = Vector<VertexIndex>;
 
    struct Vertex {
        Vector3f position;
 
        Vector3f normal;
 
        Vector2f texCoords;
 
        Vector3f tangent;
 
        Vector3f bitangent;
    };
 
    struct SubMesh {
        UInt32 indexOffset = 0;
 
        VertexCount indexCount = 0;
 
        PrimitiveTopology primitiveTopology = PrimitiveTopology::Triangles;
 
        Sphere boundingSphere;
 
        AABox boundingBox;
    };
 
    struct MeshProperties {
        VertexCount vertexCount = 0;
 
        Vector<SubMesh> subMeshes;
 
        VertexDeclaration vertexDeclaration;
 
        IndexType indexType = IndexType::UInt32;
 
        Sphere boundingSphere;
 
        AABox boundingBox;
    };
 
    class Mesh : public TResource<Mesh> {
        using super = TResource<Mesh>;
        CE_META_CLASS_FRIEND(Mesh);
 
    public:
        MeshProperties mProperties;
 
    public:
        explicit Mesh();
 
        explicit Mesh(MeshProperties&& properties);
 
        ~Mesh() override;
 
    public:
        [[nodiscard]] virtual ConstRawVertexBufferView getRawVertexBufferView() const = 0;
 
        template<typename T> [[nodiscard]] VertexBufferView<const T> getVertexBufferView() const {
            const size_t stride = mProperties.vertexDeclaration.getSize();
            CE_ASSERT(stride >= sizeof(T));
            return VertexBufferView<const T>(getRawVertexBufferView().as<const T>(), stride);
        }
 
        [[nodiscard]] virtual ConstRawIndexBufferView getRawIndexBufferView() const = 0;
 
        template<typename T> [[nodiscard]] IndexBufferView<const T> getIndexBufferView() const {
            const size_t stride = mProperties.indexType.getSize();
            CE_ASSERT(stride == sizeof(T));
            return IndexBufferView<const T>(getRawIndexBufferView().as<const T>(), stride);
        }
 
    public:
        [[nodiscard]] const MeshProperties& getProperties() const noexcept { return mProperties; }
 
        [[nodiscard]] const Vector<SubMesh>& getSubMeshes() const { return mProperties.subMeshes; }
 
        [[nodiscard]] const VertexDeclaration& getVertexDeclaration() const { return mProperties.vertexDeclaration; }
 
        [[nodiscard]] const IndexType& getIndexType() const { return mProperties.indexType; }
 
        [[nodiscard]] const Sphere& getBoundingSphere() const { return mProperties.boundingSphere; }
 
        [[nodiscard]] const AABox& getBoundingBox() const { return mProperties.boundingBox; }
 
    protected:
        void recalculateMeshBounds();
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            RTTI.property("properties", &Mesh::mProperties);
        }
    };
 
    class MemoryMesh final : public TResource<MemoryMesh, Mesh> {
        using super = TResource<MemoryMesh, Mesh>;
        CE_META_CLASS_FRIEND(MemoryMesh);
 
    public:
        Vector<Byte> mVertexData;
 
        Vector<Byte> mIndexData;
 
    public:
        explicit MemoryMesh(Vector<Byte> vertexBuffer, MeshProperties&& properties);
 
        explicit MemoryMesh(Vector<Byte> vertexBuffer, Vector<Byte> indexBuffer, MeshProperties&& properties);
 
        explicit MemoryMesh(MemoryView<const Byte> vertexBuffer, MeshProperties&& properties);
 
        explicit MemoryMesh(MemoryView<const Byte> vertexBuffer, MemoryView<const Byte> indexBuffer, MeshProperties&& properties);
 
        explicit MemoryMesh(Vector<Byte> vertexBuffer, VertexDeclaration vertexDeclaration, Vector<SubMesh> subMeshes)
                : MemoryMesh(std::move(vertexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                      }) {}
 
        explicit MemoryMesh(Vector<Byte> vertexBuffer, VertexDeclaration vertexDeclaration, Vector<Byte> indexBuffer, const IndexType indexType,
            Vector<SubMesh> subMeshes)
                : MemoryMesh(std::move(vertexBuffer), std::move(indexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                          .indexType = indexType,
                      }) {}
 
        explicit MemoryMesh(Vector<Byte> vertexBuffer, const VertexDeclaration& vertexDeclaration, Vector<Byte> indexBuffer, const Vector<SubMesh> subMeshes)
                : MemoryMesh(std::move(vertexBuffer), std::move(indexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                          .indexType = IndexType::UInt32,
                      }) {}
 
    private:
        explicit MemoryMesh() = default;
 
    public:
        [[nodiscard]] ConstRawVertexBufferView getRawVertexBufferView() const final { return mVertexData; }
 
        [[nodiscard]] ConstRawIndexBufferView getRawIndexBufferView() const final { return mIndexData; }
 
    public:
        [[nodiscard]] MemoryView<const Byte> getVertexBuffer() const noexcept { return mVertexData; }
 
        [[nodiscard]] MemoryView<const Byte> getIndexBuffer() const noexcept { return mIndexData; }
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            RTTI.property("vertexData", &MemoryMesh::mVertexData);
            RTTI.property("indexData", &MemoryMesh::mIndexData);
        }
    };
 
    class StreamingMesh final : public TResource<StreamingMesh, Mesh> {
        using super = TResource<StreamingMesh, Mesh>;
        CE_META_CLASS_FRIEND(StreamingMesh);
 
    public:
        explicit StreamingMesh(Vector<Byte> vertexBuffer, MeshProperties&& properties);
 
        explicit StreamingMesh(Vector<Byte> vertexBuffer, Vector<Byte> indexBuffer, MeshProperties&& properties);
 
        explicit StreamingMesh(MemoryView<const Byte> vertexBuffer, MeshProperties&& properties);
 
        explicit StreamingMesh(MemoryView<const Byte> vertexBuffer, MemoryView<const Byte> indexBuffer, MeshProperties&& properties);
 
        explicit StreamingMesh(Vector<Byte> vertexBuffer, VertexDeclaration vertexDeclaration, Vector<SubMesh> subMeshes)
                : StreamingMesh(std::move(vertexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                      }) {}
 
        explicit StreamingMesh(Vector<Byte> vertexBuffer, VertexDeclaration vertexDeclaration, Vector<Byte> indexBuffer, const IndexType indexType,
            Vector<SubMesh> subMeshes)
                : StreamingMesh(std::move(vertexBuffer), std::move(indexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                          .indexType = indexType,
                      }) {}
 
        explicit StreamingMesh(Vector<Byte> vertexBuffer, const VertexDeclaration& vertexDeclaration, Vector<Byte> indexBuffer, const Vector<SubMesh> subMeshes)
                : StreamingMesh(std::move(vertexBuffer), std::move(indexBuffer),
                      MeshProperties{
                          .subMeshes = std::move(subMeshes),
                          .vertexDeclaration = std::move(vertexDeclaration),
                          .indexType = IndexType::UInt32,
                      }) {}
 
    public:
        [[nodiscard]] ConstRawVertexBufferView getRawVertexBufferView() const final { return {}; }
 
        [[nodiscard]] ConstRawIndexBufferView getRawIndexBufferView() const final { return {}; }
 
    public:
        [[nodiscard]] MemoryView<const Byte> getVertexBuffer() const noexcept { return {}; }
 
        [[nodiscard]] MemoryView<const Byte> getIndexBuffer() const noexcept { return {}; }
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
        }
    };
 
    class GPUMesh final : public TResource<GPUMesh, Mesh> {
        using super = TResource<GPUMesh, Mesh>;
        CE_META_CLASS_FRIEND(GPUMesh);
 
    private:
        GPUVertexBuffer mVertexBuffer;
 
        GPUIndexBuffer mIndexBuffer;
 
        //        /// The GPU memory mapped buffer pointer.
        //        void* mVertexGPUBufferPtr = nullptr;
        //
        //        /// The GPU memory mapped buffer pointer.
        //        void* mIndexGPUBufferPtr = nullptr;
 
    public:
        explicit GPUMesh(const GPUVertexBuffer& vertexBuffer, VertexDeclaration vertexDeclaration, Vector<SubMesh> subMeshes);
 
        explicit GPUMesh(const GPUVertexBuffer& vertexBuffer, VertexDeclaration vertexDeclaration, const GPUIndexBuffer& indexBuffer, IndexType indexType,
            Vector<SubMesh> subMeshes);
 
        explicit GPUMesh(const GPUVertexBuffer& vertexBuffer, const VertexDeclaration& vertexDeclaration, const GPUIndexBuffer& indexBuffer,
            const Vector<SubMesh> subMeshes)
                : GPUMesh(vertexBuffer, vertexDeclaration, indexBuffer, IndexType::UInt32, subMeshes) {}
 
    public:
        [[nodiscard]] ConstRawVertexBufferView getRawVertexBufferView() const final { return ConstRawVertexBufferView(); }
 
        [[nodiscard]] ConstRawIndexBufferView getRawIndexBufferView() const final { return ConstRawIndexBufferView(); }
 
    public:
        [[nodiscard]] const GPUVertexBuffer& getVertexBuffer() const noexcept { return mVertexBuffer; }
 
        [[nodiscard]] const GPUIndexBuffer& getIndexBuffer() const noexcept { return mIndexBuffer; }
    };
 
} // namespace CeresEngine