IKernelCompiler.h

#pragma once
#include <UnCompute/Base/Byte.h>
#include <UnCompute/Containers/HeapArray.h>
#include <UnCompute/Memory/Object.h>
 
namespace UN
{
    enum class KernelSourceLang
    {
        Hlsl 
    };
 
    enum class KernelTargetLang
    {
        SpirV 
    };
 
    struct KernelCompilerDesc
    {
        const char* Name            = nullptr;                 
        KernelSourceLang SourceLang = KernelSourceLang::Hlsl;  
        KernelTargetLang TargetLang = KernelTargetLang::SpirV; 
 
        inline KernelCompilerDesc() = default;
 
        inline explicit KernelCompilerDesc(const char* name, KernelSourceLang sourceLang = KernelSourceLang::Hlsl,
                                           KernelTargetLang targetLang = KernelTargetLang::SpirV)
            : Name(name)
            , SourceLang(sourceLang)
            , TargetLang(targetLang)
        {
        }
    };
 
    enum class CompilerOptimizationLevel
    {
        None,    
        O1,      
        O2,      
        O3,      
        Max = O3 
    };
 
    struct CompilerDefinition
    {
        const char* Name  = nullptr; 
        const char* Value = nullptr; 
 
        CompilerDefinition() = default;
 
        inline explicit CompilerDefinition(const char* name, const char* value = nullptr)
            : Name(name)
            , Value(value)
        {
        }
    };
 
    struct KernelCompilerArgs
    {
        ArraySlice<const Byte> SourceCode; 
        CompilerOptimizationLevel OptimizationLevel = CompilerOptimizationLevel::Max; 
        const char* EntryPoint                      = "main";                         
        ArraySlice<CompilerDefinition> Definitions;                                   
    };
 
    class IKernelCompiler : public IObject
    {
    public:
        using DescriptorType = KernelCompilerDesc;
 
        [[nodiscard]] virtual const DescriptorType& GetDesc() const = 0;
 
        virtual ResultCode Init(const DescriptorType& desc) = 0;
 
        virtual ResultCode Compile(const KernelCompilerArgs& args, HeapArray<Byte>* pResult) = 0;
    };
} // namespace UN