XCEngine/engine/src/Resources/Shader/ShaderLoader.cpp

#include <XCEngine/Resources/Shader/ShaderLoader.h>
#include <XCEngine/Resources/BuiltinResources.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>

namespace XCEngine {
namespace Resources {

ShaderLoader::ShaderLoader() = default;

ShaderLoader::~ShaderLoader() = default;

Containers::Array<Containers::String> ShaderLoader::GetSupportedExtensions() const {
    Containers::Array<Containers::String> extensions;
    extensions.PushBack("vert");
    extensions.PushBack("frag");
    extensions.PushBack("geom");
    extensions.PushBack("comp");
    extensions.PushBack("glsl");
    extensions.PushBack("hlsl");
    extensions.PushBack("shader");
    return extensions;
}

bool ShaderLoader::CanLoad(const Containers::String& path) const {
    if (IsBuiltinShaderPath(path)) {
        return true;
    }

    Containers::String ext = GetExtension(path);
    return ext == "vert" || ext == "frag" || ext == "geom" || 
           ext == "comp" || ext == "glsl" || ext == "hlsl" || ext == "shader";
}

LoadResult ShaderLoader::Load(const Containers::String& path, const ImportSettings* settings) {
    if (IsBuiltinShaderPath(path)) {
        return CreateBuiltinShaderResource(path);
    }

    Containers::Array<Core::uint8> data = ReadFileData(path);
    if (data.Empty()) {
        return LoadResult("Failed to read shader file: " + path);
    }
    
    Containers::String source;
    source.Reserve(data.Size());
    for (size_t i = 0; i < data.Size(); ++i) {
        source += static_cast<char>(data[i]);
    }
    
    Shader* shader = new Shader();
    shader->m_path = path;
    shader->m_name = path;
    shader->m_guid = ResourceGUID::Generate(path);
    
    Containers::String ext = GetExtension(path);
    if (ext == "hlsl") {
        shader->SetShaderLanguage(ShaderLanguage::HLSL);
    } else {
        shader->SetShaderLanguage(ShaderLanguage::GLSL);
    }
    
    ShaderType shaderType = DetectShaderType(path, source);
    shader->SetShaderType(shaderType);
    shader->SetSourceCode(source);
    
    shader->m_isValid = true;
    shader->m_memorySize = sizeof(Shader) + shader->m_name.Length() + 
                           shader->m_path.Length() + source.Length();
    
    return LoadResult(shader);
}

ImportSettings* ShaderLoader::GetDefaultSettings() const {
    return nullptr;
}

ShaderType ShaderLoader::DetectShaderType(const Containers::String& path, const Containers::String& source) {
    Containers::String ext = GetExtension(path);
    
    if (ext == "vert") return ShaderType::Vertex;
    if (ext == "frag") return ShaderType::Fragment;
    if (ext == "geom") return ShaderType::Geometry;
    if (ext == "comp") return ShaderType::Compute;
    
    return ShaderType::Fragment;
}

bool ShaderLoader::ParseShaderSource(const Containers::String& source, Shader* shader) {
    return true;
}

} // namespace Resources
} // namespace XCEngine