MaterialAsset.h

Go to the documentation of this file.

#pragma once
#include "Engine/Core/Asset.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Texture/TextureHandle.h"
 
namespace Ecs {
    class ModelAssetPipeline;
}
 
namespace EngineCore {
    class MaterialAsset : public Asset::AssetBase {
        friend class Ecs::ModelAssetPipeline;
    public:
        explicit MaterialAsset(const Asset::Path &assetPath, bool initWithDefaultData = false);

        template<typename T>
        T& getData();

        void unload() override;

        [[nodiscard]] 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]] AlbedoTextureHandle getBaseColorTextureHandle() const { return baseColorTextureHandle_; }

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

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

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

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

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

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

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

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

        void setLightmapTextureHandle(LightmapTextureHandle h) { lightmapTextureHandle_ = h; }
 
    protected:
        void updateLoadingState() override;
 
        PipelineNames type = NORMALS_SHADER;
        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
        AlbedoTextureHandle baseColorTextureHandle_;
        NormalTextureHandle normalTextureHandle_;
        MetallicRoughnessTextureHandle metallicRoughnessTextureHandle_;
        EmissiveTextureHandle emissiveTextureHandle_;
        LightmapTextureHandle lightmapTextureHandle_;
    };
 
    template<typename T>
    T& MaterialAsset::getData() {
        return mainRegistry.get<T>(data);
    }
 
    class MaterialAssetManager : public Asset::AssetManager<Asset::Path, MaterialAsset> {
    public:
        MaterialAssetManager() = default;
    };
}