/// Vulkan implementation of GrAAL
module gfx.vulkan;

import gfx.bindings.vulkan;
import gfx.core.log : LogTag;
import gfx.graal;

enum gfxVkLogMask = 0x2000_0000;
package(gfx) immutable gfxVkLog = LogTag("GFX-VK", gfxVkLogMask);

// some standard layers

enum lunarGValidationLayers = [
    "VK_LAYER_LUNARG_core_validation",
    "VK_LAYER_LUNARG_standard_validation",
    "VK_LAYER_LUNARG_parameter_validation",
];

@property ApiProps vulkanApiProps() {
    return ApiProps(
        "vulkan", CoordSystem.rightHanded
    );
}

/// Load global level vulkan functions, and instance level layers and extensions
/// This function must be called before any other in this module
void vulkanInit()
{
    synchronized {
        _globCmds = loadVulkanGlobalCmds();
        _instanceLayers = loadInstanceLayers();
        _instanceExtensions = loadInstanceExtensions();
    }
}

struct VulkanVersion
{
    import std.bitmanip : bitfields;
    mixin(bitfields!(
        uint, "patch", 12,
        uint, "minor", 10,
        uint, "major", 10,
    ));

    this (in uint major, in uint minor, in uint patch) {
        this.major = major; this.minor = minor; this.patch = patch;
    }

    this (in uint vkVer) {
        this(VK_VERSION_MAJOR(vkVer), VK_VERSION_MINOR(vkVer), VK_VERSION_PATCH(vkVer));
    }

    static VulkanVersion fromUint(in uint vkVer) {
        return *cast(VulkanVersion*)(cast(void*)&vkVer);
    }

    uint toUint() const {
        return *cast(uint*)(cast(void*)&this);
    }

    string toString() {
        import std.format : format;
        return format("VulkanVersion(%s, %s, %s)", this.major, this.minor, this.patch);
    }
}

unittest {
    const vkVer = VK_MAKE_VERSION(12, 7, 38);
    auto vv = VulkanVersion.fromUint(vkVer);
    assert(vv.major == 12);
    assert(vv.minor == 7);
    assert(vv.patch == 38);
    assert(vv.toUint() == vkVer);
}

struct VulkanLayerProperties
{
    string layerName;
    VulkanVersion specVer;
    VulkanVersion implVer;
    string description;

    @property VulkanExtensionProperties[] instanceExtensions()
    {
        return loadInstanceExtensions(layerName);
    }
}

struct VulkanExtensionProperties
{
    string extensionName;
    VulkanVersion specVer;
}

/// Retrieve available instance level layer properties
@property VulkanLayerProperties[] vulkanInstanceLayers() {
    return _instanceLayers;
}
/// Retrieve available instance level extensions properties
@property VulkanExtensionProperties[] vulkanInstanceExtensions()
{
    return _instanceExtensions;
}

/// Creates a vulkan instance with default layers and extensions
VulkanInstance createVulkanInstance(in string appName=null,
                                    in VulkanVersion appVersion=VulkanVersion(0, 0, 0))
{
    debug {
        const wantedLayers = lunarGValidationLayers;
        const wantedExts = [ "VK_KHR_debug_report", "VK_EXT_debug_report" ];
    }
    else {
        const string[] wantedLayers = [];
        const string[] wantedExts = [];
    }

    import gfx.vulkan.wsi : surfaceInstanceExtensions;

    import std.algorithm : canFind, filter, map;
    import std.array : array;
    import std.range : chain;

    const layers = wantedLayers
            .filter!(l => _instanceLayers.map!(il => il.layerName).canFind(l))
            .array;
    const exts = wantedExts
            .filter!(e => _instanceExtensions.map!(ie => ie.extensionName).canFind(e))
            .array
        ~ surfaceInstanceExtensions;

    return createVulkanInstance(layers, exts, appName, appVersion);
}

