IDeviceFactory.h

#pragma once
#include <UnCompute/Acceleration/AdapterInfo.h>
#include <UnCompute/Memory/Object.h>
#include <UnCompute/Utils/DynamicLibrary.h>
#include <UnCompute/Containers/ArraySlice.h>
 
namespace UN
{
    enum class BackendKind
    {
        Cpu,   
        Vulkan 
    };
 
    struct DeviceFactoryDesc
    {
        const char* ApplicationName; 
 
        inline explicit DeviceFactoryDesc(const char* applicationName)
            : ApplicationName(applicationName)
        {
        }
    };
 
    class IKernelCompiler;
    class IComputeDevice;
    struct ComputeDeviceDesc;
 
    class IDeviceFactory : public IObject
    {
    public:
        virtual ResultCode Init(const DeviceFactoryDesc& desc) = 0;
 
        virtual void Reset() = 0;
 
        [[nodiscard]] virtual BackendKind GetBackendKind() const = 0;
 
        [[nodiscard]] virtual ArraySlice<const AdapterInfo> EnumerateAdapters() = 0;
 
        virtual ResultCode CreateDevice(IComputeDevice** ppDevice) = 0;
 
        virtual ResultCode CreateKernelCompiler(IKernelCompiler** ppCompiler) = 0;
    };
 
    inline constexpr const char* CreateDeviceFactoryProcName = "CreateDeviceFactoryImpl";
    inline constexpr const char* UraniumComputeDllName       = "UnCompute";
 
    extern "C"
    {
        typedef ResultCode (*CreateDeviceFactoryProc)(BackendKind backendKind, IDeviceFactory** ppDeviceFactory);
    }
 
    inline ResultCode LoadCreateDeviceFactoryProc(DynamicLibrary** ppLibrary, CreateDeviceFactoryProc* pCreateDeviceFactoryProc)
    {
        // TODO: this function requires us to add DynamicLibrary.h include here which requires to include windows.h
        // and it's not desired. We can possibly create another STATIC library in the future dedicated for
        // DynamicLibrary class to avoid including platform headers.
 
        auto resultCode = DynamicLibrary::Create(ppLibrary);
        if (Failed(resultCode))
        {
            return resultCode;
        }
 
        resultCode = (*ppLibrary)->Init(UraniumComputeDllName);
        if (Failed(resultCode))
        {
            UN_Error(false, "Couldn't load {} library", UraniumComputeDllName);
            return resultCode;
        }
 
        resultCode = (*ppLibrary)->GetFunction(CreateDeviceFactoryProcName, pCreateDeviceFactoryProc);
        if (Failed(resultCode))
        {
            UN_Error(false,
                     "Couldn't get the entry point named \"{}\" in \"{}\" library",
                     CreateDeviceFactoryProcName,
                     UraniumComputeDllName);
            return resultCode;
        }
 
        return resultCode;
    }
} // namespace UN