MaterialAsset.h

#pragma once
#include "Engine/Core/Asset.h"
#include "Engine/Core/Settings.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Mesh/GltfLoader.h"
 
namespace Engine::Ecs
{
    class ModelAssetPipeline;
}  // namespace Engine::Ecs
 
namespace Ecs {
    class ModelAssetPipeline;
}
 
namespace Engine::Assets {
    class Material : public Asset::AssetBase {
        friend class Ecs::ModelAssetPipeline;
    public:
        explicit Material(const Asset::MeshPath &assetPath, bool initWithDefaultData = false);

        template<typename T>
        T& getData();

        void unload() override;

        [[nodiscard]] Rendering::PipelineNames getType() const { return type; }

        [[nodiscard]] const std::filesystem::path& getBaseColorTexturePath() const { return baseColorTexturePath; }

        void setBaseColorTexturePath(const std::filesystem::path& path) { baseColorTexturePath = path; }
 
        // PBR texture path accessors
        [[nodiscard]] const std::filesystem::path& getNormalTexturePath() const { return normalTexturePath; }

        [[nodiscard]] const std::filesystem::path& getMetallicRoughnessTexturePath() const { return metallicRoughnessTexturePath; }

        [[nodiscard]] const std::filesystem::path& getEmissiveTexturePath() const { return emissiveTexturePath; }

        [[nodiscard]] const std::filesystem::path& getLightmapTexturePath() const { return lightmapTexturePath; }

        void setNormalTexturePath(const std::filesystem::path& path) { normalTexturePath = path; }

        void setMetallicRoughnessTexturePath(const std::filesystem::path& path) { metallicRoughnessTexturePath = path; }

        void setEmissiveTexturePath(const std::filesystem::path& path) { emissiveTexturePath = path; }

        void setLightmapTexturePath(const std::filesystem::path& path) { lightmapTexturePath = path; }
 
        // Type-safe handle accessors (compile-time type enforcement)

        [[nodiscard]] Texture2DHandle getBaseColorTextureHandle() const { return baseColorTextureHandle_; }

        [[nodiscard]] Texture2DHandle getNormalTextureHandle() const { return normalTextureHandle_; }

        [[nodiscard]] Texture2DHandle getMetallicRoughnessTextureHandle() const { return metallicRoughnessTextureHandle_; }

        [[nodiscard]] Texture2DHandle getEmissiveTextureHandle() const { return emissiveTextureHandle_; }

        [[nodiscard]] Texture2DHandle getLightmapTextureHandle() const { return lightmapTextureHandle_; }

        void setBaseColorTextureHandle(Texture2DHandle h) { baseColorTextureHandle_ = h; }

        void setNormalTextureHandle(Texture2DHandle h) { normalTextureHandle_ = h; }

        void setMetallicRoughnessTextureHandle(Texture2DHandle h) { metallicRoughnessTextureHandle_ = h; }

        void setEmissiveTextureHandle(Texture2DHandle h) { emissiveTextureHandle_ = h; }

        void setLightmapTextureHandle(Texture2DHandle h) { lightmapTextureHandle_ = h; }
 
    protected:
        void updateLoadingState() override;
 
        Rendering::PipelineNames type = DEFAULT_MATERIAL_PIPELINE;  
        std::filesystem::path baseColorTexturePath;  
        std::filesystem::path normalTexturePath;  
        std::filesystem::path metallicRoughnessTexturePath;  
        std::filesystem::path emissiveTexturePath;  
        std::filesystem::path lightmapTexturePath;  
 
        // Type-safe texture handles for O(1) descriptor index lookup
        Texture2DHandle baseColorTextureHandle_;  
        Texture2DHandle normalTextureHandle_;  
        Texture2DHandle metallicRoughnessTextureHandle_;  
        Texture2DHandle emissiveTextureHandle_;  
        Texture2DHandle lightmapTextureHandle_;  
    };
 
    template<typename T>
    T& Material::getData() {
        return mainRegistry.get<T>(data);
    }

    class MaterialAssetManager : public Asset::AssetManager<Asset::MeshPath, Material> {
    public:
        MaterialAssetManager() = default;
    };
}