/// Creates an Instance object with Vulkan backend with user specified layers and extensions
VulkanInstance createVulkanInstance(in string[] layers, in string[] extensions,
                                    in string appName=null,
                                    in VulkanVersion appVersion=VulkanVersion(0, 0, 0))
{
    import gfx : gfxVersionMaj, gfxVersionMin, gfxVersionMic;
    import std.algorithm : all, canFind, map;
    import std.array : array;
    import std.exception : enforce;
    import std.string : toStringz;

    // throw if some requested layers or extensions are not available
    // TODO: specific exception
    foreach (l; layers) {
        enforce(
            _instanceLayers.map!(il => il.layerName).canFind(l),
            "Could not find layer " ~ l ~ " when creating Vulkan instance"
        );
    }
    foreach (e; extensions) {
        enforce(
            _instanceExtensions.map!(ie => ie.extensionName).canFind(e),
            "Could not find extension " ~ e ~ " when creating Vulkan instance"
        );
    }

    VkApplicationInfo ai;
    ai.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    if (appName.length) {
        ai.pApplicationName = toStringz(appName);
    }
    ai.applicationVersion = appVersion.toUint();
    ai.pEngineName = "gfx-d\0".ptr;
    ai.engineVersion = VK_MAKE_VERSION(gfxVersionMaj, gfxVersionMin, gfxVersionMic);
    ai.apiVersion = VK_API_VERSION_1_0;

    auto vkLayers = layers.map!toStringz.array;
    auto vkExts = extensions.map!toStringz.array;

    gfxVkLog.info("Opening Vulkan instance.");
    gfxVkLog.infof("Vulan layers:%s", layers.length?"":" none");
    foreach (l; layers) {
        gfxVkLog.infof("    %s", l);
    }
    gfxVkLog.infof("Vulan extensions:%s", extensions.length?"":" none");
    foreach (e; extensions) {
        gfxVkLog.infof("    %s", e);
    }



    VkInstanceCreateInfo ici;
    ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    ici.pApplicationInfo = &ai;
    ici.enabledLayerCount = cast(uint)vkLayers.length;
    ici.ppEnabledLayerNames = vkLayers.ptr;
    ici.enabledExtensionCount = cast(uint)vkExts.length;
    ici.ppEnabledExtensionNames = vkExts.ptr;

    auto vk = _globCmds;
    VkInstance vkInst;
    vulkanEnforce(vk.CreateInstance(&ici, null, &vkInst), "Could not create Vulkan instance");

    return new VulkanInstance(vkInst);
}

/// Retrieve available device level layers
@property VulkanLayerProperties[] vulkanDeviceLayers(PhysicalDevice device) {
    auto pd = cast(VulkanPhysicalDevice)device;
    if (!pd) return [];

    return pd._availableLayers;
}
/// Retrieve available instance level extensions properties
VulkanExtensionProperties[] vulkanDeviceExtensions(PhysicalDevice device, in string layerName=null)
{
    auto pd = cast(VulkanPhysicalDevice)device;
    if (!pd) return [];

    if (!layerName) {
        return pd._availableExtensions;
    }
    else {
        return pd.loadDeviceExtensions(layerName);
    }
}

void overrideDeviceOpenVulkanLayers(PhysicalDevice device, string[] layers)
{
    auto pd = cast(VulkanPhysicalDevice)device;
    if (!pd) return;

    pd._openLayers = layers;
}

void overrideDeviceOpenVulkanExtensions(PhysicalDevice device, string[] extensions)
{
    auto pd = cast(VulkanPhysicalDevice)device;
    if (!pd) return;

    pd._openExtensions = extensions;
}


package:

import gfx.core.rc;
import gfx.graal.device;
import gfx.graal.format;
import gfx.graal.memory;
import gfx.graal.presentation;
import gfx.graal.queue;
import gfx.vulkan.conv;
import gfx.vulkan.device;
import gfx.vulkan.error;
import gfx.vulkan.wsi : VulkanSurface;

import std.exception : enforce;

__gshared VkGlobalCmds _globCmds;
__gshared VulkanLayerProperties[] _instanceLayers;
__gshared VulkanExtensionProperties[] _instanceExtensions;

