Mesh.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/asset/AssetViews.h"
#include "ncengine/ecs/Component.h"
#include "ncengine/graphics/Material.h"
#include "ncengine/graphics/SkeletalAnimationController.h"
 
namespace nc
{
namespace graphics
{
class MeshSubsystem;
} // namespace graphics
 
enum class MeshInstanceType : uint8_t
{
    Static,
    Skinned
};
 
struct MeshInstanceContext
{
    Entity entity = Entity::Null();
    asset::AssetId meshId = std::numeric_limits<uint64_t>::max();
    uint32_t transformDataHandle = std::numeric_limits<uint32_t>::max();
    uint32_t boneDataHandle = std::numeric_limits<uint32_t>::max();
    MeshInstanceType type = MeshInstanceType::Static;
};
 
class MeshBase
{
    public:
        explicit MeshBase(Entity self,
                          const asset::MeshView& meshAsset,
                          const MaterialDesc& materialDesc,
                          MeshInstanceType type);
 
        MeshBase(MeshBase&& other) noexcept
            : m_ctx{std::exchange(other.m_ctx, MeshInstanceContext{})},
              m_material{std::move(other.m_material)}
        {
        }
 
        MeshBase& operator=(MeshBase&& other) noexcept
        {
            if (this != &other)
            {
                Release();
                m_ctx = std::exchange(other.m_ctx, MeshInstanceContext{});
                m_material = std::move(other.m_material);
            }
 
            return *this;
        }
 
        MeshBase(const MeshBase&) = delete;
        MeshBase& operator=(const MeshBase&) = delete;
 
        auto GetEntity() const -> Entity { return m_ctx.entity; }
        auto GetContext() const -> const MeshInstanceContext& { return m_ctx; }
 
        auto GetMeshId() const -> uint64_t { return m_ctx.meshId; }
        void SetMesh(const asset::MeshView& meshAsset);
 
        auto GetMaterial() const -> const MaterialInstance& { return m_material; }
        auto GetMaterial() -> MaterialInstance& { return m_material; }
        void SetMaterial(const MaterialDesc& materialDesc);
 
        static void RegisterSubsystem(graphics::MeshSubsystem* subsystem)
        {
            s_subsystem = subsystem;
        }
    protected:
        ~MeshBase() noexcept
        {
            Release();
        }
 
    private:
        inline static graphics::MeshSubsystem* s_subsystem = nullptr;
        MeshInstanceContext m_ctx;
        MaterialInstance m_material;
 
        void Release() noexcept;
};
 
class StaticMesh : public MeshBase
{
    public:
        explicit StaticMesh(Entity self,
                            const asset::MeshView& meshAsset,
                            const MaterialDesc& materialDesc)
            : MeshBase{self, meshAsset, materialDesc, MeshInstanceType::Static}
        {
        }
};
 
class SkinnedMesh : public MeshBase
{
    public:
        explicit SkinnedMesh(Entity self,
                             const asset::MeshView& meshAsset,
                             const MaterialDesc& materialDesc,
                             asset::AssetId rootAnimationId = asset::NullAssetId)
            : MeshBase{self, meshAsset, materialDesc, MeshInstanceType::Skinned},
              m_controller{rootAnimationId}
        {
        }
 
        void SetMesh(const asset::MeshView& meshAsset);
 
        auto GetAnimationController() const -> const SkeletalAnimationController& { return m_controller; }
        auto GetAnimationController()       ->       SkeletalAnimationController& { return m_controller; }
 
    private:
        SkeletalAnimationController m_controller;
};
} // namespace nc