VulkanLayerProperties[] loadInstanceLayers()
{
    auto vk = _globCmds;
    uint count;
    vulkanEnforce(
        vk.EnumerateInstanceLayerProperties(&count, null),
        "Could not retrieve Vulkan instance layers"
    );
    if (!count) return[];

    auto vkLayers = new VkLayerProperties[count];
    vulkanEnforce(
        vk.EnumerateInstanceLayerProperties(&count, &vkLayers[0]),
        "Could not retrieve Vulkan instance layers"
    );

    import std.algorithm : map;
    import std.array : array;
    import std.string : fromStringz;

    return vkLayers
            .map!((ref VkLayerProperties vkLp) {
                return VulkanLayerProperties(
                    fromStringz(&vkLp.layerName[0]).idup,
                    VulkanVersion.fromUint(vkLp.specVersion),
                    VulkanVersion.fromUint(vkLp.implementationVersion),
                    fromStringz(&vkLp.description[0]).idup,
                );
            })
            .array;
}

VulkanExtensionProperties[] loadInstanceExtensions(in string layerName=null)
{
    import std.string : toStringz;

    const(char)* layer;
    if (layerName.length) {
        layer = toStringz(layerName);
    }
    auto vk = _globCmds;
    uint count;
    vulkanEnforce(
        vk.EnumerateInstanceExtensionProperties(layer, &count, null),
        "Could not retrieve Vulkan instance extensions"
    );
    if (!count) return[];

    auto vkExts = new VkExtensionProperties[count];
    vulkanEnforce(
        vk.EnumerateInstanceExtensionProperties(layer, &count, &vkExts[0]),
        "Could not retrieve Vulkan instance extensions"
    );

    import std.algorithm : map;
    import std.array : array;
    import std.string : fromStringz;

    return vkExts
            .map!((ref VkExtensionProperties vkExt) {
                return VulkanExtensionProperties(
                    fromStringz(&vkExt.extensionName[0]).idup,
                    VulkanVersion.fromUint(vkExt.specVersion)
                );
            })
            .array;
}

VulkanLayerProperties[] loadDeviceLayers(VulkanPhysicalDevice pd)
{
    auto vk = pd.vk;
    uint count;
    vulkanEnforce(
        vk.EnumerateDeviceLayerProperties(pd.vkObj, &count, null),
        "Could not retrieve Vulkan device layers"
    );
    if (!count) return[];

    auto vkLayers = new VkLayerProperties[count];
    vulkanEnforce(
        vk.EnumerateDeviceLayerProperties(pd.vkObj, &count, &vkLayers[0]),
        "Could not retrieve Vulkan device layers"
    );

    import std.algorithm : map;
    import std.array : array;
    import std.string : fromStringz;

    return vkLayers
            .map!((ref VkLayerProperties vkLp) {
                return VulkanLayerProperties(
                    fromStringz(&vkLp.layerName[0]).idup,
                    VulkanVersion.fromUint(vkLp.specVersion),
                    VulkanVersion.fromUint(vkLp.implementationVersion),
                    fromStringz(&vkLp.description[0]).idup,
                );
            })
            .array;
}

VulkanExtensionProperties[] loadDeviceExtensions(VulkanPhysicalDevice pd, in string layerName=null)
{
    import std.string : toStringz;

    const(char)* layer;
    if (layerName.length) {
        layer = toStringz(layerName);
    }

    auto vk = pd.vk;
    uint count;
    vulkanEnforce(
        vk.EnumerateDeviceExtensionProperties(pd.vkObj, layer, &count, null),
        "Could not retrieve Vulkan device extensions"
    );
    if (!count) return[];

    auto vkExts = new VkExtensionProperties[count];
    vulkanEnforce(
        vk.EnumerateDeviceExtensionProperties(pd.vkObj, layer, &count, &vkExts[0]),
        "Could not retrieve Vulkan device extensions"
    );

    import std.algorithm : map;
    import std.array : array;
    import std.string : fromStringz;

    return vkExts
            .map!((ref VkExtensionProperties vkExt) {
                return VulkanExtensionProperties(
                    fromStringz(&vkExt.extensionName[0]).idup,
                    VulkanVersion.fromUint(vkExt.specVersion)
                );
            })
            .array;
}

class VulkanObj(VkType)
{
    this (VkType vkObj) {
        _vkObj = vkObj;
    }

    final @property VkType vkObj() {
        return _vkObj;
    }

    private VkType _vkObj;
}

class VulkanInstObj(VkType) : Disposable
{
    this (VkType vkObj, VulkanInstance inst)
    {
        _vkObj = vkObj;
        _inst = inst;
        _inst.retain();
    }

    override void dispose() {
        _inst.release();
        _inst = null;
    }

    final @property VkType vkObj() {
        return _vkObj;
    }

    final @property VulkanInstance inst() {
        return _inst;
    }

    final @property VkInstance vkInst() {
        return _inst.vkObj;
    }

    private VkType _vkObj;
    private VulkanInstance _inst;
}

final class VulkanInstance : VulkanObj!(VkInstance), Instance
{
    mixin(atomicRcCode);

    this(VkInstance vkObj) {
        super(vkObj);
        _vk = new VkInstanceCmds(vkObj, _globCmds);
    }

    override void dispose() {
        if (_vkCb) {
            vk.DestroyDebugReportCallbackEXT(vkObj, _vkCb, null);
            _vkCb = VK_NULL_ND_HANDLE;
            _callback = null;
        }
        vk.DestroyInstance(vkObj, null);
    }

    override @property Backend backend() {
        return Backend.vulkan;
    }

    override @property ApiProps apiProps() {
        return vulkanApiProps;
    }

    @property VkInstanceCmds vk() {
        return _vk;
    }

    override PhysicalDevice[] devices()
    {
        import std.algorithm : map;
        import std.array : array, uninitializedArray;

        if (!_phDs.length) {
            uint count;
            vulkanEnforce(vk.EnumeratePhysicalDevices(vkObj, &count, null),
                    "Could not enumerate Vulkan devices");
            auto devices = uninitializedArray!(VkPhysicalDevice[])(count);
            vulkanEnforce(vk.EnumeratePhysicalDevices(vkObj, &count, devices.ptr),
                    "Could not enumerate Vulkan devices");

            _phDs = devices
                .map!(vkD => cast(PhysicalDevice)new VulkanPhysicalDevice(vkD, this))
                .array();
        }
        return _phDs;
    }

    override void setDebugCallback(DebugCallback callback) {
        VkDebugReportCallbackCreateInfoEXT ci;
        ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
        ci.flags = 0x1f;
        ci.pfnCallback = &gfxd_vk_DebugReportCallback;
        ci.pUserData = cast(void*)this;

        vk.CreateDebugReportCallbackEXT(vkObj, &ci, null, &_vkCb);
        _callback = callback;
    }

    VkInstanceCmds _vk;
    PhysicalDevice[] _phDs;
    VkDebugReportCallbackEXT _vkCb;
    DebugCallback _callback;
}

extern(C) nothrow {
    VkBool32 gfxd_vk_DebugReportCallback(VkDebugReportFlagsEXT flags,
                                         VkDebugReportObjectTypeEXT objectType,
                                         ulong object,
                                         size_t location,
                                         int messageCode,
                                         const(char)* pLayerPrefix,
                                         const(char)* pMessage,
                                         void* pUserData)
    {
        auto vkInst = cast(VulkanInstance)pUserData;
        if (vkInst && vkInst._callback) {
            import gfx.vulkan.conv : debugReportFlagsToGfx;
            import std.string : fromStringz;
            try {
                vkInst._callback(debugReportFlagsToGfx(flags), fromStringz(pMessage).idup);
            }
            catch(Exception ex) {
                import std.exception : collectException;
                import std.stdio : stderr;
                collectException(
                    stderr.writefln("Exception thrown in debug callback: %s", ex.msg)
                );
            }
        }

        return VK_FALSE;
    }
}

final class VulkanPhysicalDevice : PhysicalDevice
{
    this(VkPhysicalDevice vkObj, VulkanInstance inst) {
        _vkObj = vkObj;
        _inst = inst;
        _vk = _inst.vk;

        vk.GetPhysicalDeviceProperties(_vkObj, &_vkProps);

        _availableLayers = loadDeviceLayers(this);
        _availableExtensions = loadDeviceExtensions(this);

        import std.algorithm : canFind, map;
        import std.exception : enforce;
        debug {
            foreach (l; lunarGValidationLayers) {
                if (_availableLayers.map!"a.layerName".canFind(l)) {
                    _openLayers ~= l;
                }
            }
        }
        version(GfxOffscreen) {}
        else {
            import gfx.vulkan.wsi : swapChainExtension;
            enforce(_availableExtensions.map!"a.extensionName".canFind(swapChainExtension));
            _openExtensions ~= swapChainExtension;
        }
    }

    @property VkPhysicalDevice vkObj() {
        return _vkObj;
    }

    @property VkInstanceCmds vk() {
        return _vk;
    }

    override @property Instance instance()
    {
        auto inst = lockObj(_inst);
        if (!inst) return null;
        return giveAwayObj(inst);
    }

    override @property string name() {
        import std.string : fromStringz;
        return fromStringz(_vkProps.deviceName.ptr).idup;
    }
    override @property DeviceType type() {
        return devTypeToGfx(_vkProps.deviceType);
    }
    override @property DeviceFeatures features() {
        import std.algorithm : canFind, map;
        import gfx.vulkan.wsi : swapChainExtension;

        VkPhysicalDeviceFeatures vkFeats;
        vk.GetPhysicalDeviceFeatures(vkObj, &vkFeats);

        DeviceFeatures features;
        features.anisotropy = vkFeats.samplerAnisotropy == VK_TRUE;
        features.presentation = vulkanDeviceExtensions(this)
                .map!(e => e.extensionName)
                .canFind(swapChainExtension);
        return features;
    }
    override @property DeviceLimits limits()
    {
        DeviceLimits limits;
        limits.linearOptimalGranularity =
                cast(size_t)_vkProps.limits.bufferImageGranularity;
        return limits;
    }

    override @property MemoryProperties memoryProperties()
    {
        VkPhysicalDeviceMemoryProperties vkProps=void;
        vk.GetPhysicalDeviceMemoryProperties(_vkObj, &vkProps);

        MemoryProperties props;

        foreach(i; 0 .. vkProps.memoryHeapCount) {
            const vkHeap = vkProps.memoryHeaps[i];
            props.heaps ~= MemoryHeap(
                cast(size_t)vkHeap.size, (vkHeap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0
            );
        }
        foreach(i; 0 .. vkProps.memoryTypeCount) {
            const vkMemType = vkProps.memoryTypes[i];
            props.types ~= MemoryType(
                memPropsToGfx(vkMemType.propertyFlags),
                vkMemType.heapIndex,
            );
        }

        return props;
    }

    override @property QueueFamily[] queueFamilies()
    {
        import std.array : array, uninitializedArray;
        uint count;
        vk.GetPhysicalDeviceQueueFamilyProperties(_vkObj, &count, null);

        auto vkQueueFams = uninitializedArray!(VkQueueFamilyProperties[])(count);
        vk.GetPhysicalDeviceQueueFamilyProperties(_vkObj, &count, vkQueueFams.ptr);

        import std.algorithm : map;
        return vkQueueFams.map!(vkObj => QueueFamily(
            queueCapToGfx(vkObj.queueFlags), vkObj.queueCount
        )).array;
    }

    override FormatProperties formatProperties(in Format format)
    {
        VkFormatProperties vkFp;
        vk.GetPhysicalDeviceFormatProperties(_vkObj, format.toVk(), &vkFp);

        return FormatProperties(
            vkFp.linearTilingFeatures.toGfx(),
            vkFp.optimalTilingFeatures.toGfx(),
            vkFp.bufferFeatures.toGfx(),
        );
    }

    override bool supportsSurface(uint queueFamilyIndex, Surface graalSurface) {
        auto surf = enforce(
            cast(VulkanSurface)graalSurface,
            "Did not pass a Vulkan surface"
        );
        VkBool32 supported;
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfaceSupportKHR(vkObj, queueFamilyIndex, surf.vkObj, &supported),
            "Could not query vulkan surface support"
        );
        return supported != VK_FALSE;
    }

    override SurfaceCaps surfaceCaps(Surface graalSurface) {
        auto surf = enforce(
            cast(VulkanSurface)graalSurface,
            "Did not pass a Vulkan surface"
        );
        VkSurfaceCapabilitiesKHR vkSc;
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfaceCapabilitiesKHR(vkObj, surf.vkObj, &vkSc),
            "Could not query vulkan surface capabilities"
        );
        return vkSc.toGfx();
    }

    override Format[] surfaceFormats(Surface graalSurface) {
        auto surf = enforce(
            cast(VulkanSurface)graalSurface,
            "Did not pass a Vulkan surface"
        );

        uint count;
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfaceFormatsKHR(vkObj, surf.vkObj, &count, null),
            "Could not query vulkan surface formats"
        );
        auto vkSf = new VkSurfaceFormatKHR[count];
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfaceFormatsKHR(vkObj, surf.vkObj, &count, &vkSf[0]),
            "Could not query vulkan surface formats"
        );

        import std.algorithm : filter, map;
        import std.array : array;
        return vkSf
                .filter!(sf => sf.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
                .map!(sf => sf.format.toGfx())
                .array;
    }

    override PresentMode[] surfacePresentModes(Surface graalSurface) {
        auto surf = enforce(
            cast(VulkanSurface)graalSurface,
            "Did not pass a Vulkan surface"
        );

        uint count;
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfacePresentModesKHR(vkObj, surf.vkObj, &count, null),
            "Could not query vulkan surface present modes"
        );
        auto vkPms = new VkPresentModeKHR[count];
        vulkanEnforce(
            vk.GetPhysicalDeviceSurfacePresentModesKHR(vkObj, surf.vkObj, &count, &vkPms[0]),
            "Could not query vulkan surface present modes"
        );

        import std.algorithm : filter, map;
        import std.array : array;
        return vkPms
                .filter!(pm => pm.hasGfxSupport)
                .map!(pm => pm.toGfx())
                .array;
    }

    override Device open(in QueueRequest[] queues, in DeviceFeatures features=DeviceFeatures.all)
    {
        import std.algorithm : filter, map, sort;
        import std.array : array;
        import std.exception : enforce;
        import std.string : toStringz;
        import gfx.vulkan.wsi : swapChainExtension;

        if (!queues.length) {
            return null;
        }

        const qcis = queues.map!((const(QueueRequest) r) {
            VkDeviceQueueCreateInfo qci;
            qci.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
            qci.queueFamilyIndex = r.familyIndex;
            qci.queueCount = cast(uint)r.priorities.length;
            qci.pQueuePriorities = r.priorities.ptr;
            return qci;
        }).array;

        const layers = _openLayers.map!toStringz.array;
        const extensions = _openExtensions
                .filter!(e => e != swapChainExtension || features.presentation)
                .map!toStringz.array;
        VkPhysicalDeviceFeatures vkFeats;
        vkFeats.samplerAnisotropy = features.anisotropy ? VK_TRUE : VK_FALSE;

        VkDeviceCreateInfo ci;
        ci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        ci.queueCreateInfoCount = cast(uint)qcis.length;
        ci.pQueueCreateInfos = qcis.ptr;
        ci.enabledLayerCount = cast(uint)layers.length;
        ci.ppEnabledLayerNames = layers.ptr;
        ci.enabledExtensionCount = cast(uint)extensions.length;
        ci.ppEnabledExtensionNames = extensions.ptr;
        ci.pEnabledFeatures = &vkFeats;

        VkDevice vkDev;
        vulkanEnforce(vk.CreateDevice(_vkObj, &ci, null, &vkDev),
                "Vulkan device creation failed");

        return new VulkanDevice(vkDev, this, _inst);
    }

    private VkPhysicalDevice _vkObj;
    private VkPhysicalDeviceProperties _vkProps;
    private VulkanInstance _inst;

    private VkInstanceCmds _vk;

    private VulkanLayerProperties[] _availableLayers;
    private VulkanExtensionProperties[] _availableExtensions;

    private string[] _openLayers;
    private string[] _openExtensions;
}

DeviceType devTypeToGfx(in VkPhysicalDeviceType vkType)
{
    switch (vkType) {
    case VK_PHYSICAL_DEVICE_TYPE_OTHER:
        return DeviceType.other;
    case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
        return DeviceType.integratedGpu;
    case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
        return DeviceType.discreteGpu;
    case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
        return DeviceType.virtualGpu;
    case VK_PHYSICAL_DEVICE_TYPE_CPU:
        return DeviceType.cpu;
    default:
        assert(false, "unexpected vulkan device type constant");
    }
}