Render a texture

.gitattributes

@@ -2,4 +2,15 @@
 
 *.c text eol=lf
 *.cpp text eol=lf
+*.py text eol=lf
+*.sh text eol=lf
 *.h text eol=lf
+*.txt text eol=lf
+*.MD text eol=lf
+*.md text eol=lf
+*.vert text eol=lf
+*.frag text eol=lf
+*.tesc text eol=lf
+*.geom text eol=lf
+*.comp text eol=lf
+*.tese text eol=lf

CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.10)
 project(bloat-buster)
 
 include(CMakePrintHelpers)
+cmake_print_variables("OS: ${CMAKE_SYSTEM_NAME}")
 cmake_print_variables("Build type: ${CMAKE_BUILD_TYPE}")
 cmake_print_variables("C flags Debug: ${CMAKE_C_FLAGS_DEBUG}")
 cmake_print_variables("CXX flags Debug: ${CMAKE_CXX_FLAGS_DEBUG}")
@@ -182,28 +183,28 @@ if (USE_LLVM)
 endif()
 
 if (NOT BB_IS_CI)
-    find_package(glslang REQUIRED)
+    add_subdirectory(dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0)
+    add_subdirectory(dependencies/SPIRV-Tools-vulkan-sdk-1.3.296.0)
+    add_subdirectory(dependencies/glslang-15.0.0)
     target_link_libraries(${COMPILER_NAME} PRIVATE glslang::glslang glslang::SPIRV glslang::glslang-default-resource-limits)
 
     set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
     set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
     set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-    set(ON CACHE BOOL "" FORCE)
-    # set(GLFW_USE_WAYLAND OFF CACHE BOOL "" FORCE)
-    # set(GLFW_BUILD_X11 ON CACHE BOOL "" FORCE)
-    # set(GLFW_BUILD_WAYLAND OFF CACHE BOOL "" FORCE)
 
     add_subdirectory(dependencies/glfw-3.4)
 
-    target_compile_definitions(${COMPILER_NAME} PRIVATE GLFW_EXPOSE_NATIVE_X11)
     target_link_libraries(${COMPILER_NAME} PRIVATE glfw)
 
     if(CMAKE_SYSTEM_NAME STREQUAL Windows)
         set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_WIN32_KHR)
+        target_compile_definitions(${COMPILER_NAME} PRIVATE GLFW_EXPOSE_NATIVE_WIN32)
     elseif(CMAKE_SYSTEM_NAME STREQUAL Linux)
         set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_XLIB_KHR)
+        target_compile_definitions(${COMPILER_NAME} PRIVATE GLFW_EXPOSE_NATIVE_X11)
     elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
         set(VOLK_STATIC_DEFINES VK_USE_PLATFORM_MACOS_MVK)
+        target_compile_definitions(${COMPILER_NAME} PRIVATE GLFW_EXPOSE_NATIVE_COCOA)
     endif()
 
     add_subdirectory(dependencies/volk-1.3.301 volk)

bootstrap/bloat-buster/gui.c

@@ -64,7 +64,7 @@ fn u8 vk_layer_is_supported(String layer_name)
     return supported;
 }
 
-fn VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void* user_data)
+fn VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void* user_data)
 {
     unused(message_severity);
     unused(message_type);
@@ -174,119 +174,6 @@ STRUCT(VulkanBuffer)
     VkDeviceSize size;
 };
 
-fn VulkanBuffer vk_buffer_create(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties physical_device_memory_properties, VkDeviceSize buffer_size, VkBufferUsageFlags usage_flags, VkMemoryPropertyFlags memory_flags)
-{
-    VkBuffer buffer;
-    VkBufferCreateInfo create_info = {
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = 0,
-        .flags = 0,
-        .size = buffer_size,
-        .usage = usage_flags,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = 0,
-    };
-    vkok(vkCreateBuffer(device, &create_info, allocation_callbacks, &buffer));
-
-    VkMemoryRequirements memory_requirements;
-    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
-
-    u8 use_device_address_bit = (create_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0;
-    VkDeviceMemory memory = vk_allocate_memory(device, allocation_callbacks, physical_device_memory_properties, memory_requirements, memory_flags, use_device_address_bit);
-
-    VkDeviceSize memory_offset = 0;
-    vkok(vkBindBufferMemory(device, buffer, memory, memory_offset));
-
-    void* data = 0;
-    if (memory_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
-    {
-        VkDeviceSize offset = 0;
-        VkMemoryMapFlags map_flags = 0;
-        vkok(vkMapMemory(device, memory, offset, memory_requirements.size, map_flags, &data));
-    }
-
-    VulkanBuffer result = {
-        .handle = buffer,
-        .cpu_data = data,
-        .gpu_data = memory,
-        .size = buffer_size,
-    };
-
-    return result;
-}
-
-STRUCT(VulkanImageCreate)
-{
-    u32 width;
-    u32 height;
-    u32 mip_levels;
-    VkFormat format;
-    VkImageUsageFlags usage;
-};
-
-STRUCT(VulkanImage)
-{
-    VkImage handle;
-    VkImageView view;
-    VkDeviceMemory memory;
-};
-
-fn VulkanImage vk_image_create(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties memory_properties, VulkanImageCreate create)
-{
-    VulkanImage result = {};
-
-    VkImageCreateInfo create_info = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
-        .pNext = 0,
-        .flags = 0,
-        .imageType = VK_IMAGE_TYPE_2D,
-        .format = create.format,
-        .extent = {
-            .width = create.width,
-            .height = create.height,
-            .depth = 1,
-        },
-        .mipLevels = create.mip_levels,
-        .arrayLayers = 1,
-        .samples = VK_SAMPLE_COUNT_1_BIT,
-        .tiling = VK_IMAGE_TILING_OPTIMAL,
-        .usage = create.usage,
-        .sharingMode = 0,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = 0,
-        .initialLayout = 0,
-    };
-    vkok(vkCreateImage(device, &create_info, allocation_callbacks, &result.handle));
-
-    VkMemoryRequirements memory_requirements;
-    vkGetImageMemoryRequirements(device, result.handle, &memory_requirements);
-
-    VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-    u8 use_device_address_bit = 0;
-    result.memory = vk_allocate_memory(device, allocation_callbacks, memory_properties, memory_requirements, flags, use_device_address_bit);
-
-    VkDeviceSize memory_offset = 0;
-    vkok(vkBindImageMemory(device, result.handle, result.memory, memory_offset));
-
-    VkImageViewCreateInfo view_create_info = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .image = result.handle,
-        .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = create_info.format,
-        .subresourceRange = {
-            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-            .baseMipLevel = 0,
-            .levelCount = create.mip_levels,
-            .baseArrayLayer = 0,
-            .layerCount = 1,
-        },
-    };
-
-    vkok(vkCreateImageView(device, &view_create_info, allocation_callbacks, &result.view));
-    return result;
-}
-
 STRUCT(ImmediateContext)
 {
     VkDevice device;
@@ -347,19 +234,19 @@ fn void immediate_end(ImmediateContext context)
     auto timeout = ~(u64)0;
     vkok(vkWaitForFences(context.device, array_length(fences), fences, wait_all, timeout));
 }
-STRUCT(CopyImage)
+STRUCT(VulkanCopyImage)
 {
     VkImage handle;
     VkExtent2D extent;
 };
 
-STRUCT(CopyImageArgs)
+STRUCT(VulkanCopyImageArgs)
 {
-    CopyImage source;
+    VulkanCopyImage source;
-    CopyImage destination;
+    VulkanCopyImage destination;
 };
 
-fn void vk_copy_image_to_image(VkCommandBuffer command_buffer, CopyImageArgs args)
+fn void vk_image_copy(VkCommandBuffer command_buffer, VulkanCopyImageArgs args)
 {
     VkImageSubresourceLayers subresource_layers = {
         .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -405,12 +292,187 @@ fn void vk_copy_image_to_image(VkCommandBuffer command_buffer, CopyImageArgs arg
     vkCmdBlitImage2(command_buffer, &blit_info);
 }
 
+fn VulkanBuffer vk_buffer_create(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties physical_device_memory_properties, VkDeviceSize buffer_size, VkBufferUsageFlags usage_flags, VkMemoryPropertyFlags memory_flags)
+{
+    VkBuffer buffer;
+    VkBufferCreateInfo create_info = {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = 0,
+        .flags = 0,
+        .size = buffer_size,
+        .usage = usage_flags,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = 0,
+    };
+    vkok(vkCreateBuffer(device, &create_info, allocation_callbacks, &buffer));
+
+    VkMemoryRequirements memory_requirements;
+    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
+
+    u8 use_device_address_bit = (create_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0;
+    VkDeviceMemory memory = vk_allocate_memory(device, allocation_callbacks, physical_device_memory_properties, memory_requirements, memory_flags, use_device_address_bit);
+
+    VkDeviceSize memory_offset = 0;
+    vkok(vkBindBufferMemory(device, buffer, memory, memory_offset));
+
+    void* data = 0;
+    if (memory_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+    {
+        VkDeviceSize offset = 0;
+        VkMemoryMapFlags map_flags = 0;
+        vkok(vkMapMemory(device, memory, offset, memory_requirements.size, map_flags, &data));
+    }
+
+    VulkanBuffer result = {
+        .handle = buffer,
+        .cpu_data = data,
+        .gpu_data = memory,
+        .size = buffer_size,
+    };
+
+    return result;
+}
+
+STRUCT(VulkanImageCreate)
+{
+    u32 width;
+    u32 height;
+    u32 mip_levels;
+    VkFormat format;
+    VkImageUsageFlags usage;
+};
+
+STRUCT(VulkanImage)
+{
+    VkImage handle;
+    VkImageView view;
+    VkDeviceMemory memory;
+    VkFormat format;
+};
+
+fn VulkanImage vk_image_create(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties memory_properties, VulkanImageCreate create)
+{
+    assert(create.width);
+    assert(create.height);
+    VulkanImage result = {};
+    result.format = create.format;
+
+    VkImageCreateInfo create_info = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+        .pNext = 0,
+        .flags = 0,
+        .imageType = VK_IMAGE_TYPE_2D,
+        .format = create.format,
+        .extent = {
+            .width = create.width,
+            .height = create.height,
+            .depth = 1,
+        },
+        .mipLevels = create.mip_levels,
+        .arrayLayers = 1,
+        .samples = VK_SAMPLE_COUNT_1_BIT,
+        .tiling = VK_IMAGE_TILING_OPTIMAL,
+        .usage = create.usage,
+        .sharingMode = 0,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = 0,
+        .initialLayout = 0,
+    };
+    vkok(vkCreateImage(device, &create_info, allocation_callbacks, &result.handle));
+
+    VkMemoryRequirements memory_requirements;
+    vkGetImageMemoryRequirements(device, result.handle, &memory_requirements);
+
+    VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    u8 use_device_address_bit = 0;
+    result.memory = vk_allocate_memory(device, allocation_callbacks, memory_properties, memory_requirements, flags, use_device_address_bit);
+
+    VkDeviceSize memory_offset = 0;
+    vkok(vkBindImageMemory(device, result.handle, result.memory, memory_offset));
+
+    VkImageViewCreateInfo view_create_info = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .image = result.handle,
+        .viewType = VK_IMAGE_VIEW_TYPE_2D,
+        .format = create_info.format,
+        .subresourceRange = {
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = create.mip_levels,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+    };
+
+    vkok(vkCreateImageView(device, &view_create_info, allocation_callbacks, &result.view));
+    return result;
+}
+
+STRUCT(ImageFromTextureOptions)
+{
+    u8 apply_gamma_correction;
+};
+
+fn VulkanImage vk_image_from_texture(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, ImmediateContext immediate_context, VkPhysicalDeviceMemoryProperties memory_properties, TextureMemory texture, ImageFromTextureOptions options)
+{
+    assert(texture.depth == 1);
+    VkFormat format = options.apply_gamma_correction ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
+
+    VulkanImage result = vk_image_create(device, allocation_callbacks, memory_properties, (VulkanImageCreate) {
+        .width = texture.width,
+        .height = texture.height,
+        .mip_levels = 1,
+        .format = format,
+        .usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+    });
+
+    u32 channel_count = 4;
+    auto image_size = (u64)texture.depth * texture.width * texture.height * channel_count;
+    VkBufferUsageFlags buffer_usage_flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+    VkMemoryPropertyFlags buffer_memory_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    auto transfer_buffer = vk_buffer_create(device, allocation_callbacks, memory_properties, image_size, buffer_usage_flags, buffer_memory_flags);
+    memcpy(transfer_buffer.cpu_data, texture.pointer, image_size);
+
+    immediate_start(immediate_context);
+
+    vk_image_transition(immediate_context.command_buffer, result.handle, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+    VkBufferImageCopy copy_regions[] = {
+        {
+            .bufferOffset = 0,
+            .bufferRowLength = 0,
+            .bufferImageHeight = 0,
+            .imageSubresource = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .mipLevel = 0,
+                .baseArrayLayer = 0,
+                .layerCount = 1,
+            },
+            .imageOffset = { .x = 0, .y = 0, .z = 0 },
+            .imageExtent = {
+                .width = texture.width,
+                .height = texture.height,
+                .depth = texture.depth,
+            },
+        }
+    };
+
+    vkCmdCopyBufferToImage(immediate_context.command_buffer, transfer_buffer.handle, result.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, array_length(copy_regions), copy_regions);
+
+    vk_image_transition(immediate_context.command_buffer, result.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+    immediate_end(immediate_context);
+
+    return result;
+}
+
 void run_app(Arena* arena)
 {
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
-	glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_X11);
+    glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_X11);
 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
-	glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_WAYLAND);
+    glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_WAYLAND);
 #endif
 
     if (glfwInit() != GLFW_TRUE)
@@ -443,7 +505,18 @@ void run_app(Arena* arena)
         const char* extensions[] = {
             VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
             VK_KHR_SURFACE_EXTENSION_NAME,
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
             VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+            VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+            VK_KHR_COCOA_SURFACE_EXTENSION_NAME,
+#endif
         };
 
         VkDebugUtilsMessengerCreateInfoEXT msg_ci = {
@@ -499,12 +572,32 @@ void run_app(Arena* arena)
 
     VkSurfaceKHR surface;
     {
-        VkXlibSurfaceCreateInfoKHR ci = {
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        VkWin32SurfaceCreateInfoKHR create_info = {
+            .sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
+            .pNext = 0,
+            .flags = 0,
+            .hinstance = GetModuleHandleW(0),
+            .hwnd = glfwGetWin32Window(window),
+        };
+        vkok(vkCreateWin32SurfaceKHR(instance, &create_info, allocation_callbacks, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+        VkXlibSurfaceCreateInfoKHR create_info = {
             .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
+            .pNext = 0,
+            .flags = 0,
             .dpy = glfwGetX11Display(),
             .window = glfwGetX11Window(window),
         };
-        vkok(vkCreateXlibSurfaceKHR(instance, &ci, allocation_callbacks, &surface));
+        vkok(vkCreateXlibSurfaceKHR(instance, &create_info, allocation_callbacks, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+            VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+            VK_KHR_COCOA_SURFACE_EXTENSION_NAME,
+#endif
     }
 
     VkPhysicalDevice physical_device;
@@ -790,6 +883,29 @@ void run_app(Arena* arena)
         vkok(vkCreateFence(device, &fence_create_info, allocation_callbacks, &immediate.fence));
     }
 
+    VkDescriptorSetLayoutBinding descriptor_set_layout_bindings[] = {
+        {
+            .binding = 0,
+            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+            .descriptorCount = 1,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .pImmutableSamplers = 0,
+        },
+    };
+    VkDescriptorSetLayout descriptor_set_layout;
+    {
+        VkDescriptorSetLayoutCreateInfo create_info = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .pNext = 0,
+            .flags = 0,
+            .bindingCount = array_length(descriptor_set_layout_bindings),
+            .pBindings = descriptor_set_layout_bindings,
+        };
+
+        vkok(vkCreateDescriptorSetLayout(device, &create_info, allocation_callbacks, &descriptor_set_layout));
+    }
+
+    VkDescriptorSetLayout descriptor_set_layouts[] = { descriptor_set_layout };
     VkPipeline graphics_pipeline;
     VkPipelineLayout graphics_pipeline_layout;
     {
@@ -807,8 +923,8 @@ void run_app(Arena* arena)
         VkPipelineLayoutCreateInfo create_info = {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
             .flags = 0,
-            .setLayoutCount = 0,
+            .setLayoutCount = array_length(descriptor_set_layouts),
-            .pSetLayouts = 0,
+            .pSetLayouts = descriptor_set_layouts,
             .pushConstantRangeCount = array_length(push_constant_ranges),
             .pPushConstantRanges = push_constant_ranges,
         };
@@ -999,30 +1115,38 @@ void run_app(Arena* arena)
 
     STRUCT(Vertex)
     {
-        Vec4 position;
+        f32 x;
-        Vec4 color;
+        f32 y;
+        f32 uv_x;
+        f32 uv_y;
     };
 
-    Vec4 color = { .v = { 1.0f, 0.0f, 0.0f, 1.0f } };
-
     auto width_float = (f32)initial_width;
     auto height_float = (f32)initial_height;
     Vertex vertices[] = {
         {
-            .position = { .v = { (3 * width_float) / 4, height_float / 4, 0.0f, 1.0f } },
+            .x = (3 * width_float) / 4,
-            .color = color,
+            .y = height_float / 4,
+            .uv_x = 1.0f,
+            .uv_y = 1.0f,
         },
         {
-            .position = { .v = { (3 * width_float) / 4, (3 * height_float) / 4, 0.0f, 1.0f } },
+            .x = (3 * width_float) / 4,
-            .color = color,
+            .y = (3 * height_float) / 4,
+            .uv_x = 1.0f,
+            .uv_y = 0.0f,
         },
         {
-            .position = { .v = { width_float / 4, height_float / 4, 0.0f, 1.0f } },
+            .x = width_float / 4,
-            .color = color,
+            .y = height_float / 4,
+            .uv_x = 0.0f,
+            .uv_y = 1.0f,
         },
         {
-            .position = { .v = { width_float / 4, (3 * height_float) / 4, 0.0f, 1.0f } },
+            .x = width_float / 4,
-            .color = color,
+            .y = (3 * height_float) / 4,
+            .uv_x = 0.0f,
+            .uv_y = 0.0f,
         },
     };
 
@@ -1072,6 +1196,104 @@ void run_app(Arena* arena)
         immediate_end(immediate);
     }
 
+    auto texture_path =
+#ifdef _WIN32
+        strlit("C:/Users/david/Pictures/buster.jpg");
+#elif defined(__linux__)
+        strlit("/home/david/Pictures/buster.jpeg");
+#else
+#endif
+    auto texture = texture_load_from_file(arena, texture_path);
+    auto texture_image = vk_image_from_texture(device, allocation_callbacks, immediate, physical_device_memory_properties, texture, (ImageFromTextureOptions) {
+        .apply_gamma_correction = 0,
+    });
+
+    VkSampler sampler;
+    {
+        VkFilter sampler_filter = VK_FILTER_LINEAR;
+        VkSamplerCreateInfo create_info = {
+            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+            .pNext = 0,
+            .flags = 0,
+            .magFilter = sampler_filter,
+            .minFilter = sampler_filter,
+            .mipmapMode = 0,
+            .addressModeU = 0,
+            .addressModeV = 0,
+            .addressModeW = 0,
+            .mipLodBias = 0,
+            .anisotropyEnable = 0,
+            .maxAnisotropy = 0,
+            .compareEnable = 0,
+            .compareOp = 0,
+            .minLod = 0,
+            .maxLod = 0,
+            .borderColor = 0,
+            .unnormalizedCoordinates = 0,
+        };
+
+        vkok(vkCreateSampler(device, &create_info, allocation_callbacks, &sampler));
+    }
+
+    VkDescriptorPool descriptor_pools[frame_overlap];
+    VkDescriptorSet descriptor_sets[frame_overlap];
+    for (u32 i = 0; i < frame_overlap; i += 1)
+    {
+        VkDescriptorPoolSize pool_sizes[] = {
+            {
+                .type = descriptor_set_layout_bindings[0].descriptorType,
+                .descriptorCount = array_length(descriptor_set_layout_bindings),
+            },
+        };
+        VkDescriptorPoolCreateInfo create_info = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+            .pNext = 0,
+            .flags = 0,
+            .maxSets = 1,
+            .poolSizeCount = array_length(pool_sizes),
+            .pPoolSizes = pool_sizes,
+        };
+
+        vkok(vkCreateDescriptorPool(device, &create_info, allocation_callbacks, &descriptor_pools[i]));
+
+        VkDescriptorSetAllocateInfo allocate_info = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+            .pNext = 0,
+            .descriptorPool = descriptor_pools[i],
+            .descriptorSetCount = array_length(descriptor_set_layouts),
+            .pSetLayouts = descriptor_set_layouts,
+        };
+
+        vkok(vkAllocateDescriptorSets(device, &allocate_info, &descriptor_sets[i]));
+
+        VkDescriptorImageInfo image_infos[] = {
+            {
+                .sampler = sampler,
+                .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                .imageView = texture_image.view,
+            },
+        };
+
+        VkWriteDescriptorSet write_descriptor_sets[] = {
+            {
+                .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                .pNext = 0,
+                .dstSet = descriptor_sets[i],
+                .dstBinding = 0,
+                .dstArrayElement = 0,
+                .descriptorCount = array_length(image_infos),
+                .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                .pImageInfo = image_infos,
+                .pBufferInfo = 0,
+                .pTexelBufferView = 0,
+            },
+        };
+
+        u32 descriptor_copy_count = 0;
+        VkCopyDescriptorSet* descriptor_copies = 0;
+        vkUpdateDescriptorSets(device, array_length(write_descriptor_sets), write_descriptor_sets, descriptor_copy_count, descriptor_copies);
+    }
+
     u32 frame_completed = 0;
     for (u32 frame_number = 0; !glfwWindowShouldClose(window); frame_number += frame_completed)
     {
@@ -1146,6 +1368,13 @@ void run_app(Arena* arena)
 
             vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphics_pipeline);
 
+            // Bind texture
+            u32 first_set = 0;
+            u32 descriptor_set_count = 1;
+            u32 dynamic_offset_count = 0;
+            u32* dynamic_offsets = 0;
+            vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphics_pipeline_layout, first_set, descriptor_set_count, &descriptor_sets[frame_index], dynamic_offset_count, dynamic_offsets);
+
             VkViewport viewports[] = {
                 {
                     .x = 0,
@@ -1176,7 +1405,6 @@ void run_app(Arena* arena)
             u32 first_scissor = 0;
             vkCmdSetScissor(command_buffer, first_scissor, array_length(scissors), scissors);
 
-// typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
             GPUDrawPushConstants push_constants = {
                 .vertex_buffer = vertex_buffer_device_address,
                 .width = (f32)width,
@@ -1200,7 +1428,7 @@ void run_app(Arena* arena)
             VkImage swapchain_image = swapchain_image_buffer[swapchain_image_index];
             vk_image_transition(command_buffer, swapchain_image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 
-            vk_copy_image_to_image(command_buffer, (CopyImageArgs) {
+            vk_image_copy(command_buffer, (VulkanCopyImageArgs) {
                 .source = {
                     .handle = render_image.handle,
                     .extent = {

bootstrap/bloat-buster/image_loader.c

@@ -9,12 +9,13 @@ EXPORT TextureMemory texture_load_from_file(Arena* arena, String path)
     int width;
     int height;
     int channels;
-    u8* buffer = stbi_load_from_memory(file.pointer, file.length, &width, &height, &channels, 0);
+    u8* buffer = stbi_load_from_memory(file.pointer, file.length, &width, &height, &channels, STBI_rgb_alpha);
 
     return (TextureMemory) {
         .pointer = buffer,
         .width = width,
         .height = height,
         .channel_count = channels,
+        .depth = 1,
     };
 }

bootstrap/include/bloat-buster/image_loader.h

@@ -7,7 +7,7 @@ STRUCT(TextureMemory)
     u32 width;
     u32 height;
     u32 channel_count;
-    u32 padding[1];
+    u32 depth;
 };
 
 EXPORT TextureMemory texture_load_from_file(Arena* arena, String path);

bootstrap/shaders/triangle.frag

@@ -1,12 +1,14 @@
 #version 450
 
 //shader input
-layout (location = 0) in vec4 inColor;
+layout (location = 0) in vec2 in_uv;
 
 //output write
-layout (location = 0) out vec4 outFragColor;
+layout (location = 0) out vec4 out_frag_color;
+
+layout(set = 0, binding = 0) uniform sampler2D display_texture;
 
 void main() 
 {
-	outFragColor = inColor;
+    out_frag_color = texture(display_texture, in_uv);
 }

bootstrap/shaders/triangle.vert

@@ -2,35 +2,37 @@
 #extension GL_EXT_buffer_reference : require
 #extension GL_EXT_debug_printf : require
 
-layout (location = 0) out vec4 outColor;
+layout (location = 0) out vec2 out_uv;
 
 struct Vertex {
-	vec4 position;
+    float x;
-	vec4 color;
+    float y;
+    float uv_x;
+    float uv_y;
 }; 
 
 layout(buffer_reference, std430) readonly buffer VertexBuffer{ 
-	Vertex vertices[];
+   Vertex vertices[];
 };
 
 //push constants block
 layout( push_constant ) uniform constants
-{	
+{
-	VertexBuffer vertexBuffer;
+    VertexBuffer vertex_buffer;
     float width;
     float height;
 } PushConstants;
 
 void main() 
-{	
+{
-	//load vertex data from device address
+    //load vertex data from device address
-	Vertex v = PushConstants.vertexBuffer.vertices[gl_VertexIndex];
+    Vertex v = PushConstants.vertex_buffer.vertices[gl_VertexIndex];
     float width = PushConstants.width;
     float height = PushConstants.height;
 
-	//output data
+    //output data
-	gl_Position = vec4(2 * v.position.x / width - 1, 1 - (2 * v.position.y) / height, v.position.z, v.position.w);
+    gl_Position = vec4(2 * v.x / width - 1, 1 - (2 * v.y) / height, 0.0, 1.0);
-	outColor = v.color;
+    out_uv = vec2(v.uv_x, v.uv_y);
     //debugPrintfEXT("Position: (%f, %f, %f)\n", v.position.x, v.position.y, v.position.z);
     //debugPrintfEXT("Color: (%f, %f, %f)\n", v.color.x, v.color.y, v.color.z);
 }

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/.gitattributes

@@ -0,0 +1,7 @@
+*.json text
+*.h text
+*.hpp text
+*.hpp11 text
+*.lua text
+*.py text
+*.xml

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    groups:
+      github-actions:
+        patterns:
+          - "*"

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/.github/workflows/presubmit.yml

@@ -0,0 +1,123 @@
+name: Presubmit
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Ubuntu packages
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt install -y dos2unix
+      - name: Install macOS packages
+        if: matrix.os == 'macos-latest'
+        run: brew install dos2unix
+      - name: Build
+        run: |
+          mkdir build
+          cd build
+          cmake -DCMAKE_INSTALL_PREFIX=install ..
+          cmake --build . --target install
+      - name: Build spec tools
+        run: |
+          cd tools/buildHeaders
+          mkdir build
+          cd build
+          cmake ..
+          cmake --build . --target install
+      - name: Build headers
+        run: |
+          cd tools/buildHeaders
+          ./bin/makeHeaders
+      - name: Check generated headers
+        run: git diff --exit-code
+
+  test_cmake_min_required:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.14.0
+      - name: CMake build
+        run: |
+          cmake -S . -B build/ -D CMAKE_BUILD_TYPE=Debug -G "Ninja" -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install/
+          cmake --build build --target install
+
+  test_cmake_latest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+      - name: CMake build
+        run: |
+          cmake -S . -B build/ -D CMAKE_BUILD_TYPE=Debug -G "Ninja"
+          cmake --install build/ --prefix build/install
+
+  add_subdirectory:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.15.0
+      - name: Build spirv-headers with testing enabled
+        run: |
+          cmake -S . -B build/ -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Debug -G "Ninja"
+          cmake --build build
+
+  find_package:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.15.0
+      - name: Install spirv-headers
+        run: |
+          cmake -S . -B build/
+          cmake --install build/ --prefix build/install
+      - name: Check spirv-headers find_package support
+        run: |
+          cmake -S tests/find_package -B tests/find_package/build/ -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install
+          cmake --build tests/find_package/build/
+
+  find_pkg_config:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.15.0
+      - name: Install spirv-headers
+        run: |
+          cmake -S . -B build/ -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install/
+          cmake --install build/
+      - name: Check spirv-headers pkg_config support
+        run: |
+          cmake -S tests/pkg_config -B tests/pkg_config/build/ -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install
+          cmake --build tests/pkg_config/build/
+
+  # https://github.com/KhronosGroup/SPIRV-Headers/issues/282
+  find_pkg_config_absolute:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.15.0
+      - name: Install spirv-headers with CMAKE_INSTALL_INCLUDEDIR being absolute
+        run: |
+          cmake -S . -B build/ -D CMAKE_INSTALL_INCLUDEDIR=${GITHUB_WORKSPACE}/build/install/include -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install/
+          cmake --install build/
+      - name: Check spirv-headers pkg_config support
+        run: |
+          cmake -S tests/pkg_config -B tests/pkg_config/build/ -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install
+          cmake --build tests/pkg_config/build/

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/.gitignore

@@ -0,0 +1,3 @@
+build
+out
+.DS_Store

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/BUILD.bazel

@@ -0,0 +1,177 @@
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])
+
+exports_files(["LICENSE"])
+
+filegroup(
+    name = "spirv_core_grammar_1.0",
+    srcs = ["include/spirv/1.0/spirv.core.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_glsl_grammar_1.0",
+    srcs = ["include/spirv/1.0/extinst.glsl.std.450.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_opencl_grammar_1.0",
+    srcs = ["include/spirv/1.0/extinst.opencl.std.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_core_grammar_1.1",
+    srcs = ["include/spirv/1.1/spirv.core.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_glsl_grammar_1.1",
+    srcs = ["include/spirv/1.1/extinst.glsl.std.450.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_opencl_grammar_1.1",
+    srcs = ["include/spirv/1.1/extinst.opencl.std.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_core_grammar_1.2",
+    srcs = ["include/spirv/1.2/spirv.core.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_glsl_grammar_1.2",
+    srcs = ["include/spirv/1.2/extinst.glsl.std.450.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_opencl_grammar_1.2",
+    srcs = ["include/spirv/1.2/extinst.opencl.std.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_core_grammar_unified1",
+    srcs = ["include/spirv/unified1/spirv.core.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_glsl_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.glsl.std.450.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_opencl_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.opencl.std.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_xml_registry",
+    srcs = ["include/spirv/spir-v.xml"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_debuginfo_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.debuginfo.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_nonsemantic_clspvreflection_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.nonsemantic.clspvreflection.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_nonsemantic_vkspreflection_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_nonsemantic_debugprintf_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.nonsemantic.debugprintf.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_opencl_debuginfo_100_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_nonsemantic_shader_debuginfo_100_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.nonsemantic.shader.debuginfo.100.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_spv_amd_gcn_shader_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.spv-amd-gcn-shader.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_spv_amd_shader_ballot_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.spv-amd-shader-ballot.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_spv_amd_shader_explicit_vertex_parameter_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.spv-amd-shader-explicit-vertex-parameter.grammar.json"],
+)
+
+filegroup(
+    name = "spirv_ext_inst_spv_amd_shader_trinary_minmax_grammar_unified1",
+    srcs = ["include/spirv/unified1/extinst.spv-amd-shader-trinary-minmax.grammar.json"],
+)
+
+cc_library(
+    name = "spirv_common_headers",
+    hdrs = [
+        "include/spirv/1.0/GLSL.std.450.h",
+        "include/spirv/1.0/OpenCL.std.h",
+        "include/spirv/1.1/GLSL.std.450.h",
+        "include/spirv/1.1/OpenCL.std.h",
+        "include/spirv/1.2/GLSL.std.450.h",
+        "include/spirv/1.2/OpenCL.std.h",
+        "include/spirv/unified1/GLSL.std.450.h",
+        "include/spirv/unified1/NonSemanticClspvReflection.h",
+        "include/spirv/unified1/NonSemanticDebugPrintf.h",
+        "include/spirv/unified1/NonSemanticVkspReflection.h",
+        "include/spirv/unified1/OpenCL.std.h",
+    ],
+    includes = ["include"],
+)
+
+cc_library(
+    name = "spirv_c_headers",
+    hdrs = [
+        "include/spirv/1.0/spirv.h",
+        "include/spirv/1.1/spirv.h",
+        "include/spirv/1.2/spirv.h",
+        "include/spirv/unified1/spirv.h",
+    ],
+    includes = ["include"],
+    deps = [":spirv_common_headers"],
+)
+
+cc_library(
+    name = "spirv_cpp_headers",
+    hdrs = [
+        "include/spirv/1.0/spirv.hpp",
+        "include/spirv/1.1/spirv.hpp",
+        "include/spirv/1.2/spirv.hpp",
+        "include/spirv/unified1/spirv.hpp",
+    ],
+    includes = ["include"],
+    deps = [":spirv_common_headers"],
+)
+
+cc_library(
+    name = "spirv_cpp11_headers",
+    hdrs = [
+        "include/spirv/1.0/spirv.hpp11",
+        "include/spirv/1.1/spirv.hpp11",
+        "include/spirv/1.2/spirv.hpp11",
+        "include/spirv/unified1/spirv.hpp11",
+    ],
+    includes = ["include"],
+    deps = [":spirv_common_headers"],
+)
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/BUILD.gn

@@ -0,0 +1,45 @@
+# Copyright (c) 2020-2024 Google LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and/or associated documentation files (the "Materials"),
+# to deal in the Materials without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Materials, and to permit persons to whom the
+# Materials are furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Materials.
+#
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+# STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+# HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+#
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+# IN THE MATERIALS.
+
+config("spv_headers_public_config") {
+  include_dirs = [ "include" ]
+}
+
+source_set("spv_headers") {
+  sources = [
+    "include/spirv/1.2/GLSL.std.450.h",
+    "include/spirv/1.2/OpenCL.std.h",
+    "include/spirv/1.2/spirv.h",
+    "include/spirv/1.2/spirv.hpp",
+    "include/spirv/unified1/GLSL.std.450.h",
+    "include/spirv/unified1/NonSemanticClspvReflection.h",
+    "include/spirv/unified1/NonSemanticDebugPrintf.h",
+    "include/spirv/unified1/NonSemanticVkspReflection.h",
+    "include/spirv/unified1/OpenCL.std.h",
+    "include/spirv/unified1/spirv.h",
+    "include/spirv/unified1/spirv.hpp",
+  ]
+
+  public_configs = [ ":spv_headers_public_config" ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/CMakeLists.txt

@@ -0,0 +1,67 @@
+# Copyright (c) 2015-2024 The Khronos Group Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and/or associated documentation files (the
+# "Materials"), to deal in the Materials without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Materials, and to
+# permit persons to whom the Materials are furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Materials.
+#
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+# KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+# SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+#    https://www.khronos.org/registry/
+#
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+cmake_minimum_required(VERSION 3.14)
+project(SPIRV-Headers LANGUAGES CXX VERSION 1.5.5)
+
+if (CMAKE_VERSION VERSION_LESS "3.21")
+    # https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
+    string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL)
+endif()
+
+add_library(SPIRV-Headers INTERFACE)
+add_library(SPIRV-Headers::SPIRV-Headers ALIAS SPIRV-Headers)
+target_include_directories(SPIRV-Headers INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+
+option(SPIRV_HEADERS_ENABLE_TESTS "Test SPIRV-Headers" ${PROJECT_IS_TOP_LEVEL})
+option(SPIRV_HEADERS_ENABLE_INSTALL "Install SPIRV-Headers" ${PROJECT_IS_TOP_LEVEL})
+
+if(SPIRV_HEADERS_ENABLE_TESTS)
+    add_subdirectory(tests)
+endif()
+
+if(SPIRV_HEADERS_ENABLE_INSTALL)
+    include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+
+    install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+    set(cmake_install_dir "${CMAKE_INSTALL_DATADIR}/cmake/SPIRV-Headers")
+    set(version_config "${CMAKE_CURRENT_BINARY_DIR}/generated/SPIRV-HeadersConfigVersion.cmake")
+
+    write_basic_package_version_file("${version_config}" COMPATIBILITY SameMajorVersion ARCH_INDEPENDENT)
+    install(FILES "${version_config}" DESTINATION "${cmake_install_dir}")
+
+    install(TARGETS SPIRV-Headers EXPORT "SPIRV-HeadersConfig" INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    install(EXPORT "SPIRV-HeadersConfig" NAMESPACE "SPIRV-Headers::" DESTINATION "${cmake_install_dir}")
+
+    if (IS_ABSOLUTE ${CMAKE_INSTALL_INCLUDEDIR})
+        set(SPIRV_HEADERS_PKGCONFIG_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR})
+    else()
+        set(SPIRV_HEADERS_PKGCONFIG_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
+    endif()
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/SPIRV-Headers.pc.in ${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Headers.pc @ONLY)
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SPIRV-Headers.pc" DESTINATION ${CMAKE_INSTALL_DATADIR}/pkgconfig)
+endif()

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil.

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/LICENSE

@@ -0,0 +1,103 @@
+Files: All files except for those called out below.
+Copyright (c) 2015-2024 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+   https://www.khronos.org/registry/
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+---
+
+Files: include/spirv/spir-v.xml
+Copyright (c) 2015-2024 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+---
+
+Files: tools/buildHeaders/jsoncpp/*
+The JsonCpp library's source code, including accompanying documentation,
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+
+---

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/README.md

@@ -0,0 +1,226 @@
+# SPIR-V Headers
+
+This repository contains machine-readable files for the
+[SPIR-V Registry](https://www.khronos.org/registry/spir-v/).
+This includes:
+
+* Header files for various languages.
+* JSON files describing the grammar for the SPIR-V core instruction set
+  and the extended instruction sets.
+* The XML registry file.
+* A tool to build the headers from the JSON grammar.
+
+Headers are provided in the [include](include) directory, with up-to-date
+headers in the `unified1` subdirectory. Older headers are provided according to
+their version.
+
+In contrast, the XML registry file has a linear history, so it is
+not tied to SPIR-V specification versions.
+
+## How is this repository updated?
+
+When a new version or revision of the SPIR-V specification is published,
+the SPIR-V Working Group will push new commits onto master, updating
+the files under [include](include).
+
+[The SPIR-V XML registry file](include/spirv/spir-v.xml)
+is updated by Khronos whenever a new enum range is allocated.
+
+Pull requests can be made to
+- request allocation of new enum ranges in the XML registry file
+- register a new magic number for a SPIR-V generator
+- reserve specific tokens in the JSON grammar
+
+### Registering a SPIR-V Generator Magic Number
+
+Tools that generate SPIR-V should use a magic number in the SPIR-V to help identify the
+generator.
+
+Care should be taken to follow existing precedent in populating the details of reserved tokens.
+This includes:
+- keeping generator numbers in numeric order
+- filling out all the existing fields
+
+### Reserving tokens in the JSON grammar
+
+Care should be taken to follow existing precedent in populating the details of reserved tokens.
+This includes:
+- pointing to what extension has more information, when possible
+- keeping enumerants in numeric order
+- when there are aliases, listing the preferred spelling first
+- adding the statement `"version" : "None"`
+
+## How to install the headers
+
+```
+mkdir build
+cd build
+cmake ..
+cmake --build . --target install
+```
+
+Then, for example, you will have `/usr/local/include/spirv/unified1/spirv.h`
+
+If you want to install them somewhere else, then use
+`-DCMAKE_INSTALL_PREFIX=/other/path` on the first `cmake` command.
+
+## Using the headers without installing
+
+### Using CMake
+A CMake-based project can use the headers without installing, as follows:
+
+1. Add an `add_subdirectory` directive to include this source tree.
+2. Use `${SPIRV-Headers_SOURCE_DIR}/include}` in a `target_include_directories`
+   directive.
+3. In your C or C++ source code use `#include` directives that explicitly mention
+   the `spirv` path component.
+```
+#include "spirv/unified1/GLSL.std.450.h"
+#include "spirv/unified1/OpenCL.std.h"
+#include "spirv/unified1/spirv.hpp"
+```
+
+See also the [example](example/) subdirectory.  But since that example is
+*inside* this repostory, it doesn't use and `add_subdirectory` directive.
+
+### Using Bazel
+A Bazel-based project can use the headers without installing, as follows:
+
+1. Add SPIRV-Headers as a submodule of your project, and add a
+`local_repository` to your `WORKSPACE` file. For example, if you place
+SPIRV-Headers under `external/spirv-headers`, then add the following to your
+`WORKSPACE` file:
+
+```
+local_repository(
+    name = "spirv_headers",
+    path = "external/spirv-headers",
+)
+```
+
+2. Add one of the following to the `deps` attribute of your build target based
+on your needs:
+```
+@spirv_headers//:spirv_c_headers
+@spirv_headers//:spirv_cpp_headers
+@spirv_headers//:spirv_cpp11_headers
+```
+
+For example:
+
+```
+cc_library(
+  name = "project",
+  srcs = [
+    # Path to project sources
+  ],
+  hdrs = [
+    # Path to project headers
+  ],
+  deps = [
+    "@spirv_tools//:spirv_c_headers",
+    # Other dependencies,
+  ],
+)
+```
+
+3. In your C or C++ source code use `#include` directives that explicitly mention
+   the `spirv` path component.
+```
+#include "spirv/unified1/GLSL.std.450.h"
+#include "spirv/unified1/OpenCL.std.h"
+#include "spirv/unified1/spirv.hpp"
+```
+
+## Generating headers from the JSON grammar for the SPIR-V core instruction set
+
+This will generally be done by Khronos, for a change to the JSON grammar.
+However, the project for the tool to do this is included in this repository,
+and can be used to test a PR, or even to include the results in the PR.
+This is not required though.
+
+The header-generation project is under the `tools/buildHeaders` directory.
+Use CMake to build and install the project, in a `build` subdirectory (under `tools/buildHeaders`).
+There is then a bash script at `bin/makeHeaders` that shows how to use the built
+header-generator binary to generate the headers from the JSON grammar.
+(Execute `bin/makeHeaders` from the `tools/buildHeaders` directory.)
+Here's a complete example:
+
+```
+cd tools/buildHeaders
+mkdir build
+cd build
+cmake ..
+cmake --build . --target install
+cd ..
+./bin/makeHeaders
+```
+
+Notes:
+- this generator is used in a broader context within Khronos to generate the specification,
+  and that influences the languages used, for legacy reasons
+- the C++ structures built may similarly include more than strictly necessary, for the same reason
+
+## Generating C headers for extended instruction sets
+
+The [GLSL.std.450.h](include/spirv/unified1/GLSL.std.450.h)
+and [OpenCL.std.h](include/spirv/unified1/OpenCL.std.h) extended instruction set headers
+are maintained manually.
+
+The C/C++ header for each of the other extended instruction sets
+is generated from the corresponding JSON grammar file.  For example, the
+[OpenCLDebugInfo100.h](include/spirv/unified1/OpenCLDebugInfo100.h) header
+is generated from the
+[extinst.opencl.debuginfo.100.grammar.json](include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json)
+grammar file.
+
+To generate these C/C++ headers, first make sure `python3` is in your PATH, then
+invoke the build script as follows:
+```
+cd tools/buildHeaders
+python3 bin/makeExtinstHeaders.py
+```
+
+## FAQ
+
+* *How are different versions published?*
+
+  The multiple versions of the headers have been simplified into a
+  single `unified1` view. The JSON grammar has a "version" field saying
+  what version things first showed up in.
+
+* *How do you handle the evolution of extended instruction sets?*
+
+  Extended instruction sets evolve asynchronously from the core spec.
+  Right now there is only a single version of both the GLSL and OpenCL
+  headers.  So we don't yet have a problematic example to resolve.
+
+## License
+<a name="license"></a>
+```
+Copyright (c) 2015-2024 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+   https://www.khronos.org/registry/
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+```

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/SECURITY.md

@@ -0,0 +1,13 @@
+# Security Policy
+
+## Supported Versions
+
+Security updates are applied only to the latest release.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
+
+Please disclose it at [security advisory](https://github.com/KhronosGroup/SPIRV-Headers/security/advisories/new).
+
+This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure.

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/cmake/SPIRV-Headers.pc.in

@@ -0,0 +1,8 @@
+includedir=@SPIRV_HEADERS_PKGCONFIG_INCLUDE_DIR@
+
+Name: SPIRV-Headers
+Description: Header files from the SPIR-V registry
+Version: @CMAKE_PROJECT_VERSION@
+Requires:
+Libs:
+Cflags: -I${includedir}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/GLSL.std.450.h

@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/OpenCL.std.h

@@ -0,0 +1,210 @@
+/*
+** Copyright (c) 2015-2017 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+namespace OpenCLLIB {
+
+enum Entrypoints {
+
+    // Section 2.1: Math extended instructions
+    Acos = 0,
+    Acosh = 1,
+    Acospi = 2,
+    Asin = 3,
+    Asinh = 4,
+    Asinpi = 5,
+    Atan = 6,
+    Atan2 = 7,
+    Atanh = 8,
+    Atanpi = 9,
+    Atan2pi = 10,
+    Cbrt = 11,
+    Ceil = 12,
+    Copysign = 13,
+    Cos = 14,
+    Cosh = 15,
+    Cospi = 16,
+    Erfc = 17,
+    Erf = 18,
+    Exp = 19,
+    Exp2 = 20,
+    Exp10 = 21,
+    Expm1 = 22,
+    Fabs = 23,
+    Fdim = 24,
+    Floor = 25,
+    Fma = 26,
+    Fmax = 27,
+    Fmin = 28,
+    Fmod = 29,
+    Fract = 30, 
+    Frexp = 31,
+    Hypot = 32,
+    Ilogb = 33,
+    Ldexp = 34,
+    Lgamma = 35,
+    Lgamma_r = 36,
+    Log = 37,
+    Log2 = 38,
+    Log10 = 39,
+    Log1p = 40,
+    Logb = 41,
+    Mad = 42,
+    Maxmag = 43,
+    Minmag = 44,
+    Modf = 45,
+    Nan = 46,
+    Nextafter = 47,
+    Pow = 48,
+    Pown = 49,
+    Powr = 50,
+    Remainder = 51,
+    Remquo = 52,
+    Rint = 53,
+    Rootn = 54,
+    Round = 55,
+    Rsqrt = 56,
+    Sin = 57,
+    Sincos = 58,
+    Sinh = 59,
+    Sinpi = 60,
+    Sqrt = 61,
+    Tan = 62,
+    Tanh = 63,
+    Tanpi = 64,
+    Tgamma = 65,
+    Trunc = 66,
+    Half_cos = 67,
+    Half_divide = 68,
+    Half_exp = 69,
+    Half_exp2 = 70,
+    Half_exp10 = 71,
+    Half_log = 72,
+    Half_log2 = 73,
+    Half_log10 = 74,
+    Half_powr = 75,
+    Half_recip = 76,
+    Half_rsqrt = 77,
+    Half_sin = 78,
+    Half_sqrt = 79,
+    Half_tan = 80,
+    Native_cos = 81,
+    Native_divide = 82,
+    Native_exp = 83,
+    Native_exp2 = 84,
+    Native_exp10 = 85,
+    Native_log = 86,
+    Native_log2 = 87,
+    Native_log10 = 88,
+    Native_powr = 89,
+    Native_recip = 90,
+    Native_rsqrt = 91,
+    Native_sin = 92,
+    Native_sqrt = 93,
+    Native_tan = 94,
+    
+    // Section 2.2: Integer instructions
+    SAbs = 141,
+    SAbs_diff = 142,
+    SAdd_sat = 143,
+    UAdd_sat = 144,
+    SHadd = 145,
+    UHadd = 146,
+    SRhadd = 147,
+    URhadd = 148,
+    SClamp = 149,
+    UClamp = 150, 
+    Clz = 151,
+    Ctz = 152,    
+    SMad_hi = 153,
+    UMad_sat = 154,
+    SMad_sat = 155,
+    SMax = 156,
+    UMax = 157,
+    SMin = 158,
+    UMin = 159,
+    SMul_hi = 160,
+    Rotate = 161,
+    SSub_sat = 162,
+    USub_sat = 163,
+    U_Upsample = 164,
+    S_Upsample = 165,
+    Popcount = 166,
+    SMad24 = 167,
+    UMad24 = 168,
+    SMul24 = 169,
+    UMul24 = 170,
+    UAbs = 201,
+    UAbs_diff = 202,
+    UMul_hi = 203,
+    UMad_hi = 204,
+
+    // Section 2.3: Common instructions
+    FClamp = 95,
+    Degrees = 96,
+    FMax_common = 97,
+    FMin_common = 98, 
+    Mix = 99,
+    Radians = 100,
+    Step = 101,
+    Smoothstep = 102,
+    Sign = 103,
+
+    // Section 2.4: Geometric instructions
+    Cross = 104,
+    Distance = 105, 
+    Length = 106,
+    Normalize = 107,
+    Fast_distance = 108,
+    Fast_length = 109,
+    Fast_normalize = 110,
+
+    // Section 2.5: Relational instructions
+    Bitselect = 186,
+    Select = 187,
+
+    // Section 2.6: Vector Data Load and Store instructions
+    Vloadn = 171,
+    Vstoren = 172,
+    Vload_half = 173,
+    Vload_halfn = 174,
+    Vstore_half = 175,
+    Vstore_half_r = 176,
+    Vstore_halfn = 177,
+    Vstore_halfn_r = 178,
+    Vloada_halfn = 179,
+    Vstorea_halfn = 180,
+    Vstorea_halfn_r = 181,
+
+    // Section 2.7: Miscellaneous Vector instructions
+    Shuffle = 182,
+    Shuffle2 = 183,
+
+    // Section 2.8: Misc instructions 
+    Printf = 184,
+    Prefetch = 185,
+};
+
+} // end namespace OpenCLLIB

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/extinst.glsl.std.450.grammar.json

@@ -0,0 +1,642 @@
+{
+  "copyright" : [
+    "Copyright (c) 2014-2016 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "Round",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "RoundEven",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Trunc",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FAbs",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SAbs",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FSign",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SSign",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Floor",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ceil",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fract",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Radians",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'degrees'" }
+      ]
+    },
+    {
+      "opname" : "Degrees",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'radians'" }
+      ]
+    },
+    {
+      "opname" : "Sin",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cos",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tan",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asin",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acos",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y_over_x'" }
+      ]
+    },
+    {
+      "opname" : "Sinh",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cosh",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tanh",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asinh",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acosh",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atanh",
+      "opcode" : 24,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan2",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Pow",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Exp",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Exp2",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log2",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Sqrt",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "InverseSqrt",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Determinant",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "MatrixInverse",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Modf",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'i'" }
+      ]
+    },
+    {
+      "opname" : "ModfStruct",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FMin",
+      "opcode" : 37,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMin",
+      "opcode" : 38,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMin",
+      "opcode" : 39,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FMax",
+      "opcode" : 40,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMax",
+      "opcode" : 41,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMax",
+      "opcode" : 42,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FClamp",
+      "opcode" : 43,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "UClamp",
+      "opcode" : 44,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "SClamp",
+      "opcode" : 45,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "FMix",
+      "opcode" : 46,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "IMix",
+      "opcode" : 47,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "Step",
+      "opcode" : 48,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SmoothStep",
+      "opcode" : 49,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge0'" },
+        { "kind" : "IdRef", "name" : "'edge1'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fma",
+      "opcode" : 50,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'a'" },
+        { "kind" : "IdRef", "name" : "'b'" },
+        { "kind" : "IdRef", "name" : "'c'" }
+      ]
+    },
+    {
+      "opname" : "Frexp",
+      "opcode" : 51,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "FrexpStruct",
+      "opcode" : 52,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ldexp",
+      "opcode" : 53,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm4x8",
+      "opcode" : 54,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm4x8",
+      "opcode" : 55,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm2x16",
+      "opcode" : 56,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm2x16",
+      "opcode" : 57,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackHalf2x16",
+      "opcode" : 58,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackDouble2x32",
+      "opcode" : 59,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "UnpackSnorm2x16",
+      "opcode" : 60,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm2x16",
+      "opcode" : 61,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackHalf2x16",
+      "opcode" : 62,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "UnpackSnorm4x8",
+      "opcode" : 63,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm4x8",
+      "opcode" : 64,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackDouble2x32",
+      "opcode" : 65,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "Length",
+      "opcode" : 66,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Distance",
+      "opcode" : 67,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p0'" },
+        { "kind" : "IdRef", "name" : "'p1'" }
+      ]
+    },
+    {
+      "opname" : "Cross",
+      "opcode" : 68,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Normalize",
+      "opcode" : 69,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FaceForward",
+      "opcode" : 70,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'Nref'" }
+      ]
+    },
+    {
+      "opname" : "Reflect",
+      "opcode" : 71,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" }
+      ]
+    },
+    {
+      "opname" : "Refract",
+      "opcode" : 72,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'eta'" }
+      ]
+    },
+    {
+      "opname" : "FindILsb",
+      "opcode" : 73,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindSMsb",
+      "opcode" : 74,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindUMsb",
+      "opcode" : 75,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "InterpolateAtCentroid",
+      "opcode" : 76,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtSample",
+      "opcode" : 77,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'sample'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtOffset",
+      "opcode" : 78,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'offset'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "NMin",
+      "opcode" : 79,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NMax",
+      "opcode" : 80,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NClamp",
+      "opcode" : 81,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/spirv.cs

@@ -0,0 +1,993 @@
+// Copyright (c) 2014-2018 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+// This header is automatically generated by the same tool that creates
+// the Binary Section of the SPIR-V specification.
+
+// Enumeration tokens for SPIR-V, in various styles:
+//   C, C++, C++11, JSON, Lua, Python, C#
+// 
+// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+// - C# will use enum classes in the Specification class located in the "Spv" namespace, e.g.: Spv.Specification.SourceLanguage.GLSL
+// 
+// Some tokens act like mask values, which can be OR'd together,
+// while others are mutually exclusive.  The mask-like ones have
+// "Mask" in their name, and a parallel enum that has the shift
+// amount (1 << x) for each corresponding enumerant.
+
+namespace Spv
+{
+
+    public static class Specification
+    {
+        public const uint MagicNumber = 0x07230203;
+        public const uint Version = 0x00010000;
+        public const uint Revision = 12;
+        public const uint OpCodeMask = 0xffff;
+        public const uint WordCountShift = 16;
+
+        public enum SourceLanguage
+        {
+            Unknown = 0,
+            ESSL = 1,
+            GLSL = 2,
+            OpenCL_C = 3,
+            OpenCL_CPP = 4,
+            HLSL = 5,
+        }
+
+        public enum ExecutionModel
+        {
+            Vertex = 0,
+            TessellationControl = 1,
+            TessellationEvaluation = 2,
+            Geometry = 3,
+            Fragment = 4,
+            GLCompute = 5,
+            Kernel = 6,
+        }
+
+        public enum AddressingModel
+        {
+            Logical = 0,
+            Physical32 = 1,
+            Physical64 = 2,
+        }
+
+        public enum MemoryModel
+        {
+            Simple = 0,
+            GLSL450 = 1,
+            OpenCL = 2,
+        }
+
+        public enum ExecutionMode
+        {
+            Invocations = 0,
+            SpacingEqual = 1,
+            SpacingFractionalEven = 2,
+            SpacingFractionalOdd = 3,
+            VertexOrderCw = 4,
+            VertexOrderCcw = 5,
+            PixelCenterInteger = 6,
+            OriginUpperLeft = 7,
+            OriginLowerLeft = 8,
+            EarlyFragmentTests = 9,
+            PointMode = 10,
+            Xfb = 11,
+            DepthReplacing = 12,
+            DepthGreater = 14,
+            DepthLess = 15,
+            DepthUnchanged = 16,
+            LocalSize = 17,
+            LocalSizeHint = 18,
+            InputPoints = 19,
+            InputLines = 20,
+            InputLinesAdjacency = 21,
+            Triangles = 22,
+            InputTrianglesAdjacency = 23,
+            Quads = 24,
+            Isolines = 25,
+            OutputVertices = 26,
+            OutputPoints = 27,
+            OutputLineStrip = 28,
+            OutputTriangleStrip = 29,
+            VecTypeHint = 30,
+            ContractionOff = 31,
+            PostDepthCoverage = 4446,
+            StencilRefReplacingEXT = 5027,
+        }
+
+        public enum StorageClass
+        {
+            UniformConstant = 0,
+            Input = 1,
+            Uniform = 2,
+            Output = 3,
+            Workgroup = 4,
+            CrossWorkgroup = 5,
+            Private = 6,
+            Function = 7,
+            Generic = 8,
+            PushConstant = 9,
+            AtomicCounter = 10,
+            Image = 11,
+            StorageBuffer = 12,
+        }
+
+        public enum Dim
+        {
+            Dim1D = 0,
+            Dim2D = 1,
+            Dim3D = 2,
+            Cube = 3,
+            Rect = 4,
+            Buffer = 5,
+            SubpassData = 6,
+        }
+
+        public enum SamplerAddressingMode
+        {
+            None = 0,
+            ClampToEdge = 1,
+            Clamp = 2,
+            Repeat = 3,
+            RepeatMirrored = 4,
+        }
+
+        public enum SamplerFilterMode
+        {
+            Nearest = 0,
+            Linear = 1,
+        }
+
+        public enum ImageFormat
+        {
+            Unknown = 0,
+            Rgba32f = 1,
+            Rgba16f = 2,
+            R32f = 3,
+            Rgba8 = 4,
+            Rgba8Snorm = 5,
+            Rg32f = 6,
+            Rg16f = 7,
+            R11fG11fB10f = 8,
+            R16f = 9,
+            Rgba16 = 10,
+            Rgb10A2 = 11,
+            Rg16 = 12,
+            Rg8 = 13,
+            R16 = 14,
+            R8 = 15,
+            Rgba16Snorm = 16,
+            Rg16Snorm = 17,
+            Rg8Snorm = 18,
+            R16Snorm = 19,
+            R8Snorm = 20,
+            Rgba32i = 21,
+            Rgba16i = 22,
+            Rgba8i = 23,
+            R32i = 24,
+            Rg32i = 25,
+            Rg16i = 26,
+            Rg8i = 27,
+            R16i = 28,
+            R8i = 29,
+            Rgba32ui = 30,
+            Rgba16ui = 31,
+            Rgba8ui = 32,
+            R32ui = 33,
+            Rgb10a2ui = 34,
+            Rg32ui = 35,
+            Rg16ui = 36,
+            Rg8ui = 37,
+            R16ui = 38,
+            R8ui = 39,
+        }
+
+        public enum ImageChannelOrder
+        {
+            R = 0,
+            A = 1,
+            RG = 2,
+            RA = 3,
+            RGB = 4,
+            RGBA = 5,
+            BGRA = 6,
+            ARGB = 7,
+            Intensity = 8,
+            Luminance = 9,
+            Rx = 10,
+            RGx = 11,
+            RGBx = 12,
+            Depth = 13,
+            DepthStencil = 14,
+            sRGB = 15,
+            sRGBx = 16,
+            sRGBA = 17,
+            sBGRA = 18,
+            ABGR = 19,
+        }
+
+        public enum ImageChannelDataType
+        {
+            SnormInt8 = 0,
+            SnormInt16 = 1,
+            UnormInt8 = 2,
+            UnormInt16 = 3,
+            UnormShort565 = 4,
+            UnormShort555 = 5,
+            UnormInt101010 = 6,
+            SignedInt8 = 7,
+            SignedInt16 = 8,
+            SignedInt32 = 9,
+            UnsignedInt8 = 10,
+            UnsignedInt16 = 11,
+            UnsignedInt32 = 12,
+            HalfFloat = 13,
+            Float = 14,
+            UnormInt24 = 15,
+            UnormInt101010_2 = 16,
+        }
+
+        public enum ImageOperandsShift
+        {
+            Bias = 0,
+            Lod = 1,
+            Grad = 2,
+            ConstOffset = 3,
+            Offset = 4,
+            ConstOffsets = 5,
+            Sample = 6,
+            MinLod = 7,
+        }
+
+        public enum ImageOperandsMask
+        {
+            MaskNone = 0,
+            Bias = 0x00000001,
+            Lod = 0x00000002,
+            Grad = 0x00000004,
+            ConstOffset = 0x00000008,
+            Offset = 0x00000010,
+            ConstOffsets = 0x00000020,
+            Sample = 0x00000040,
+            MinLod = 0x00000080,
+        }
+
+        public enum FPFastMathModeShift
+        {
+            NotNaN = 0,
+            NotInf = 1,
+            NSZ = 2,
+            AllowRecip = 3,
+            Fast = 4,
+        }
+
+        public enum FPFastMathModeMask
+        {
+            MaskNone = 0,
+            NotNaN = 0x00000001,
+            NotInf = 0x00000002,
+            NSZ = 0x00000004,
+            AllowRecip = 0x00000008,
+            Fast = 0x00000010,
+        }
+
+        public enum FPRoundingMode
+        {
+            RTE = 0,
+            RTZ = 1,
+            RTP = 2,
+            RTN = 3,
+        }
+
+        public enum LinkageType
+        {
+            Export = 0,
+            Import = 1,
+        }
+
+        public enum AccessQualifier
+        {
+            ReadOnly = 0,
+            WriteOnly = 1,
+            ReadWrite = 2,
+        }
+
+        public enum FunctionParameterAttribute
+        {
+            Zext = 0,
+            Sext = 1,
+            ByVal = 2,
+            Sret = 3,
+            NoAlias = 4,
+            NoCapture = 5,
+            NoWrite = 6,
+            NoReadWrite = 7,
+        }
+
+        public enum Decoration
+        {
+            RelaxedPrecision = 0,
+            SpecId = 1,
+            Block = 2,
+            BufferBlock = 3,
+            RowMajor = 4,
+            ColMajor = 5,
+            ArrayStride = 6,
+            MatrixStride = 7,
+            GLSLShared = 8,
+            GLSLPacked = 9,
+            CPacked = 10,
+            BuiltIn = 11,
+            NoPerspective = 13,
+            Flat = 14,
+            Patch = 15,
+            Centroid = 16,
+            Sample = 17,
+            Invariant = 18,
+            Restrict = 19,
+            Aliased = 20,
+            Volatile = 21,
+            Constant = 22,
+            Coherent = 23,
+            NonWritable = 24,
+            NonReadable = 25,
+            Uniform = 26,
+            SaturatedConversion = 28,
+            Stream = 29,
+            Location = 30,
+            Component = 31,
+            Index = 32,
+            Binding = 33,
+            DescriptorSet = 34,
+            Offset = 35,
+            XfbBuffer = 36,
+            XfbStride = 37,
+            FuncParamAttr = 38,
+            FPRoundingMode = 39,
+            FPFastMathMode = 40,
+            LinkageAttributes = 41,
+            NoContraction = 42,
+            InputAttachmentIndex = 43,
+            Alignment = 44,
+            ExplicitInterpAMD = 4999,
+            OverrideCoverageNV = 5248,
+            PassthroughNV = 5250,
+            ViewportRelativeNV = 5252,
+            SecondaryViewportRelativeNV = 5256,
+            HlslCounterBufferGOOGLE = 5634,
+            HlslSemanticGOOGLE = 5635,
+        }
+
+        public enum BuiltIn
+        {
+            Position = 0,
+            PointSize = 1,
+            ClipDistance = 3,
+            CullDistance = 4,
+            VertexId = 5,
+            InstanceId = 6,
+            PrimitiveId = 7,
+            InvocationId = 8,
+            Layer = 9,
+            ViewportIndex = 10,
+            TessLevelOuter = 11,
+            TessLevelInner = 12,
+            TessCoord = 13,
+            PatchVertices = 14,
+            FragCoord = 15,
+            PointCoord = 16,
+            FrontFacing = 17,
+            SampleId = 18,
+            SamplePosition = 19,
+            SampleMask = 20,
+            FragDepth = 22,
+            HelperInvocation = 23,
+            NumWorkgroups = 24,
+            WorkgroupSize = 25,
+            WorkgroupId = 26,
+            LocalInvocationId = 27,
+            GlobalInvocationId = 28,
+            LocalInvocationIndex = 29,
+            WorkDim = 30,
+            GlobalSize = 31,
+            EnqueuedWorkgroupSize = 32,
+            GlobalOffset = 33,
+            GlobalLinearId = 34,
+            SubgroupSize = 36,
+            SubgroupMaxSize = 37,
+            NumSubgroups = 38,
+            NumEnqueuedSubgroups = 39,
+            SubgroupId = 40,
+            SubgroupLocalInvocationId = 41,
+            VertexIndex = 42,
+            InstanceIndex = 43,
+            SubgroupEqMaskKHR = 4416,
+            SubgroupGeMaskKHR = 4417,
+            SubgroupGtMaskKHR = 4418,
+            SubgroupLeMaskKHR = 4419,
+            SubgroupLtMaskKHR = 4420,
+            BaseVertex = 4424,
+            BaseInstance = 4425,
+            DrawIndex = 4426,
+            DeviceIndex = 4438,
+            ViewIndex = 4440,
+            BaryCoordNoPerspAMD = 4992,
+            BaryCoordNoPerspCentroidAMD = 4993,
+            BaryCoordNoPerspSampleAMD = 4994,
+            BaryCoordSmoothAMD = 4995,
+            BaryCoordSmoothCentroidAMD = 4996,
+            BaryCoordSmoothSampleAMD = 4997,
+            BaryCoordPullModelAMD = 4998,
+            FragStencilRefEXT = 5014,
+            ViewportMaskNV = 5253,
+            SecondaryPositionNV = 5257,
+            SecondaryViewportMaskNV = 5258,
+            PositionPerViewNV = 5261,
+            ViewportMaskPerViewNV = 5262,
+        }
+
+        public enum SelectionControlShift
+        {
+            Flatten = 0,
+            DontFlatten = 1,
+        }
+
+        public enum SelectionControlMask
+        {
+            MaskNone = 0,
+            Flatten = 0x00000001,
+            DontFlatten = 0x00000002,
+        }
+
+        public enum LoopControlShift
+        {
+            Unroll = 0,
+            DontUnroll = 1,
+        }
+
+        public enum LoopControlMask
+        {
+            MaskNone = 0,
+            Unroll = 0x00000001,
+            DontUnroll = 0x00000002,
+        }
+
+        public enum FunctionControlShift
+        {
+            Inline = 0,
+            DontInline = 1,
+            Pure = 2,
+            Const = 3,
+        }
+
+        public enum FunctionControlMask
+        {
+            MaskNone = 0,
+            Inline = 0x00000001,
+            DontInline = 0x00000002,
+            Pure = 0x00000004,
+            Const = 0x00000008,
+        }
+
+        public enum MemorySemanticsShift
+        {
+            Acquire = 1,
+            Release = 2,
+            AcquireRelease = 3,
+            SequentiallyConsistent = 4,
+            UniformMemory = 6,
+            SubgroupMemory = 7,
+            WorkgroupMemory = 8,
+            CrossWorkgroupMemory = 9,
+            AtomicCounterMemory = 10,
+            ImageMemory = 11,
+        }
+
+        public enum MemorySemanticsMask
+        {
+            MaskNone = 0,
+            Acquire = 0x00000002,
+            Release = 0x00000004,
+            AcquireRelease = 0x00000008,
+            SequentiallyConsistent = 0x00000010,
+            UniformMemory = 0x00000040,
+            SubgroupMemory = 0x00000080,
+            WorkgroupMemory = 0x00000100,
+            CrossWorkgroupMemory = 0x00000200,
+            AtomicCounterMemory = 0x00000400,
+            ImageMemory = 0x00000800,
+        }
+
+        public enum MemoryAccessShift
+        {
+            Volatile = 0,
+            Aligned = 1,
+            Nontemporal = 2,
+        }
+
+        public enum MemoryAccessMask
+        {
+            MaskNone = 0,
+            Volatile = 0x00000001,
+            Aligned = 0x00000002,
+            Nontemporal = 0x00000004,
+        }
+
+        public enum Scope
+        {
+            CrossDevice = 0,
+            Device = 1,
+            Workgroup = 2,
+            Subgroup = 3,
+            Invocation = 4,
+        }
+
+        public enum GroupOperation
+        {
+            Reduce = 0,
+            InclusiveScan = 1,
+            ExclusiveScan = 2,
+        }
+
+        public enum KernelEnqueueFlags
+        {
+            NoWait = 0,
+            WaitKernel = 1,
+            WaitWorkGroup = 2,
+        }
+
+        public enum KernelProfilingInfoShift
+        {
+            CmdExecTime = 0,
+        }
+
+        public enum KernelProfilingInfoMask
+        {
+            MaskNone = 0,
+            CmdExecTime = 0x00000001,
+        }
+
+        public enum Capability
+        {
+            Matrix = 0,
+            Shader = 1,
+            Geometry = 2,
+            Tessellation = 3,
+            Addresses = 4,
+            Linkage = 5,
+            Kernel = 6,
+            Vector16 = 7,
+            Float16Buffer = 8,
+            Float16 = 9,
+            Float64 = 10,
+            Int64 = 11,
+            Int64Atomics = 12,
+            ImageBasic = 13,
+            ImageReadWrite = 14,
+            ImageMipmap = 15,
+            Pipes = 17,
+            Groups = 18,
+            DeviceEnqueue = 19,
+            LiteralSampler = 20,
+            AtomicStorage = 21,
+            Int16 = 22,
+            TessellationPointSize = 23,
+            GeometryPointSize = 24,
+            ImageGatherExtended = 25,
+            StorageImageMultisample = 27,
+            UniformBufferArrayDynamicIndexing = 28,
+            SampledImageArrayDynamicIndexing = 29,
+            StorageBufferArrayDynamicIndexing = 30,
+            StorageImageArrayDynamicIndexing = 31,
+            ClipDistance = 32,
+            CullDistance = 33,
+            ImageCubeArray = 34,
+            SampleRateShading = 35,
+            ImageRect = 36,
+            SampledRect = 37,
+            GenericPointer = 38,
+            Int8 = 39,
+            InputAttachment = 40,
+            SparseResidency = 41,
+            MinLod = 42,
+            Sampled1D = 43,
+            Image1D = 44,
+            SampledCubeArray = 45,
+            SampledBuffer = 46,
+            ImageBuffer = 47,
+            ImageMSArray = 48,
+            StorageImageExtendedFormats = 49,
+            ImageQuery = 50,
+            DerivativeControl = 51,
+            InterpolationFunction = 52,
+            TransformFeedback = 53,
+            GeometryStreams = 54,
+            StorageImageReadWithoutFormat = 55,
+            StorageImageWriteWithoutFormat = 56,
+            MultiViewport = 57,
+            SubgroupBallotKHR = 4423,
+            DrawParameters = 4427,
+            SubgroupVoteKHR = 4431,
+            StorageBuffer16BitAccess = 4433,
+            StorageUniformBufferBlock16 = 4433,
+            StorageUniform16 = 4434,
+            UniformAndStorageBuffer16BitAccess = 4434,
+            StoragePushConstant16 = 4435,
+            StorageInputOutput16 = 4436,
+            DeviceGroup = 4437,
+            MultiView = 4439,
+            VariablePointersStorageBuffer = 4441,
+            VariablePointers = 4442,
+            AtomicStorageOps = 4445,
+            SampleMaskPostDepthCoverage = 4447,
+            ImageGatherBiasLodAMD = 5009,
+            FragmentMaskAMD = 5010,
+            StencilExportEXT = 5013,
+            ImageReadWriteLodAMD = 5015,
+            SampleMaskOverrideCoverageNV = 5249,
+            GeometryShaderPassthroughNV = 5251,
+            ShaderViewportIndexLayerEXT = 5254,
+            ShaderViewportIndexLayerNV = 5254,
+            ShaderViewportMaskNV = 5255,
+            ShaderStereoViewNV = 5259,
+            PerViewAttributesNV = 5260,
+            SubgroupShuffleINTEL = 5568,
+            SubgroupBufferBlockIOINTEL = 5569,
+            SubgroupImageBlockIOINTEL = 5570,
+        }
+
+        public enum Op
+        {
+            OpNop = 0,
+            OpUndef = 1,
+            OpSourceContinued = 2,
+            OpSource = 3,
+            OpSourceExtension = 4,
+            OpName = 5,
+            OpMemberName = 6,
+            OpString = 7,
+            OpLine = 8,
+            OpExtension = 10,
+            OpExtInstImport = 11,
+            OpExtInst = 12,
+            OpMemoryModel = 14,
+            OpEntryPoint = 15,
+            OpExecutionMode = 16,
+            OpCapability = 17,
+            OpTypeVoid = 19,
+            OpTypeBool = 20,
+            OpTypeInt = 21,
+            OpTypeFloat = 22,
+            OpTypeVector = 23,
+            OpTypeMatrix = 24,
+            OpTypeImage = 25,
+            OpTypeSampler = 26,
+            OpTypeSampledImage = 27,
+            OpTypeArray = 28,
+            OpTypeRuntimeArray = 29,
+            OpTypeStruct = 30,
+            OpTypeOpaque = 31,
+            OpTypePointer = 32,
+            OpTypeFunction = 33,
+            OpTypeEvent = 34,
+            OpTypeDeviceEvent = 35,
+            OpTypeReserveId = 36,
+            OpTypeQueue = 37,
+            OpTypePipe = 38,
+            OpTypeForwardPointer = 39,
+            OpConstantTrue = 41,
+            OpConstantFalse = 42,
+            OpConstant = 43,
+            OpConstantComposite = 44,
+            OpConstantSampler = 45,
+            OpConstantNull = 46,
+            OpSpecConstantTrue = 48,
+            OpSpecConstantFalse = 49,
+            OpSpecConstant = 50,
+            OpSpecConstantComposite = 51,
+            OpSpecConstantOp = 52,
+            OpFunction = 54,
+            OpFunctionParameter = 55,
+            OpFunctionEnd = 56,
+            OpFunctionCall = 57,
+            OpVariable = 59,
+            OpImageTexelPointer = 60,
+            OpLoad = 61,
+            OpStore = 62,
+            OpCopyMemory = 63,
+            OpCopyMemorySized = 64,
+            OpAccessChain = 65,
+            OpInBoundsAccessChain = 66,
+            OpPtrAccessChain = 67,
+            OpArrayLength = 68,
+            OpGenericPtrMemSemantics = 69,
+            OpInBoundsPtrAccessChain = 70,
+            OpDecorate = 71,
+            OpMemberDecorate = 72,
+            OpDecorationGroup = 73,
+            OpGroupDecorate = 74,
+            OpGroupMemberDecorate = 75,
+            OpVectorExtractDynamic = 77,
+            OpVectorInsertDynamic = 78,
+            OpVectorShuffle = 79,
+            OpCompositeConstruct = 80,
+            OpCompositeExtract = 81,
+            OpCompositeInsert = 82,
+            OpCopyObject = 83,
+            OpTranspose = 84,
+            OpSampledImage = 86,
+            OpImageSampleImplicitLod = 87,
+            OpImageSampleExplicitLod = 88,
+            OpImageSampleDrefImplicitLod = 89,
+            OpImageSampleDrefExplicitLod = 90,
+            OpImageSampleProjImplicitLod = 91,
+            OpImageSampleProjExplicitLod = 92,
+            OpImageSampleProjDrefImplicitLod = 93,
+            OpImageSampleProjDrefExplicitLod = 94,
+            OpImageFetch = 95,
+            OpImageGather = 96,
+            OpImageDrefGather = 97,
+            OpImageRead = 98,
+            OpImageWrite = 99,
+            OpImage = 100,
+            OpImageQueryFormat = 101,
+            OpImageQueryOrder = 102,
+            OpImageQuerySizeLod = 103,
+            OpImageQuerySize = 104,
+            OpImageQueryLod = 105,
+            OpImageQueryLevels = 106,
+            OpImageQuerySamples = 107,
+            OpConvertFToU = 109,
+            OpConvertFToS = 110,
+            OpConvertSToF = 111,
+            OpConvertUToF = 112,
+            OpUConvert = 113,
+            OpSConvert = 114,
+            OpFConvert = 115,
+            OpQuantizeToF16 = 116,
+            OpConvertPtrToU = 117,
+            OpSatConvertSToU = 118,
+            OpSatConvertUToS = 119,
+            OpConvertUToPtr = 120,
+            OpPtrCastToGeneric = 121,
+            OpGenericCastToPtr = 122,
+            OpGenericCastToPtrExplicit = 123,
+            OpBitcast = 124,
+            OpSNegate = 126,
+            OpFNegate = 127,
+            OpIAdd = 128,
+            OpFAdd = 129,
+            OpISub = 130,
+            OpFSub = 131,
+            OpIMul = 132,
+            OpFMul = 133,
+            OpUDiv = 134,
+            OpSDiv = 135,
+            OpFDiv = 136,
+            OpUMod = 137,
+            OpSRem = 138,
+            OpSMod = 139,
+            OpFRem = 140,
+            OpFMod = 141,
+            OpVectorTimesScalar = 142,
+            OpMatrixTimesScalar = 143,
+            OpVectorTimesMatrix = 144,
+            OpMatrixTimesVector = 145,
+            OpMatrixTimesMatrix = 146,
+            OpOuterProduct = 147,
+            OpDot = 148,
+            OpIAddCarry = 149,
+            OpISubBorrow = 150,
+            OpUMulExtended = 151,
+            OpSMulExtended = 152,
+            OpAny = 154,
+            OpAll = 155,
+            OpIsNan = 156,
+            OpIsInf = 157,
+            OpIsFinite = 158,
+            OpIsNormal = 159,
+            OpSignBitSet = 160,
+            OpLessOrGreater = 161,
+            OpOrdered = 162,
+            OpUnordered = 163,
+            OpLogicalEqual = 164,
+            OpLogicalNotEqual = 165,
+            OpLogicalOr = 166,
+            OpLogicalAnd = 167,
+            OpLogicalNot = 168,
+            OpSelect = 169,
+            OpIEqual = 170,
+            OpINotEqual = 171,
+            OpUGreaterThan = 172,
+            OpSGreaterThan = 173,
+            OpUGreaterThanEqual = 174,
+            OpSGreaterThanEqual = 175,
+            OpULessThan = 176,
+            OpSLessThan = 177,
+            OpULessThanEqual = 178,
+            OpSLessThanEqual = 179,
+            OpFOrdEqual = 180,
+            OpFUnordEqual = 181,
+            OpFOrdNotEqual = 182,
+            OpFUnordNotEqual = 183,
+            OpFOrdLessThan = 184,
+            OpFUnordLessThan = 185,
+            OpFOrdGreaterThan = 186,
+            OpFUnordGreaterThan = 187,
+            OpFOrdLessThanEqual = 188,
+            OpFUnordLessThanEqual = 189,
+            OpFOrdGreaterThanEqual = 190,
+            OpFUnordGreaterThanEqual = 191,
+            OpShiftRightLogical = 194,
+            OpShiftRightArithmetic = 195,
+            OpShiftLeftLogical = 196,
+            OpBitwiseOr = 197,
+            OpBitwiseXor = 198,
+            OpBitwiseAnd = 199,
+            OpNot = 200,
+            OpBitFieldInsert = 201,
+            OpBitFieldSExtract = 202,
+            OpBitFieldUExtract = 203,
+            OpBitReverse = 204,
+            OpBitCount = 205,
+            OpDPdx = 207,
+            OpDPdy = 208,
+            OpFwidth = 209,
+            OpDPdxFine = 210,
+            OpDPdyFine = 211,
+            OpFwidthFine = 212,
+            OpDPdxCoarse = 213,
+            OpDPdyCoarse = 214,
+            OpFwidthCoarse = 215,
+            OpEmitVertex = 218,
+            OpEndPrimitive = 219,
+            OpEmitStreamVertex = 220,
+            OpEndStreamPrimitive = 221,
+            OpControlBarrier = 224,
+            OpMemoryBarrier = 225,
+            OpAtomicLoad = 227,
+            OpAtomicStore = 228,
+            OpAtomicExchange = 229,
+            OpAtomicCompareExchange = 230,
+            OpAtomicCompareExchangeWeak = 231,
+            OpAtomicIIncrement = 232,
+            OpAtomicIDecrement = 233,
+            OpAtomicIAdd = 234,
+            OpAtomicISub = 235,
+            OpAtomicSMin = 236,
+            OpAtomicUMin = 237,
+            OpAtomicSMax = 238,
+            OpAtomicUMax = 239,
+            OpAtomicAnd = 240,
+            OpAtomicOr = 241,
+            OpAtomicXor = 242,
+            OpPhi = 245,
+            OpLoopMerge = 246,
+            OpSelectionMerge = 247,
+            OpLabel = 248,
+            OpBranch = 249,
+            OpBranchConditional = 250,
+            OpSwitch = 251,
+            OpKill = 252,
+            OpReturn = 253,
+            OpReturnValue = 254,
+            OpUnreachable = 255,
+            OpLifetimeStart = 256,
+            OpLifetimeStop = 257,
+            OpGroupAsyncCopy = 259,
+            OpGroupWaitEvents = 260,
+            OpGroupAll = 261,
+            OpGroupAny = 262,
+            OpGroupBroadcast = 263,
+            OpGroupIAdd = 264,
+            OpGroupFAdd = 265,
+            OpGroupFMin = 266,
+            OpGroupUMin = 267,
+            OpGroupSMin = 268,
+            OpGroupFMax = 269,
+            OpGroupUMax = 270,
+            OpGroupSMax = 271,
+            OpReadPipe = 274,
+            OpWritePipe = 275,
+            OpReservedReadPipe = 276,
+            OpReservedWritePipe = 277,
+            OpReserveReadPipePackets = 278,
+            OpReserveWritePipePackets = 279,
+            OpCommitReadPipe = 280,
+            OpCommitWritePipe = 281,
+            OpIsValidReserveId = 282,
+            OpGetNumPipePackets = 283,
+            OpGetMaxPipePackets = 284,
+            OpGroupReserveReadPipePackets = 285,
+            OpGroupReserveWritePipePackets = 286,
+            OpGroupCommitReadPipe = 287,
+            OpGroupCommitWritePipe = 288,
+            OpEnqueueMarker = 291,
+            OpEnqueueKernel = 292,
+            OpGetKernelNDrangeSubGroupCount = 293,
+            OpGetKernelNDrangeMaxSubGroupSize = 294,
+            OpGetKernelWorkGroupSize = 295,
+            OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+            OpRetainEvent = 297,
+            OpReleaseEvent = 298,
+            OpCreateUserEvent = 299,
+            OpIsValidEvent = 300,
+            OpSetUserEventStatus = 301,
+            OpCaptureEventProfilingInfo = 302,
+            OpGetDefaultQueue = 303,
+            OpBuildNDRange = 304,
+            OpImageSparseSampleImplicitLod = 305,
+            OpImageSparseSampleExplicitLod = 306,
+            OpImageSparseSampleDrefImplicitLod = 307,
+            OpImageSparseSampleDrefExplicitLod = 308,
+            OpImageSparseSampleProjImplicitLod = 309,
+            OpImageSparseSampleProjExplicitLod = 310,
+            OpImageSparseSampleProjDrefImplicitLod = 311,
+            OpImageSparseSampleProjDrefExplicitLod = 312,
+            OpImageSparseFetch = 313,
+            OpImageSparseGather = 314,
+            OpImageSparseDrefGather = 315,
+            OpImageSparseTexelsResident = 316,
+            OpNoLine = 317,
+            OpAtomicFlagTestAndSet = 318,
+            OpAtomicFlagClear = 319,
+            OpImageSparseRead = 320,
+            OpDecorateId = 332,
+            OpSubgroupBallotKHR = 4421,
+            OpSubgroupFirstInvocationKHR = 4422,
+            OpSubgroupAllKHR = 4428,
+            OpSubgroupAnyKHR = 4429,
+            OpSubgroupAllEqualKHR = 4430,
+            OpSubgroupReadInvocationKHR = 4432,
+            OpGroupIAddNonUniformAMD = 5000,
+            OpGroupFAddNonUniformAMD = 5001,
+            OpGroupFMinNonUniformAMD = 5002,
+            OpGroupUMinNonUniformAMD = 5003,
+            OpGroupSMinNonUniformAMD = 5004,
+            OpGroupFMaxNonUniformAMD = 5005,
+            OpGroupUMaxNonUniformAMD = 5006,
+            OpGroupSMaxNonUniformAMD = 5007,
+            OpFragmentMaskFetchAMD = 5011,
+            OpFragmentFetchAMD = 5012,
+            OpSubgroupShuffleINTEL = 5571,
+            OpSubgroupShuffleDownINTEL = 5572,
+            OpSubgroupShuffleUpINTEL = 5573,
+            OpSubgroupShuffleXorINTEL = 5574,
+            OpSubgroupBlockReadINTEL = 5575,
+            OpSubgroupBlockWriteINTEL = 5576,
+            OpSubgroupImageBlockReadINTEL = 5577,
+            OpSubgroupImageBlockWriteINTEL = 5578,
+            OpDecorateStringGOOGLE = 5632,
+            OpMemberDecorateStringGOOGLE = 5633,
+        }
+    }
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/spirv.h

@@ -0,0 +1,993 @@
+/*
+** Copyright (c) 2014-2018 The Khronos Group Inc.
+** 
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+** 
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+** 
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+** 
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+/*
+** This header is automatically generated by the same tool that creates
+** the Binary Section of the SPIR-V specification.
+*/
+
+/*
+** Enumeration tokens for SPIR-V, in various styles:
+**   C, C++, C++11, JSON, Lua, Python
+** 
+** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+** 
+** Some tokens act like mask values, which can be OR'd together,
+** while others are mutually exclusive.  The mask-like ones have
+** "Mask" in their name, and a parallel enum that has the shift
+** amount (1 << x) for each corresponding enumerant.
+*/
+
+#ifndef spirv_H
+#define spirv_H
+
+typedef unsigned int SpvId;
+
+#define SPV_VERSION 0x10000
+#define SPV_REVISION 12
+
+static const unsigned int SpvMagicNumber = 0x07230203;
+static const unsigned int SpvVersion = 0x00010000;
+static const unsigned int SpvRevision = 12;
+static const unsigned int SpvOpCodeMask = 0xffff;
+static const unsigned int SpvWordCountShift = 16;
+
+typedef enum SpvSourceLanguage_ {
+    SpvSourceLanguageUnknown = 0,
+    SpvSourceLanguageESSL = 1,
+    SpvSourceLanguageGLSL = 2,
+    SpvSourceLanguageOpenCL_C = 3,
+    SpvSourceLanguageOpenCL_CPP = 4,
+    SpvSourceLanguageHLSL = 5,
+    SpvSourceLanguageMax = 0x7fffffff,
+} SpvSourceLanguage;
+
+typedef enum SpvExecutionModel_ {
+    SpvExecutionModelVertex = 0,
+    SpvExecutionModelTessellationControl = 1,
+    SpvExecutionModelTessellationEvaluation = 2,
+    SpvExecutionModelGeometry = 3,
+    SpvExecutionModelFragment = 4,
+    SpvExecutionModelGLCompute = 5,
+    SpvExecutionModelKernel = 6,
+    SpvExecutionModelMax = 0x7fffffff,
+} SpvExecutionModel;
+
+typedef enum SpvAddressingModel_ {
+    SpvAddressingModelLogical = 0,
+    SpvAddressingModelPhysical32 = 1,
+    SpvAddressingModelPhysical64 = 2,
+    SpvAddressingModelMax = 0x7fffffff,
+} SpvAddressingModel;
+
+typedef enum SpvMemoryModel_ {
+    SpvMemoryModelSimple = 0,
+    SpvMemoryModelGLSL450 = 1,
+    SpvMemoryModelOpenCL = 2,
+    SpvMemoryModelMax = 0x7fffffff,
+} SpvMemoryModel;
+
+typedef enum SpvExecutionMode_ {
+    SpvExecutionModeInvocations = 0,
+    SpvExecutionModeSpacingEqual = 1,
+    SpvExecutionModeSpacingFractionalEven = 2,
+    SpvExecutionModeSpacingFractionalOdd = 3,
+    SpvExecutionModeVertexOrderCw = 4,
+    SpvExecutionModeVertexOrderCcw = 5,
+    SpvExecutionModePixelCenterInteger = 6,
+    SpvExecutionModeOriginUpperLeft = 7,
+    SpvExecutionModeOriginLowerLeft = 8,
+    SpvExecutionModeEarlyFragmentTests = 9,
+    SpvExecutionModePointMode = 10,
+    SpvExecutionModeXfb = 11,
+    SpvExecutionModeDepthReplacing = 12,
+    SpvExecutionModeDepthGreater = 14,
+    SpvExecutionModeDepthLess = 15,
+    SpvExecutionModeDepthUnchanged = 16,
+    SpvExecutionModeLocalSize = 17,
+    SpvExecutionModeLocalSizeHint = 18,
+    SpvExecutionModeInputPoints = 19,
+    SpvExecutionModeInputLines = 20,
+    SpvExecutionModeInputLinesAdjacency = 21,
+    SpvExecutionModeTriangles = 22,
+    SpvExecutionModeInputTrianglesAdjacency = 23,
+    SpvExecutionModeQuads = 24,
+    SpvExecutionModeIsolines = 25,
+    SpvExecutionModeOutputVertices = 26,
+    SpvExecutionModeOutputPoints = 27,
+    SpvExecutionModeOutputLineStrip = 28,
+    SpvExecutionModeOutputTriangleStrip = 29,
+    SpvExecutionModeVecTypeHint = 30,
+    SpvExecutionModeContractionOff = 31,
+    SpvExecutionModePostDepthCoverage = 4446,
+    SpvExecutionModeStencilRefReplacingEXT = 5027,
+    SpvExecutionModeMax = 0x7fffffff,
+} SpvExecutionMode;
+
+typedef enum SpvStorageClass_ {
+    SpvStorageClassUniformConstant = 0,
+    SpvStorageClassInput = 1,
+    SpvStorageClassUniform = 2,
+    SpvStorageClassOutput = 3,
+    SpvStorageClassWorkgroup = 4,
+    SpvStorageClassCrossWorkgroup = 5,
+    SpvStorageClassPrivate = 6,
+    SpvStorageClassFunction = 7,
+    SpvStorageClassGeneric = 8,
+    SpvStorageClassPushConstant = 9,
+    SpvStorageClassAtomicCounter = 10,
+    SpvStorageClassImage = 11,
+    SpvStorageClassStorageBuffer = 12,
+    SpvStorageClassMax = 0x7fffffff,
+} SpvStorageClass;
+
+typedef enum SpvDim_ {
+    SpvDim1D = 0,
+    SpvDim2D = 1,
+    SpvDim3D = 2,
+    SpvDimCube = 3,
+    SpvDimRect = 4,
+    SpvDimBuffer = 5,
+    SpvDimSubpassData = 6,
+    SpvDimMax = 0x7fffffff,
+} SpvDim;
+
+typedef enum SpvSamplerAddressingMode_ {
+    SpvSamplerAddressingModeNone = 0,
+    SpvSamplerAddressingModeClampToEdge = 1,
+    SpvSamplerAddressingModeClamp = 2,
+    SpvSamplerAddressingModeRepeat = 3,
+    SpvSamplerAddressingModeRepeatMirrored = 4,
+    SpvSamplerAddressingModeMax = 0x7fffffff,
+} SpvSamplerAddressingMode;
+
+typedef enum SpvSamplerFilterMode_ {
+    SpvSamplerFilterModeNearest = 0,
+    SpvSamplerFilterModeLinear = 1,
+    SpvSamplerFilterModeMax = 0x7fffffff,
+} SpvSamplerFilterMode;
+
+typedef enum SpvImageFormat_ {
+    SpvImageFormatUnknown = 0,
+    SpvImageFormatRgba32f = 1,
+    SpvImageFormatRgba16f = 2,
+    SpvImageFormatR32f = 3,
+    SpvImageFormatRgba8 = 4,
+    SpvImageFormatRgba8Snorm = 5,
+    SpvImageFormatRg32f = 6,
+    SpvImageFormatRg16f = 7,
+    SpvImageFormatR11fG11fB10f = 8,
+    SpvImageFormatR16f = 9,
+    SpvImageFormatRgba16 = 10,
+    SpvImageFormatRgb10A2 = 11,
+    SpvImageFormatRg16 = 12,
+    SpvImageFormatRg8 = 13,
+    SpvImageFormatR16 = 14,
+    SpvImageFormatR8 = 15,
+    SpvImageFormatRgba16Snorm = 16,
+    SpvImageFormatRg16Snorm = 17,
+    SpvImageFormatRg8Snorm = 18,
+    SpvImageFormatR16Snorm = 19,
+    SpvImageFormatR8Snorm = 20,
+    SpvImageFormatRgba32i = 21,
+    SpvImageFormatRgba16i = 22,
+    SpvImageFormatRgba8i = 23,
+    SpvImageFormatR32i = 24,
+    SpvImageFormatRg32i = 25,
+    SpvImageFormatRg16i = 26,
+    SpvImageFormatRg8i = 27,
+    SpvImageFormatR16i = 28,
+    SpvImageFormatR8i = 29,
+    SpvImageFormatRgba32ui = 30,
+    SpvImageFormatRgba16ui = 31,
+    SpvImageFormatRgba8ui = 32,
+    SpvImageFormatR32ui = 33,
+    SpvImageFormatRgb10a2ui = 34,
+    SpvImageFormatRg32ui = 35,
+    SpvImageFormatRg16ui = 36,
+    SpvImageFormatRg8ui = 37,
+    SpvImageFormatR16ui = 38,
+    SpvImageFormatR8ui = 39,
+    SpvImageFormatMax = 0x7fffffff,
+} SpvImageFormat;
+
+typedef enum SpvImageChannelOrder_ {
+    SpvImageChannelOrderR = 0,
+    SpvImageChannelOrderA = 1,
+    SpvImageChannelOrderRG = 2,
+    SpvImageChannelOrderRA = 3,
+    SpvImageChannelOrderRGB = 4,
+    SpvImageChannelOrderRGBA = 5,
+    SpvImageChannelOrderBGRA = 6,
+    SpvImageChannelOrderARGB = 7,
+    SpvImageChannelOrderIntensity = 8,
+    SpvImageChannelOrderLuminance = 9,
+    SpvImageChannelOrderRx = 10,
+    SpvImageChannelOrderRGx = 11,
+    SpvImageChannelOrderRGBx = 12,
+    SpvImageChannelOrderDepth = 13,
+    SpvImageChannelOrderDepthStencil = 14,
+    SpvImageChannelOrdersRGB = 15,
+    SpvImageChannelOrdersRGBx = 16,
+    SpvImageChannelOrdersRGBA = 17,
+    SpvImageChannelOrdersBGRA = 18,
+    SpvImageChannelOrderABGR = 19,
+    SpvImageChannelOrderMax = 0x7fffffff,
+} SpvImageChannelOrder;
+
+typedef enum SpvImageChannelDataType_ {
+    SpvImageChannelDataTypeSnormInt8 = 0,
+    SpvImageChannelDataTypeSnormInt16 = 1,
+    SpvImageChannelDataTypeUnormInt8 = 2,
+    SpvImageChannelDataTypeUnormInt16 = 3,
+    SpvImageChannelDataTypeUnormShort565 = 4,
+    SpvImageChannelDataTypeUnormShort555 = 5,
+    SpvImageChannelDataTypeUnormInt101010 = 6,
+    SpvImageChannelDataTypeSignedInt8 = 7,
+    SpvImageChannelDataTypeSignedInt16 = 8,
+    SpvImageChannelDataTypeSignedInt32 = 9,
+    SpvImageChannelDataTypeUnsignedInt8 = 10,
+    SpvImageChannelDataTypeUnsignedInt16 = 11,
+    SpvImageChannelDataTypeUnsignedInt32 = 12,
+    SpvImageChannelDataTypeHalfFloat = 13,
+    SpvImageChannelDataTypeFloat = 14,
+    SpvImageChannelDataTypeUnormInt24 = 15,
+    SpvImageChannelDataTypeUnormInt101010_2 = 16,
+    SpvImageChannelDataTypeMax = 0x7fffffff,
+} SpvImageChannelDataType;
+
+typedef enum SpvImageOperandsShift_ {
+    SpvImageOperandsBiasShift = 0,
+    SpvImageOperandsLodShift = 1,
+    SpvImageOperandsGradShift = 2,
+    SpvImageOperandsConstOffsetShift = 3,
+    SpvImageOperandsOffsetShift = 4,
+    SpvImageOperandsConstOffsetsShift = 5,
+    SpvImageOperandsSampleShift = 6,
+    SpvImageOperandsMinLodShift = 7,
+    SpvImageOperandsMax = 0x7fffffff,
+} SpvImageOperandsShift;
+
+typedef enum SpvImageOperandsMask_ {
+    SpvImageOperandsMaskNone = 0,
+    SpvImageOperandsBiasMask = 0x00000001,
+    SpvImageOperandsLodMask = 0x00000002,
+    SpvImageOperandsGradMask = 0x00000004,
+    SpvImageOperandsConstOffsetMask = 0x00000008,
+    SpvImageOperandsOffsetMask = 0x00000010,
+    SpvImageOperandsConstOffsetsMask = 0x00000020,
+    SpvImageOperandsSampleMask = 0x00000040,
+    SpvImageOperandsMinLodMask = 0x00000080,
+} SpvImageOperandsMask;
+
+typedef enum SpvFPFastMathModeShift_ {
+    SpvFPFastMathModeNotNaNShift = 0,
+    SpvFPFastMathModeNotInfShift = 1,
+    SpvFPFastMathModeNSZShift = 2,
+    SpvFPFastMathModeAllowRecipShift = 3,
+    SpvFPFastMathModeFastShift = 4,
+    SpvFPFastMathModeMax = 0x7fffffff,
+} SpvFPFastMathModeShift;
+
+typedef enum SpvFPFastMathModeMask_ {
+    SpvFPFastMathModeMaskNone = 0,
+    SpvFPFastMathModeNotNaNMask = 0x00000001,
+    SpvFPFastMathModeNotInfMask = 0x00000002,
+    SpvFPFastMathModeNSZMask = 0x00000004,
+    SpvFPFastMathModeAllowRecipMask = 0x00000008,
+    SpvFPFastMathModeFastMask = 0x00000010,
+} SpvFPFastMathModeMask;
+
+typedef enum SpvFPRoundingMode_ {
+    SpvFPRoundingModeRTE = 0,
+    SpvFPRoundingModeRTZ = 1,
+    SpvFPRoundingModeRTP = 2,
+    SpvFPRoundingModeRTN = 3,
+    SpvFPRoundingModeMax = 0x7fffffff,
+} SpvFPRoundingMode;
+
+typedef enum SpvLinkageType_ {
+    SpvLinkageTypeExport = 0,
+    SpvLinkageTypeImport = 1,
+    SpvLinkageTypeMax = 0x7fffffff,
+} SpvLinkageType;
+
+typedef enum SpvAccessQualifier_ {
+    SpvAccessQualifierReadOnly = 0,
+    SpvAccessQualifierWriteOnly = 1,
+    SpvAccessQualifierReadWrite = 2,
+    SpvAccessQualifierMax = 0x7fffffff,
+} SpvAccessQualifier;
+
+typedef enum SpvFunctionParameterAttribute_ {
+    SpvFunctionParameterAttributeZext = 0,
+    SpvFunctionParameterAttributeSext = 1,
+    SpvFunctionParameterAttributeByVal = 2,
+    SpvFunctionParameterAttributeSret = 3,
+    SpvFunctionParameterAttributeNoAlias = 4,
+    SpvFunctionParameterAttributeNoCapture = 5,
+    SpvFunctionParameterAttributeNoWrite = 6,
+    SpvFunctionParameterAttributeNoReadWrite = 7,
+    SpvFunctionParameterAttributeMax = 0x7fffffff,
+} SpvFunctionParameterAttribute;
+
+typedef enum SpvDecoration_ {
+    SpvDecorationRelaxedPrecision = 0,
+    SpvDecorationSpecId = 1,
+    SpvDecorationBlock = 2,
+    SpvDecorationBufferBlock = 3,
+    SpvDecorationRowMajor = 4,
+    SpvDecorationColMajor = 5,
+    SpvDecorationArrayStride = 6,
+    SpvDecorationMatrixStride = 7,
+    SpvDecorationGLSLShared = 8,
+    SpvDecorationGLSLPacked = 9,
+    SpvDecorationCPacked = 10,
+    SpvDecorationBuiltIn = 11,
+    SpvDecorationNoPerspective = 13,
+    SpvDecorationFlat = 14,
+    SpvDecorationPatch = 15,
+    SpvDecorationCentroid = 16,
+    SpvDecorationSample = 17,
+    SpvDecorationInvariant = 18,
+    SpvDecorationRestrict = 19,
+    SpvDecorationAliased = 20,
+    SpvDecorationVolatile = 21,
+    SpvDecorationConstant = 22,
+    SpvDecorationCoherent = 23,
+    SpvDecorationNonWritable = 24,
+    SpvDecorationNonReadable = 25,
+    SpvDecorationUniform = 26,
+    SpvDecorationSaturatedConversion = 28,
+    SpvDecorationStream = 29,
+    SpvDecorationLocation = 30,
+    SpvDecorationComponent = 31,
+    SpvDecorationIndex = 32,
+    SpvDecorationBinding = 33,
+    SpvDecorationDescriptorSet = 34,
+    SpvDecorationOffset = 35,
+    SpvDecorationXfbBuffer = 36,
+    SpvDecorationXfbStride = 37,
+    SpvDecorationFuncParamAttr = 38,
+    SpvDecorationFPRoundingMode = 39,
+    SpvDecorationFPFastMathMode = 40,
+    SpvDecorationLinkageAttributes = 41,
+    SpvDecorationNoContraction = 42,
+    SpvDecorationInputAttachmentIndex = 43,
+    SpvDecorationAlignment = 44,
+    SpvDecorationExplicitInterpAMD = 4999,
+    SpvDecorationOverrideCoverageNV = 5248,
+    SpvDecorationPassthroughNV = 5250,
+    SpvDecorationViewportRelativeNV = 5252,
+    SpvDecorationSecondaryViewportRelativeNV = 5256,
+    SpvDecorationHlslCounterBufferGOOGLE = 5634,
+    SpvDecorationHlslSemanticGOOGLE = 5635,
+    SpvDecorationMax = 0x7fffffff,
+} SpvDecoration;
+
+typedef enum SpvBuiltIn_ {
+    SpvBuiltInPosition = 0,
+    SpvBuiltInPointSize = 1,
+    SpvBuiltInClipDistance = 3,
+    SpvBuiltInCullDistance = 4,
+    SpvBuiltInVertexId = 5,
+    SpvBuiltInInstanceId = 6,
+    SpvBuiltInPrimitiveId = 7,
+    SpvBuiltInInvocationId = 8,
+    SpvBuiltInLayer = 9,
+    SpvBuiltInViewportIndex = 10,
+    SpvBuiltInTessLevelOuter = 11,
+    SpvBuiltInTessLevelInner = 12,
+    SpvBuiltInTessCoord = 13,
+    SpvBuiltInPatchVertices = 14,
+    SpvBuiltInFragCoord = 15,
+    SpvBuiltInPointCoord = 16,
+    SpvBuiltInFrontFacing = 17,
+    SpvBuiltInSampleId = 18,
+    SpvBuiltInSamplePosition = 19,
+    SpvBuiltInSampleMask = 20,
+    SpvBuiltInFragDepth = 22,
+    SpvBuiltInHelperInvocation = 23,
+    SpvBuiltInNumWorkgroups = 24,
+    SpvBuiltInWorkgroupSize = 25,
+    SpvBuiltInWorkgroupId = 26,
+    SpvBuiltInLocalInvocationId = 27,
+    SpvBuiltInGlobalInvocationId = 28,
+    SpvBuiltInLocalInvocationIndex = 29,
+    SpvBuiltInWorkDim = 30,
+    SpvBuiltInGlobalSize = 31,
+    SpvBuiltInEnqueuedWorkgroupSize = 32,
+    SpvBuiltInGlobalOffset = 33,
+    SpvBuiltInGlobalLinearId = 34,
+    SpvBuiltInSubgroupSize = 36,
+    SpvBuiltInSubgroupMaxSize = 37,
+    SpvBuiltInNumSubgroups = 38,
+    SpvBuiltInNumEnqueuedSubgroups = 39,
+    SpvBuiltInSubgroupId = 40,
+    SpvBuiltInSubgroupLocalInvocationId = 41,
+    SpvBuiltInVertexIndex = 42,
+    SpvBuiltInInstanceIndex = 43,
+    SpvBuiltInSubgroupEqMaskKHR = 4416,
+    SpvBuiltInSubgroupGeMaskKHR = 4417,
+    SpvBuiltInSubgroupGtMaskKHR = 4418,
+    SpvBuiltInSubgroupLeMaskKHR = 4419,
+    SpvBuiltInSubgroupLtMaskKHR = 4420,
+    SpvBuiltInBaseVertex = 4424,
+    SpvBuiltInBaseInstance = 4425,
+    SpvBuiltInDrawIndex = 4426,
+    SpvBuiltInDeviceIndex = 4438,
+    SpvBuiltInViewIndex = 4440,
+    SpvBuiltInBaryCoordNoPerspAMD = 4992,
+    SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993,
+    SpvBuiltInBaryCoordNoPerspSampleAMD = 4994,
+    SpvBuiltInBaryCoordSmoothAMD = 4995,
+    SpvBuiltInBaryCoordSmoothCentroidAMD = 4996,
+    SpvBuiltInBaryCoordSmoothSampleAMD = 4997,
+    SpvBuiltInBaryCoordPullModelAMD = 4998,
+    SpvBuiltInFragStencilRefEXT = 5014,
+    SpvBuiltInViewportMaskNV = 5253,
+    SpvBuiltInSecondaryPositionNV = 5257,
+    SpvBuiltInSecondaryViewportMaskNV = 5258,
+    SpvBuiltInPositionPerViewNV = 5261,
+    SpvBuiltInViewportMaskPerViewNV = 5262,
+    SpvBuiltInMax = 0x7fffffff,
+} SpvBuiltIn;
+
+typedef enum SpvSelectionControlShift_ {
+    SpvSelectionControlFlattenShift = 0,
+    SpvSelectionControlDontFlattenShift = 1,
+    SpvSelectionControlMax = 0x7fffffff,
+} SpvSelectionControlShift;
+
+typedef enum SpvSelectionControlMask_ {
+    SpvSelectionControlMaskNone = 0,
+    SpvSelectionControlFlattenMask = 0x00000001,
+    SpvSelectionControlDontFlattenMask = 0x00000002,
+} SpvSelectionControlMask;
+
+typedef enum SpvLoopControlShift_ {
+    SpvLoopControlUnrollShift = 0,
+    SpvLoopControlDontUnrollShift = 1,
+    SpvLoopControlMax = 0x7fffffff,
+} SpvLoopControlShift;
+
+typedef enum SpvLoopControlMask_ {
+    SpvLoopControlMaskNone = 0,
+    SpvLoopControlUnrollMask = 0x00000001,
+    SpvLoopControlDontUnrollMask = 0x00000002,
+} SpvLoopControlMask;
+
+typedef enum SpvFunctionControlShift_ {
+    SpvFunctionControlInlineShift = 0,
+    SpvFunctionControlDontInlineShift = 1,
+    SpvFunctionControlPureShift = 2,
+    SpvFunctionControlConstShift = 3,
+    SpvFunctionControlMax = 0x7fffffff,
+} SpvFunctionControlShift;
+
+typedef enum SpvFunctionControlMask_ {
+    SpvFunctionControlMaskNone = 0,
+    SpvFunctionControlInlineMask = 0x00000001,
+    SpvFunctionControlDontInlineMask = 0x00000002,
+    SpvFunctionControlPureMask = 0x00000004,
+    SpvFunctionControlConstMask = 0x00000008,
+} SpvFunctionControlMask;
+
+typedef enum SpvMemorySemanticsShift_ {
+    SpvMemorySemanticsAcquireShift = 1,
+    SpvMemorySemanticsReleaseShift = 2,
+    SpvMemorySemanticsAcquireReleaseShift = 3,
+    SpvMemorySemanticsSequentiallyConsistentShift = 4,
+    SpvMemorySemanticsUniformMemoryShift = 6,
+    SpvMemorySemanticsSubgroupMemoryShift = 7,
+    SpvMemorySemanticsWorkgroupMemoryShift = 8,
+    SpvMemorySemanticsCrossWorkgroupMemoryShift = 9,
+    SpvMemorySemanticsAtomicCounterMemoryShift = 10,
+    SpvMemorySemanticsImageMemoryShift = 11,
+    SpvMemorySemanticsMax = 0x7fffffff,
+} SpvMemorySemanticsShift;
+
+typedef enum SpvMemorySemanticsMask_ {
+    SpvMemorySemanticsMaskNone = 0,
+    SpvMemorySemanticsAcquireMask = 0x00000002,
+    SpvMemorySemanticsReleaseMask = 0x00000004,
+    SpvMemorySemanticsAcquireReleaseMask = 0x00000008,
+    SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010,
+    SpvMemorySemanticsUniformMemoryMask = 0x00000040,
+    SpvMemorySemanticsSubgroupMemoryMask = 0x00000080,
+    SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100,
+    SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
+    SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400,
+    SpvMemorySemanticsImageMemoryMask = 0x00000800,
+} SpvMemorySemanticsMask;
+
+typedef enum SpvMemoryAccessShift_ {
+    SpvMemoryAccessVolatileShift = 0,
+    SpvMemoryAccessAlignedShift = 1,
+    SpvMemoryAccessNontemporalShift = 2,
+    SpvMemoryAccessMax = 0x7fffffff,
+} SpvMemoryAccessShift;
+
+typedef enum SpvMemoryAccessMask_ {
+    SpvMemoryAccessMaskNone = 0,
+    SpvMemoryAccessVolatileMask = 0x00000001,
+    SpvMemoryAccessAlignedMask = 0x00000002,
+    SpvMemoryAccessNontemporalMask = 0x00000004,
+} SpvMemoryAccessMask;
+
+typedef enum SpvScope_ {
+    SpvScopeCrossDevice = 0,
+    SpvScopeDevice = 1,
+    SpvScopeWorkgroup = 2,
+    SpvScopeSubgroup = 3,
+    SpvScopeInvocation = 4,
+    SpvScopeMax = 0x7fffffff,
+} SpvScope;
+
+typedef enum SpvGroupOperation_ {
+    SpvGroupOperationReduce = 0,
+    SpvGroupOperationInclusiveScan = 1,
+    SpvGroupOperationExclusiveScan = 2,
+    SpvGroupOperationMax = 0x7fffffff,
+} SpvGroupOperation;
+
+typedef enum SpvKernelEnqueueFlags_ {
+    SpvKernelEnqueueFlagsNoWait = 0,
+    SpvKernelEnqueueFlagsWaitKernel = 1,
+    SpvKernelEnqueueFlagsWaitWorkGroup = 2,
+    SpvKernelEnqueueFlagsMax = 0x7fffffff,
+} SpvKernelEnqueueFlags;
+
+typedef enum SpvKernelProfilingInfoShift_ {
+    SpvKernelProfilingInfoCmdExecTimeShift = 0,
+    SpvKernelProfilingInfoMax = 0x7fffffff,
+} SpvKernelProfilingInfoShift;
+
+typedef enum SpvKernelProfilingInfoMask_ {
+    SpvKernelProfilingInfoMaskNone = 0,
+    SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001,
+} SpvKernelProfilingInfoMask;
+
+typedef enum SpvCapability_ {
+    SpvCapabilityMatrix = 0,
+    SpvCapabilityShader = 1,
+    SpvCapabilityGeometry = 2,
+    SpvCapabilityTessellation = 3,
+    SpvCapabilityAddresses = 4,
+    SpvCapabilityLinkage = 5,
+    SpvCapabilityKernel = 6,
+    SpvCapabilityVector16 = 7,
+    SpvCapabilityFloat16Buffer = 8,
+    SpvCapabilityFloat16 = 9,
+    SpvCapabilityFloat64 = 10,
+    SpvCapabilityInt64 = 11,
+    SpvCapabilityInt64Atomics = 12,
+    SpvCapabilityImageBasic = 13,
+    SpvCapabilityImageReadWrite = 14,
+    SpvCapabilityImageMipmap = 15,
+    SpvCapabilityPipes = 17,
+    SpvCapabilityGroups = 18,
+    SpvCapabilityDeviceEnqueue = 19,
+    SpvCapabilityLiteralSampler = 20,
+    SpvCapabilityAtomicStorage = 21,
+    SpvCapabilityInt16 = 22,
+    SpvCapabilityTessellationPointSize = 23,
+    SpvCapabilityGeometryPointSize = 24,
+    SpvCapabilityImageGatherExtended = 25,
+    SpvCapabilityStorageImageMultisample = 27,
+    SpvCapabilityUniformBufferArrayDynamicIndexing = 28,
+    SpvCapabilitySampledImageArrayDynamicIndexing = 29,
+    SpvCapabilityStorageBufferArrayDynamicIndexing = 30,
+    SpvCapabilityStorageImageArrayDynamicIndexing = 31,
+    SpvCapabilityClipDistance = 32,
+    SpvCapabilityCullDistance = 33,
+    SpvCapabilityImageCubeArray = 34,
+    SpvCapabilitySampleRateShading = 35,
+    SpvCapabilityImageRect = 36,
+    SpvCapabilitySampledRect = 37,
+    SpvCapabilityGenericPointer = 38,
+    SpvCapabilityInt8 = 39,
+    SpvCapabilityInputAttachment = 40,
+    SpvCapabilitySparseResidency = 41,
+    SpvCapabilityMinLod = 42,
+    SpvCapabilitySampled1D = 43,
+    SpvCapabilityImage1D = 44,
+    SpvCapabilitySampledCubeArray = 45,
+    SpvCapabilitySampledBuffer = 46,
+    SpvCapabilityImageBuffer = 47,
+    SpvCapabilityImageMSArray = 48,
+    SpvCapabilityStorageImageExtendedFormats = 49,
+    SpvCapabilityImageQuery = 50,
+    SpvCapabilityDerivativeControl = 51,
+    SpvCapabilityInterpolationFunction = 52,
+    SpvCapabilityTransformFeedback = 53,
+    SpvCapabilityGeometryStreams = 54,
+    SpvCapabilityStorageImageReadWithoutFormat = 55,
+    SpvCapabilityStorageImageWriteWithoutFormat = 56,
+    SpvCapabilityMultiViewport = 57,
+    SpvCapabilitySubgroupBallotKHR = 4423,
+    SpvCapabilityDrawParameters = 4427,
+    SpvCapabilitySubgroupVoteKHR = 4431,
+    SpvCapabilityStorageBuffer16BitAccess = 4433,
+    SpvCapabilityStorageUniformBufferBlock16 = 4433,
+    SpvCapabilityStorageUniform16 = 4434,
+    SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434,
+    SpvCapabilityStoragePushConstant16 = 4435,
+    SpvCapabilityStorageInputOutput16 = 4436,
+    SpvCapabilityDeviceGroup = 4437,
+    SpvCapabilityMultiView = 4439,
+    SpvCapabilityVariablePointersStorageBuffer = 4441,
+    SpvCapabilityVariablePointers = 4442,
+    SpvCapabilityAtomicStorageOps = 4445,
+    SpvCapabilitySampleMaskPostDepthCoverage = 4447,
+    SpvCapabilityImageGatherBiasLodAMD = 5009,
+    SpvCapabilityFragmentMaskAMD = 5010,
+    SpvCapabilityStencilExportEXT = 5013,
+    SpvCapabilityImageReadWriteLodAMD = 5015,
+    SpvCapabilitySampleMaskOverrideCoverageNV = 5249,
+    SpvCapabilityGeometryShaderPassthroughNV = 5251,
+    SpvCapabilityShaderViewportIndexLayerEXT = 5254,
+    SpvCapabilityShaderViewportIndexLayerNV = 5254,
+    SpvCapabilityShaderViewportMaskNV = 5255,
+    SpvCapabilityShaderStereoViewNV = 5259,
+    SpvCapabilityPerViewAttributesNV = 5260,
+    SpvCapabilitySubgroupShuffleINTEL = 5568,
+    SpvCapabilitySubgroupBufferBlockIOINTEL = 5569,
+    SpvCapabilitySubgroupImageBlockIOINTEL = 5570,
+    SpvCapabilityMax = 0x7fffffff,
+} SpvCapability;
+
+typedef enum SpvOp_ {
+    SpvOpNop = 0,
+    SpvOpUndef = 1,
+    SpvOpSourceContinued = 2,
+    SpvOpSource = 3,
+    SpvOpSourceExtension = 4,
+    SpvOpName = 5,
+    SpvOpMemberName = 6,
+    SpvOpString = 7,
+    SpvOpLine = 8,
+    SpvOpExtension = 10,
+    SpvOpExtInstImport = 11,
+    SpvOpExtInst = 12,
+    SpvOpMemoryModel = 14,
+    SpvOpEntryPoint = 15,
+    SpvOpExecutionMode = 16,
+    SpvOpCapability = 17,
+    SpvOpTypeVoid = 19,
+    SpvOpTypeBool = 20,
+    SpvOpTypeInt = 21,
+    SpvOpTypeFloat = 22,
+    SpvOpTypeVector = 23,
+    SpvOpTypeMatrix = 24,
+    SpvOpTypeImage = 25,
+    SpvOpTypeSampler = 26,
+    SpvOpTypeSampledImage = 27,
+    SpvOpTypeArray = 28,
+    SpvOpTypeRuntimeArray = 29,
+    SpvOpTypeStruct = 30,
+    SpvOpTypeOpaque = 31,
+    SpvOpTypePointer = 32,
+    SpvOpTypeFunction = 33,
+    SpvOpTypeEvent = 34,
+    SpvOpTypeDeviceEvent = 35,
+    SpvOpTypeReserveId = 36,
+    SpvOpTypeQueue = 37,
+    SpvOpTypePipe = 38,
+    SpvOpTypeForwardPointer = 39,
+    SpvOpConstantTrue = 41,
+    SpvOpConstantFalse = 42,
+    SpvOpConstant = 43,
+    SpvOpConstantComposite = 44,
+    SpvOpConstantSampler = 45,
+    SpvOpConstantNull = 46,
+    SpvOpSpecConstantTrue = 48,
+    SpvOpSpecConstantFalse = 49,
+    SpvOpSpecConstant = 50,
+    SpvOpSpecConstantComposite = 51,
+    SpvOpSpecConstantOp = 52,
+    SpvOpFunction = 54,
+    SpvOpFunctionParameter = 55,
+    SpvOpFunctionEnd = 56,
+    SpvOpFunctionCall = 57,
+    SpvOpVariable = 59,
+    SpvOpImageTexelPointer = 60,
+    SpvOpLoad = 61,
+    SpvOpStore = 62,
+    SpvOpCopyMemory = 63,
+    SpvOpCopyMemorySized = 64,
+    SpvOpAccessChain = 65,
+    SpvOpInBoundsAccessChain = 66,
+    SpvOpPtrAccessChain = 67,
+    SpvOpArrayLength = 68,
+    SpvOpGenericPtrMemSemantics = 69,
+    SpvOpInBoundsPtrAccessChain = 70,
+    SpvOpDecorate = 71,
+    SpvOpMemberDecorate = 72,
+    SpvOpDecorationGroup = 73,
+    SpvOpGroupDecorate = 74,
+    SpvOpGroupMemberDecorate = 75,
+    SpvOpVectorExtractDynamic = 77,
+    SpvOpVectorInsertDynamic = 78,
+    SpvOpVectorShuffle = 79,
+    SpvOpCompositeConstruct = 80,
+    SpvOpCompositeExtract = 81,
+    SpvOpCompositeInsert = 82,
+    SpvOpCopyObject = 83,
+    SpvOpTranspose = 84,
+    SpvOpSampledImage = 86,
+    SpvOpImageSampleImplicitLod = 87,
+    SpvOpImageSampleExplicitLod = 88,
+    SpvOpImageSampleDrefImplicitLod = 89,
+    SpvOpImageSampleDrefExplicitLod = 90,
+    SpvOpImageSampleProjImplicitLod = 91,
+    SpvOpImageSampleProjExplicitLod = 92,
+    SpvOpImageSampleProjDrefImplicitLod = 93,
+    SpvOpImageSampleProjDrefExplicitLod = 94,
+    SpvOpImageFetch = 95,
+    SpvOpImageGather = 96,
+    SpvOpImageDrefGather = 97,
+    SpvOpImageRead = 98,
+    SpvOpImageWrite = 99,
+    SpvOpImage = 100,
+    SpvOpImageQueryFormat = 101,
+    SpvOpImageQueryOrder = 102,
+    SpvOpImageQuerySizeLod = 103,
+    SpvOpImageQuerySize = 104,
+    SpvOpImageQueryLod = 105,
+    SpvOpImageQueryLevels = 106,
+    SpvOpImageQuerySamples = 107,
+    SpvOpConvertFToU = 109,
+    SpvOpConvertFToS = 110,
+    SpvOpConvertSToF = 111,
+    SpvOpConvertUToF = 112,
+    SpvOpUConvert = 113,
+    SpvOpSConvert = 114,
+    SpvOpFConvert = 115,
+    SpvOpQuantizeToF16 = 116,
+    SpvOpConvertPtrToU = 117,
+    SpvOpSatConvertSToU = 118,
+    SpvOpSatConvertUToS = 119,
+    SpvOpConvertUToPtr = 120,
+    SpvOpPtrCastToGeneric = 121,
+    SpvOpGenericCastToPtr = 122,
+    SpvOpGenericCastToPtrExplicit = 123,
+    SpvOpBitcast = 124,
+    SpvOpSNegate = 126,
+    SpvOpFNegate = 127,
+    SpvOpIAdd = 128,
+    SpvOpFAdd = 129,
+    SpvOpISub = 130,
+    SpvOpFSub = 131,
+    SpvOpIMul = 132,
+    SpvOpFMul = 133,
+    SpvOpUDiv = 134,
+    SpvOpSDiv = 135,
+    SpvOpFDiv = 136,
+    SpvOpUMod = 137,
+    SpvOpSRem = 138,
+    SpvOpSMod = 139,
+    SpvOpFRem = 140,
+    SpvOpFMod = 141,
+    SpvOpVectorTimesScalar = 142,
+    SpvOpMatrixTimesScalar = 143,
+    SpvOpVectorTimesMatrix = 144,
+    SpvOpMatrixTimesVector = 145,
+    SpvOpMatrixTimesMatrix = 146,
+    SpvOpOuterProduct = 147,
+    SpvOpDot = 148,
+    SpvOpIAddCarry = 149,
+    SpvOpISubBorrow = 150,
+    SpvOpUMulExtended = 151,
+    SpvOpSMulExtended = 152,
+    SpvOpAny = 154,
+    SpvOpAll = 155,
+    SpvOpIsNan = 156,
+    SpvOpIsInf = 157,
+    SpvOpIsFinite = 158,
+    SpvOpIsNormal = 159,
+    SpvOpSignBitSet = 160,
+    SpvOpLessOrGreater = 161,
+    SpvOpOrdered = 162,
+    SpvOpUnordered = 163,
+    SpvOpLogicalEqual = 164,
+    SpvOpLogicalNotEqual = 165,
+    SpvOpLogicalOr = 166,
+    SpvOpLogicalAnd = 167,
+    SpvOpLogicalNot = 168,
+    SpvOpSelect = 169,
+    SpvOpIEqual = 170,
+    SpvOpINotEqual = 171,
+    SpvOpUGreaterThan = 172,
+    SpvOpSGreaterThan = 173,
+    SpvOpUGreaterThanEqual = 174,
+    SpvOpSGreaterThanEqual = 175,
+    SpvOpULessThan = 176,
+    SpvOpSLessThan = 177,
+    SpvOpULessThanEqual = 178,
+    SpvOpSLessThanEqual = 179,
+    SpvOpFOrdEqual = 180,
+    SpvOpFUnordEqual = 181,
+    SpvOpFOrdNotEqual = 182,
+    SpvOpFUnordNotEqual = 183,
+    SpvOpFOrdLessThan = 184,
+    SpvOpFUnordLessThan = 185,
+    SpvOpFOrdGreaterThan = 186,
+    SpvOpFUnordGreaterThan = 187,
+    SpvOpFOrdLessThanEqual = 188,
+    SpvOpFUnordLessThanEqual = 189,
+    SpvOpFOrdGreaterThanEqual = 190,
+    SpvOpFUnordGreaterThanEqual = 191,
+    SpvOpShiftRightLogical = 194,
+    SpvOpShiftRightArithmetic = 195,
+    SpvOpShiftLeftLogical = 196,
+    SpvOpBitwiseOr = 197,
+    SpvOpBitwiseXor = 198,
+    SpvOpBitwiseAnd = 199,
+    SpvOpNot = 200,
+    SpvOpBitFieldInsert = 201,
+    SpvOpBitFieldSExtract = 202,
+    SpvOpBitFieldUExtract = 203,
+    SpvOpBitReverse = 204,
+    SpvOpBitCount = 205,
+    SpvOpDPdx = 207,
+    SpvOpDPdy = 208,
+    SpvOpFwidth = 209,
+    SpvOpDPdxFine = 210,
+    SpvOpDPdyFine = 211,
+    SpvOpFwidthFine = 212,
+    SpvOpDPdxCoarse = 213,
+    SpvOpDPdyCoarse = 214,
+    SpvOpFwidthCoarse = 215,
+    SpvOpEmitVertex = 218,
+    SpvOpEndPrimitive = 219,
+    SpvOpEmitStreamVertex = 220,
+    SpvOpEndStreamPrimitive = 221,
+    SpvOpControlBarrier = 224,
+    SpvOpMemoryBarrier = 225,
+    SpvOpAtomicLoad = 227,
+    SpvOpAtomicStore = 228,
+    SpvOpAtomicExchange = 229,
+    SpvOpAtomicCompareExchange = 230,
+    SpvOpAtomicCompareExchangeWeak = 231,
+    SpvOpAtomicIIncrement = 232,
+    SpvOpAtomicIDecrement = 233,
+    SpvOpAtomicIAdd = 234,
+    SpvOpAtomicISub = 235,
+    SpvOpAtomicSMin = 236,
+    SpvOpAtomicUMin = 237,
+    SpvOpAtomicSMax = 238,
+    SpvOpAtomicUMax = 239,
+    SpvOpAtomicAnd = 240,
+    SpvOpAtomicOr = 241,
+    SpvOpAtomicXor = 242,
+    SpvOpPhi = 245,
+    SpvOpLoopMerge = 246,
+    SpvOpSelectionMerge = 247,
+    SpvOpLabel = 248,
+    SpvOpBranch = 249,
+    SpvOpBranchConditional = 250,
+    SpvOpSwitch = 251,
+    SpvOpKill = 252,
+    SpvOpReturn = 253,
+    SpvOpReturnValue = 254,
+    SpvOpUnreachable = 255,
+    SpvOpLifetimeStart = 256,
+    SpvOpLifetimeStop = 257,
+    SpvOpGroupAsyncCopy = 259,
+    SpvOpGroupWaitEvents = 260,
+    SpvOpGroupAll = 261,
+    SpvOpGroupAny = 262,
+    SpvOpGroupBroadcast = 263,
+    SpvOpGroupIAdd = 264,
+    SpvOpGroupFAdd = 265,
+    SpvOpGroupFMin = 266,
+    SpvOpGroupUMin = 267,
+    SpvOpGroupSMin = 268,
+    SpvOpGroupFMax = 269,
+    SpvOpGroupUMax = 270,
+    SpvOpGroupSMax = 271,
+    SpvOpReadPipe = 274,
+    SpvOpWritePipe = 275,
+    SpvOpReservedReadPipe = 276,
+    SpvOpReservedWritePipe = 277,
+    SpvOpReserveReadPipePackets = 278,
+    SpvOpReserveWritePipePackets = 279,
+    SpvOpCommitReadPipe = 280,
+    SpvOpCommitWritePipe = 281,
+    SpvOpIsValidReserveId = 282,
+    SpvOpGetNumPipePackets = 283,
+    SpvOpGetMaxPipePackets = 284,
+    SpvOpGroupReserveReadPipePackets = 285,
+    SpvOpGroupReserveWritePipePackets = 286,
+    SpvOpGroupCommitReadPipe = 287,
+    SpvOpGroupCommitWritePipe = 288,
+    SpvOpEnqueueMarker = 291,
+    SpvOpEnqueueKernel = 292,
+    SpvOpGetKernelNDrangeSubGroupCount = 293,
+    SpvOpGetKernelNDrangeMaxSubGroupSize = 294,
+    SpvOpGetKernelWorkGroupSize = 295,
+    SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296,
+    SpvOpRetainEvent = 297,
+    SpvOpReleaseEvent = 298,
+    SpvOpCreateUserEvent = 299,
+    SpvOpIsValidEvent = 300,
+    SpvOpSetUserEventStatus = 301,
+    SpvOpCaptureEventProfilingInfo = 302,
+    SpvOpGetDefaultQueue = 303,
+    SpvOpBuildNDRange = 304,
+    SpvOpImageSparseSampleImplicitLod = 305,
+    SpvOpImageSparseSampleExplicitLod = 306,
+    SpvOpImageSparseSampleDrefImplicitLod = 307,
+    SpvOpImageSparseSampleDrefExplicitLod = 308,
+    SpvOpImageSparseSampleProjImplicitLod = 309,
+    SpvOpImageSparseSampleProjExplicitLod = 310,
+    SpvOpImageSparseSampleProjDrefImplicitLod = 311,
+    SpvOpImageSparseSampleProjDrefExplicitLod = 312,
+    SpvOpImageSparseFetch = 313,
+    SpvOpImageSparseGather = 314,
+    SpvOpImageSparseDrefGather = 315,
+    SpvOpImageSparseTexelsResident = 316,
+    SpvOpNoLine = 317,
+    SpvOpAtomicFlagTestAndSet = 318,
+    SpvOpAtomicFlagClear = 319,
+    SpvOpImageSparseRead = 320,
+    SpvOpDecorateId = 332,
+    SpvOpSubgroupBallotKHR = 4421,
+    SpvOpSubgroupFirstInvocationKHR = 4422,
+    SpvOpSubgroupAllKHR = 4428,
+    SpvOpSubgroupAnyKHR = 4429,
+    SpvOpSubgroupAllEqualKHR = 4430,
+    SpvOpSubgroupReadInvocationKHR = 4432,
+    SpvOpGroupIAddNonUniformAMD = 5000,
+    SpvOpGroupFAddNonUniformAMD = 5001,
+    SpvOpGroupFMinNonUniformAMD = 5002,
+    SpvOpGroupUMinNonUniformAMD = 5003,
+    SpvOpGroupSMinNonUniformAMD = 5004,
+    SpvOpGroupFMaxNonUniformAMD = 5005,
+    SpvOpGroupUMaxNonUniformAMD = 5006,
+    SpvOpGroupSMaxNonUniformAMD = 5007,
+    SpvOpFragmentMaskFetchAMD = 5011,
+    SpvOpFragmentFetchAMD = 5012,
+    SpvOpSubgroupShuffleINTEL = 5571,
+    SpvOpSubgroupShuffleDownINTEL = 5572,
+    SpvOpSubgroupShuffleUpINTEL = 5573,
+    SpvOpSubgroupShuffleXorINTEL = 5574,
+    SpvOpSubgroupBlockReadINTEL = 5575,
+    SpvOpSubgroupBlockWriteINTEL = 5576,
+    SpvOpSubgroupImageBlockReadINTEL = 5577,
+    SpvOpSubgroupImageBlockWriteINTEL = 5578,
+    SpvOpDecorateStringGOOGLE = 5632,
+    SpvOpMemberDecorateStringGOOGLE = 5633,
+    SpvOpMax = 0x7fffffff,
+} SpvOp;
+
+#endif  // #ifndef spirv_H
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/spirv.lua

@@ -0,0 +1,949 @@
+-- Copyright (c) 2014-2018 The Khronos Group Inc.
+-- 
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and/or associated documentation files (the "Materials"),
+-- to deal in the Materials without restriction, including without limitation
+-- the rights to use, copy, modify, merge, publish, distribute, sublicense,
+-- and/or sell copies of the Materials, and to permit persons to whom the
+-- Materials are furnished to do so, subject to the following conditions:
+-- 
+-- The above copyright notice and this permission notice shall be included in
+-- all copies or substantial portions of the Materials.
+-- 
+-- MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+-- STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+-- HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+-- 
+-- THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+-- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+-- THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-- FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+-- IN THE MATERIALS.
+
+-- This header is automatically generated by the same tool that creates
+-- the Binary Section of the SPIR-V specification.
+
+-- Enumeration tokens for SPIR-V, in various styles:
+--   C, C++, C++11, JSON, Lua, Python
+-- 
+-- - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+-- - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+-- - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+-- - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+-- - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+-- 
+-- Some tokens act like mask values, which can be OR'd together,
+-- while others are mutually exclusive.  The mask-like ones have
+-- "Mask" in their name, and a parallel enum that has the shift
+-- amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    MagicNumber = 0x07230203,
+    Version = 0x00010000,
+    Revision = 12,
+    OpCodeMask = 0xffff,
+    WordCountShift = 16,
+
+    SourceLanguage = {
+        Unknown = 0,
+        ESSL = 1,
+        GLSL = 2,
+        OpenCL_C = 3,
+        OpenCL_CPP = 4,
+        HLSL = 5,
+    },
+
+    ExecutionModel = {
+        Vertex = 0,
+        TessellationControl = 1,
+        TessellationEvaluation = 2,
+        Geometry = 3,
+        Fragment = 4,
+        GLCompute = 5,
+        Kernel = 6,
+    },
+
+    AddressingModel = {
+        Logical = 0,
+        Physical32 = 1,
+        Physical64 = 2,
+    },
+
+    MemoryModel = {
+        Simple = 0,
+        GLSL450 = 1,
+        OpenCL = 2,
+    },
+
+    ExecutionMode = {
+        Invocations = 0,
+        SpacingEqual = 1,
+        SpacingFractionalEven = 2,
+        SpacingFractionalOdd = 3,
+        VertexOrderCw = 4,
+        VertexOrderCcw = 5,
+        PixelCenterInteger = 6,
+        OriginUpperLeft = 7,
+        OriginLowerLeft = 8,
+        EarlyFragmentTests = 9,
+        PointMode = 10,
+        Xfb = 11,
+        DepthReplacing = 12,
+        DepthGreater = 14,
+        DepthLess = 15,
+        DepthUnchanged = 16,
+        LocalSize = 17,
+        LocalSizeHint = 18,
+        InputPoints = 19,
+        InputLines = 20,
+        InputLinesAdjacency = 21,
+        Triangles = 22,
+        InputTrianglesAdjacency = 23,
+        Quads = 24,
+        Isolines = 25,
+        OutputVertices = 26,
+        OutputPoints = 27,
+        OutputLineStrip = 28,
+        OutputTriangleStrip = 29,
+        VecTypeHint = 30,
+        ContractionOff = 31,
+        PostDepthCoverage = 4446,
+        StencilRefReplacingEXT = 5027,
+    },
+
+    StorageClass = {
+        UniformConstant = 0,
+        Input = 1,
+        Uniform = 2,
+        Output = 3,
+        Workgroup = 4,
+        CrossWorkgroup = 5,
+        Private = 6,
+        Function = 7,
+        Generic = 8,
+        PushConstant = 9,
+        AtomicCounter = 10,
+        Image = 11,
+        StorageBuffer = 12,
+    },
+
+    Dim = {
+        Dim1D = 0,
+        Dim2D = 1,
+        Dim3D = 2,
+        Cube = 3,
+        Rect = 4,
+        Buffer = 5,
+        SubpassData = 6,
+    },
+
+    SamplerAddressingMode = {
+        None = 0,
+        ClampToEdge = 1,
+        Clamp = 2,
+        Repeat = 3,
+        RepeatMirrored = 4,
+    },
+
+    SamplerFilterMode = {
+        Nearest = 0,
+        Linear = 1,
+    },
+
+    ImageFormat = {
+        Unknown = 0,
+        Rgba32f = 1,
+        Rgba16f = 2,
+        R32f = 3,
+        Rgba8 = 4,
+        Rgba8Snorm = 5,
+        Rg32f = 6,
+        Rg16f = 7,
+        R11fG11fB10f = 8,
+        R16f = 9,
+        Rgba16 = 10,
+        Rgb10A2 = 11,
+        Rg16 = 12,
+        Rg8 = 13,
+        R16 = 14,
+        R8 = 15,
+        Rgba16Snorm = 16,
+        Rg16Snorm = 17,
+        Rg8Snorm = 18,
+        R16Snorm = 19,
+        R8Snorm = 20,
+        Rgba32i = 21,
+        Rgba16i = 22,
+        Rgba8i = 23,
+        R32i = 24,
+        Rg32i = 25,
+        Rg16i = 26,
+        Rg8i = 27,
+        R16i = 28,
+        R8i = 29,
+        Rgba32ui = 30,
+        Rgba16ui = 31,
+        Rgba8ui = 32,
+        R32ui = 33,
+        Rgb10a2ui = 34,
+        Rg32ui = 35,
+        Rg16ui = 36,
+        Rg8ui = 37,
+        R16ui = 38,
+        R8ui = 39,
+    },
+
+    ImageChannelOrder = {
+        R = 0,
+        A = 1,
+        RG = 2,
+        RA = 3,
+        RGB = 4,
+        RGBA = 5,
+        BGRA = 6,
+        ARGB = 7,
+        Intensity = 8,
+        Luminance = 9,
+        Rx = 10,
+        RGx = 11,
+        RGBx = 12,
+        Depth = 13,
+        DepthStencil = 14,
+        sRGB = 15,
+        sRGBx = 16,
+        sRGBA = 17,
+        sBGRA = 18,
+        ABGR = 19,
+    },
+
+    ImageChannelDataType = {
+        SnormInt8 = 0,
+        SnormInt16 = 1,
+        UnormInt8 = 2,
+        UnormInt16 = 3,
+        UnormShort565 = 4,
+        UnormShort555 = 5,
+        UnormInt101010 = 6,
+        SignedInt8 = 7,
+        SignedInt16 = 8,
+        SignedInt32 = 9,
+        UnsignedInt8 = 10,
+        UnsignedInt16 = 11,
+        UnsignedInt32 = 12,
+        HalfFloat = 13,
+        Float = 14,
+        UnormInt24 = 15,
+        UnormInt101010_2 = 16,
+    },
+
+    ImageOperandsShift = {
+        Bias = 0,
+        Lod = 1,
+        Grad = 2,
+        ConstOffset = 3,
+        Offset = 4,
+        ConstOffsets = 5,
+        Sample = 6,
+        MinLod = 7,
+    },
+
+    ImageOperandsMask = {
+        MaskNone = 0,
+        Bias = 0x00000001,
+        Lod = 0x00000002,
+        Grad = 0x00000004,
+        ConstOffset = 0x00000008,
+        Offset = 0x00000010,
+        ConstOffsets = 0x00000020,
+        Sample = 0x00000040,
+        MinLod = 0x00000080,
+    },
+
+    FPFastMathModeShift = {
+        NotNaN = 0,
+        NotInf = 1,
+        NSZ = 2,
+        AllowRecip = 3,
+        Fast = 4,
+    },
+
+    FPFastMathModeMask = {
+        MaskNone = 0,
+        NotNaN = 0x00000001,
+        NotInf = 0x00000002,
+        NSZ = 0x00000004,
+        AllowRecip = 0x00000008,
+        Fast = 0x00000010,
+    },
+
+    FPRoundingMode = {
+        RTE = 0,
+        RTZ = 1,
+        RTP = 2,
+        RTN = 3,
+    },
+
+    LinkageType = {
+        Export = 0,
+        Import = 1,
+    },
+
+    AccessQualifier = {
+        ReadOnly = 0,
+        WriteOnly = 1,
+        ReadWrite = 2,
+    },
+
+    FunctionParameterAttribute = {
+        Zext = 0,
+        Sext = 1,
+        ByVal = 2,
+        Sret = 3,
+        NoAlias = 4,
+        NoCapture = 5,
+        NoWrite = 6,
+        NoReadWrite = 7,
+    },
+
+    Decoration = {
+        RelaxedPrecision = 0,
+        SpecId = 1,
+        Block = 2,
+        BufferBlock = 3,
+        RowMajor = 4,
+        ColMajor = 5,
+        ArrayStride = 6,
+        MatrixStride = 7,
+        GLSLShared = 8,
+        GLSLPacked = 9,
+        CPacked = 10,
+        BuiltIn = 11,
+        NoPerspective = 13,
+        Flat = 14,
+        Patch = 15,
+        Centroid = 16,
+        Sample = 17,
+        Invariant = 18,
+        Restrict = 19,
+        Aliased = 20,
+        Volatile = 21,
+        Constant = 22,
+        Coherent = 23,
+        NonWritable = 24,
+        NonReadable = 25,
+        Uniform = 26,
+        SaturatedConversion = 28,
+        Stream = 29,
+        Location = 30,
+        Component = 31,
+        Index = 32,
+        Binding = 33,
+        DescriptorSet = 34,
+        Offset = 35,
+        XfbBuffer = 36,
+        XfbStride = 37,
+        FuncParamAttr = 38,
+        FPRoundingMode = 39,
+        FPFastMathMode = 40,
+        LinkageAttributes = 41,
+        NoContraction = 42,
+        InputAttachmentIndex = 43,
+        Alignment = 44,
+        ExplicitInterpAMD = 4999,
+        OverrideCoverageNV = 5248,
+        PassthroughNV = 5250,
+        ViewportRelativeNV = 5252,
+        SecondaryViewportRelativeNV = 5256,
+        HlslCounterBufferGOOGLE = 5634,
+        HlslSemanticGOOGLE = 5635,
+    },
+
+    BuiltIn = {
+        Position = 0,
+        PointSize = 1,
+        ClipDistance = 3,
+        CullDistance = 4,
+        VertexId = 5,
+        InstanceId = 6,
+        PrimitiveId = 7,
+        InvocationId = 8,
+        Layer = 9,
+        ViewportIndex = 10,
+        TessLevelOuter = 11,
+        TessLevelInner = 12,
+        TessCoord = 13,
+        PatchVertices = 14,
+        FragCoord = 15,
+        PointCoord = 16,
+        FrontFacing = 17,
+        SampleId = 18,
+        SamplePosition = 19,
+        SampleMask = 20,
+        FragDepth = 22,
+        HelperInvocation = 23,
+        NumWorkgroups = 24,
+        WorkgroupSize = 25,
+        WorkgroupId = 26,
+        LocalInvocationId = 27,
+        GlobalInvocationId = 28,
+        LocalInvocationIndex = 29,
+        WorkDim = 30,
+        GlobalSize = 31,
+        EnqueuedWorkgroupSize = 32,
+        GlobalOffset = 33,
+        GlobalLinearId = 34,
+        SubgroupSize = 36,
+        SubgroupMaxSize = 37,
+        NumSubgroups = 38,
+        NumEnqueuedSubgroups = 39,
+        SubgroupId = 40,
+        SubgroupLocalInvocationId = 41,
+        VertexIndex = 42,
+        InstanceIndex = 43,
+        SubgroupEqMaskKHR = 4416,
+        SubgroupGeMaskKHR = 4417,
+        SubgroupGtMaskKHR = 4418,
+        SubgroupLeMaskKHR = 4419,
+        SubgroupLtMaskKHR = 4420,
+        BaseVertex = 4424,
+        BaseInstance = 4425,
+        DrawIndex = 4426,
+        DeviceIndex = 4438,
+        ViewIndex = 4440,
+        BaryCoordNoPerspAMD = 4992,
+        BaryCoordNoPerspCentroidAMD = 4993,
+        BaryCoordNoPerspSampleAMD = 4994,
+        BaryCoordSmoothAMD = 4995,
+        BaryCoordSmoothCentroidAMD = 4996,
+        BaryCoordSmoothSampleAMD = 4997,
+        BaryCoordPullModelAMD = 4998,
+        FragStencilRefEXT = 5014,
+        ViewportMaskNV = 5253,
+        SecondaryPositionNV = 5257,
+        SecondaryViewportMaskNV = 5258,
+        PositionPerViewNV = 5261,
+        ViewportMaskPerViewNV = 5262,
+    },
+
+    SelectionControlShift = {
+        Flatten = 0,
+        DontFlatten = 1,
+    },
+
+    SelectionControlMask = {
+        MaskNone = 0,
+        Flatten = 0x00000001,
+        DontFlatten = 0x00000002,
+    },
+
+    LoopControlShift = {
+        Unroll = 0,
+        DontUnroll = 1,
+    },
+
+    LoopControlMask = {
+        MaskNone = 0,
+        Unroll = 0x00000001,
+        DontUnroll = 0x00000002,
+    },
+
+    FunctionControlShift = {
+        Inline = 0,
+        DontInline = 1,
+        Pure = 2,
+        Const = 3,
+    },
+
+    FunctionControlMask = {
+        MaskNone = 0,
+        Inline = 0x00000001,
+        DontInline = 0x00000002,
+        Pure = 0x00000004,
+        Const = 0x00000008,
+    },
+
+    MemorySemanticsShift = {
+        Acquire = 1,
+        Release = 2,
+        AcquireRelease = 3,
+        SequentiallyConsistent = 4,
+        UniformMemory = 6,
+        SubgroupMemory = 7,
+        WorkgroupMemory = 8,
+        CrossWorkgroupMemory = 9,
+        AtomicCounterMemory = 10,
+        ImageMemory = 11,
+    },
+
+    MemorySemanticsMask = {
+        MaskNone = 0,
+        Acquire = 0x00000002,
+        Release = 0x00000004,
+        AcquireRelease = 0x00000008,
+        SequentiallyConsistent = 0x00000010,
+        UniformMemory = 0x00000040,
+        SubgroupMemory = 0x00000080,
+        WorkgroupMemory = 0x00000100,
+        CrossWorkgroupMemory = 0x00000200,
+        AtomicCounterMemory = 0x00000400,
+        ImageMemory = 0x00000800,
+    },
+
+    MemoryAccessShift = {
+        Volatile = 0,
+        Aligned = 1,
+        Nontemporal = 2,
+    },
+
+    MemoryAccessMask = {
+        MaskNone = 0,
+        Volatile = 0x00000001,
+        Aligned = 0x00000002,
+        Nontemporal = 0x00000004,
+    },
+
+    Scope = {
+        CrossDevice = 0,
+        Device = 1,
+        Workgroup = 2,
+        Subgroup = 3,
+        Invocation = 4,
+    },
+
+    GroupOperation = {
+        Reduce = 0,
+        InclusiveScan = 1,
+        ExclusiveScan = 2,
+    },
+
+    KernelEnqueueFlags = {
+        NoWait = 0,
+        WaitKernel = 1,
+        WaitWorkGroup = 2,
+    },
+
+    KernelProfilingInfoShift = {
+        CmdExecTime = 0,
+    },
+
+    KernelProfilingInfoMask = {
+        MaskNone = 0,
+        CmdExecTime = 0x00000001,
+    },
+
+    Capability = {
+        Matrix = 0,
+        Shader = 1,
+        Geometry = 2,
+        Tessellation = 3,
+        Addresses = 4,
+        Linkage = 5,
+        Kernel = 6,
+        Vector16 = 7,
+        Float16Buffer = 8,
+        Float16 = 9,
+        Float64 = 10,
+        Int64 = 11,
+        Int64Atomics = 12,
+        ImageBasic = 13,
+        ImageReadWrite = 14,
+        ImageMipmap = 15,
+        Pipes = 17,
+        Groups = 18,
+        DeviceEnqueue = 19,
+        LiteralSampler = 20,
+        AtomicStorage = 21,
+        Int16 = 22,
+        TessellationPointSize = 23,
+        GeometryPointSize = 24,
+        ImageGatherExtended = 25,
+        StorageImageMultisample = 27,
+        UniformBufferArrayDynamicIndexing = 28,
+        SampledImageArrayDynamicIndexing = 29,
+        StorageBufferArrayDynamicIndexing = 30,
+        StorageImageArrayDynamicIndexing = 31,
+        ClipDistance = 32,
+        CullDistance = 33,
+        ImageCubeArray = 34,
+        SampleRateShading = 35,
+        ImageRect = 36,
+        SampledRect = 37,
+        GenericPointer = 38,
+        Int8 = 39,
+        InputAttachment = 40,
+        SparseResidency = 41,
+        MinLod = 42,
+        Sampled1D = 43,
+        Image1D = 44,
+        SampledCubeArray = 45,
+        SampledBuffer = 46,
+        ImageBuffer = 47,
+        ImageMSArray = 48,
+        StorageImageExtendedFormats = 49,
+        ImageQuery = 50,
+        DerivativeControl = 51,
+        InterpolationFunction = 52,
+        TransformFeedback = 53,
+        GeometryStreams = 54,
+        StorageImageReadWithoutFormat = 55,
+        StorageImageWriteWithoutFormat = 56,
+        MultiViewport = 57,
+        SubgroupBallotKHR = 4423,
+        DrawParameters = 4427,
+        SubgroupVoteKHR = 4431,
+        StorageBuffer16BitAccess = 4433,
+        StorageUniformBufferBlock16 = 4433,
+        StorageUniform16 = 4434,
+        UniformAndStorageBuffer16BitAccess = 4434,
+        StoragePushConstant16 = 4435,
+        StorageInputOutput16 = 4436,
+        DeviceGroup = 4437,
+        MultiView = 4439,
+        VariablePointersStorageBuffer = 4441,
+        VariablePointers = 4442,
+        AtomicStorageOps = 4445,
+        SampleMaskPostDepthCoverage = 4447,
+        ImageGatherBiasLodAMD = 5009,
+        FragmentMaskAMD = 5010,
+        StencilExportEXT = 5013,
+        ImageReadWriteLodAMD = 5015,
+        SampleMaskOverrideCoverageNV = 5249,
+        GeometryShaderPassthroughNV = 5251,
+        ShaderViewportIndexLayerEXT = 5254,
+        ShaderViewportIndexLayerNV = 5254,
+        ShaderViewportMaskNV = 5255,
+        ShaderStereoViewNV = 5259,
+        PerViewAttributesNV = 5260,
+        SubgroupShuffleINTEL = 5568,
+        SubgroupBufferBlockIOINTEL = 5569,
+        SubgroupImageBlockIOINTEL = 5570,
+    },
+
+    Op = {
+        OpNop = 0,
+        OpUndef = 1,
+        OpSourceContinued = 2,
+        OpSource = 3,
+        OpSourceExtension = 4,
+        OpName = 5,
+        OpMemberName = 6,
+        OpString = 7,
+        OpLine = 8,
+        OpExtension = 10,
+        OpExtInstImport = 11,
+        OpExtInst = 12,
+        OpMemoryModel = 14,
+        OpEntryPoint = 15,
+        OpExecutionMode = 16,
+        OpCapability = 17,
+        OpTypeVoid = 19,
+        OpTypeBool = 20,
+        OpTypeInt = 21,
+        OpTypeFloat = 22,
+        OpTypeVector = 23,
+        OpTypeMatrix = 24,
+        OpTypeImage = 25,
+        OpTypeSampler = 26,
+        OpTypeSampledImage = 27,
+        OpTypeArray = 28,
+        OpTypeRuntimeArray = 29,
+        OpTypeStruct = 30,
+        OpTypeOpaque = 31,
+        OpTypePointer = 32,
+        OpTypeFunction = 33,
+        OpTypeEvent = 34,
+        OpTypeDeviceEvent = 35,
+        OpTypeReserveId = 36,
+        OpTypeQueue = 37,
+        OpTypePipe = 38,
+        OpTypeForwardPointer = 39,
+        OpConstantTrue = 41,
+        OpConstantFalse = 42,
+        OpConstant = 43,
+        OpConstantComposite = 44,
+        OpConstantSampler = 45,
+        OpConstantNull = 46,
+        OpSpecConstantTrue = 48,
+        OpSpecConstantFalse = 49,
+        OpSpecConstant = 50,
+        OpSpecConstantComposite = 51,
+        OpSpecConstantOp = 52,
+        OpFunction = 54,
+        OpFunctionParameter = 55,
+        OpFunctionEnd = 56,
+        OpFunctionCall = 57,
+        OpVariable = 59,
+        OpImageTexelPointer = 60,
+        OpLoad = 61,
+        OpStore = 62,
+        OpCopyMemory = 63,
+        OpCopyMemorySized = 64,
+        OpAccessChain = 65,
+        OpInBoundsAccessChain = 66,
+        OpPtrAccessChain = 67,
+        OpArrayLength = 68,
+        OpGenericPtrMemSemantics = 69,
+        OpInBoundsPtrAccessChain = 70,
+        OpDecorate = 71,
+        OpMemberDecorate = 72,
+        OpDecorationGroup = 73,
+        OpGroupDecorate = 74,
+        OpGroupMemberDecorate = 75,
+        OpVectorExtractDynamic = 77,
+        OpVectorInsertDynamic = 78,
+        OpVectorShuffle = 79,
+        OpCompositeConstruct = 80,
+        OpCompositeExtract = 81,
+        OpCompositeInsert = 82,
+        OpCopyObject = 83,
+        OpTranspose = 84,
+        OpSampledImage = 86,
+        OpImageSampleImplicitLod = 87,
+        OpImageSampleExplicitLod = 88,
+        OpImageSampleDrefImplicitLod = 89,
+        OpImageSampleDrefExplicitLod = 90,
+        OpImageSampleProjImplicitLod = 91,
+        OpImageSampleProjExplicitLod = 92,
+        OpImageSampleProjDrefImplicitLod = 93,
+        OpImageSampleProjDrefExplicitLod = 94,
+        OpImageFetch = 95,
+        OpImageGather = 96,
+        OpImageDrefGather = 97,
+        OpImageRead = 98,
+        OpImageWrite = 99,
+        OpImage = 100,
+        OpImageQueryFormat = 101,
+        OpImageQueryOrder = 102,
+        OpImageQuerySizeLod = 103,
+        OpImageQuerySize = 104,
+        OpImageQueryLod = 105,
+        OpImageQueryLevels = 106,
+        OpImageQuerySamples = 107,
+        OpConvertFToU = 109,
+        OpConvertFToS = 110,
+        OpConvertSToF = 111,
+        OpConvertUToF = 112,
+        OpUConvert = 113,
+        OpSConvert = 114,
+        OpFConvert = 115,
+        OpQuantizeToF16 = 116,
+        OpConvertPtrToU = 117,
+        OpSatConvertSToU = 118,
+        OpSatConvertUToS = 119,
+        OpConvertUToPtr = 120,
+        OpPtrCastToGeneric = 121,
+        OpGenericCastToPtr = 122,
+        OpGenericCastToPtrExplicit = 123,
+        OpBitcast = 124,
+        OpSNegate = 126,
+        OpFNegate = 127,
+        OpIAdd = 128,
+        OpFAdd = 129,
+        OpISub = 130,
+        OpFSub = 131,
+        OpIMul = 132,
+        OpFMul = 133,
+        OpUDiv = 134,
+        OpSDiv = 135,
+        OpFDiv = 136,
+        OpUMod = 137,
+        OpSRem = 138,
+        OpSMod = 139,
+        OpFRem = 140,
+        OpFMod = 141,
+        OpVectorTimesScalar = 142,
+        OpMatrixTimesScalar = 143,
+        OpVectorTimesMatrix = 144,
+        OpMatrixTimesVector = 145,
+        OpMatrixTimesMatrix = 146,
+        OpOuterProduct = 147,
+        OpDot = 148,
+        OpIAddCarry = 149,
+        OpISubBorrow = 150,
+        OpUMulExtended = 151,
+        OpSMulExtended = 152,
+        OpAny = 154,
+        OpAll = 155,
+        OpIsNan = 156,
+        OpIsInf = 157,
+        OpIsFinite = 158,
+        OpIsNormal = 159,
+        OpSignBitSet = 160,
+        OpLessOrGreater = 161,
+        OpOrdered = 162,
+        OpUnordered = 163,
+        OpLogicalEqual = 164,
+        OpLogicalNotEqual = 165,
+        OpLogicalOr = 166,
+        OpLogicalAnd = 167,
+        OpLogicalNot = 168,
+        OpSelect = 169,
+        OpIEqual = 170,
+        OpINotEqual = 171,
+        OpUGreaterThan = 172,
+        OpSGreaterThan = 173,
+        OpUGreaterThanEqual = 174,
+        OpSGreaterThanEqual = 175,
+        OpULessThan = 176,
+        OpSLessThan = 177,
+        OpULessThanEqual = 178,
+        OpSLessThanEqual = 179,
+        OpFOrdEqual = 180,
+        OpFUnordEqual = 181,
+        OpFOrdNotEqual = 182,
+        OpFUnordNotEqual = 183,
+        OpFOrdLessThan = 184,
+        OpFUnordLessThan = 185,
+        OpFOrdGreaterThan = 186,
+        OpFUnordGreaterThan = 187,
+        OpFOrdLessThanEqual = 188,
+        OpFUnordLessThanEqual = 189,
+        OpFOrdGreaterThanEqual = 190,
+        OpFUnordGreaterThanEqual = 191,
+        OpShiftRightLogical = 194,
+        OpShiftRightArithmetic = 195,
+        OpShiftLeftLogical = 196,
+        OpBitwiseOr = 197,
+        OpBitwiseXor = 198,
+        OpBitwiseAnd = 199,
+        OpNot = 200,
+        OpBitFieldInsert = 201,
+        OpBitFieldSExtract = 202,
+        OpBitFieldUExtract = 203,
+        OpBitReverse = 204,
+        OpBitCount = 205,
+        OpDPdx = 207,
+        OpDPdy = 208,
+        OpFwidth = 209,
+        OpDPdxFine = 210,
+        OpDPdyFine = 211,
+        OpFwidthFine = 212,
+        OpDPdxCoarse = 213,
+        OpDPdyCoarse = 214,
+        OpFwidthCoarse = 215,
+        OpEmitVertex = 218,
+        OpEndPrimitive = 219,
+        OpEmitStreamVertex = 220,
+        OpEndStreamPrimitive = 221,
+        OpControlBarrier = 224,
+        OpMemoryBarrier = 225,
+        OpAtomicLoad = 227,
+        OpAtomicStore = 228,
+        OpAtomicExchange = 229,
+        OpAtomicCompareExchange = 230,
+        OpAtomicCompareExchangeWeak = 231,
+        OpAtomicIIncrement = 232,
+        OpAtomicIDecrement = 233,
+        OpAtomicIAdd = 234,
+        OpAtomicISub = 235,
+        OpAtomicSMin = 236,
+        OpAtomicUMin = 237,
+        OpAtomicSMax = 238,
+        OpAtomicUMax = 239,
+        OpAtomicAnd = 240,
+        OpAtomicOr = 241,
+        OpAtomicXor = 242,
+        OpPhi = 245,
+        OpLoopMerge = 246,
+        OpSelectionMerge = 247,
+        OpLabel = 248,
+        OpBranch = 249,
+        OpBranchConditional = 250,
+        OpSwitch = 251,
+        OpKill = 252,
+        OpReturn = 253,
+        OpReturnValue = 254,
+        OpUnreachable = 255,
+        OpLifetimeStart = 256,
+        OpLifetimeStop = 257,
+        OpGroupAsyncCopy = 259,
+        OpGroupWaitEvents = 260,
+        OpGroupAll = 261,
+        OpGroupAny = 262,
+        OpGroupBroadcast = 263,
+        OpGroupIAdd = 264,
+        OpGroupFAdd = 265,
+        OpGroupFMin = 266,
+        OpGroupUMin = 267,
+        OpGroupSMin = 268,
+        OpGroupFMax = 269,
+        OpGroupUMax = 270,
+        OpGroupSMax = 271,
+        OpReadPipe = 274,
+        OpWritePipe = 275,
+        OpReservedReadPipe = 276,
+        OpReservedWritePipe = 277,
+        OpReserveReadPipePackets = 278,
+        OpReserveWritePipePackets = 279,
+        OpCommitReadPipe = 280,
+        OpCommitWritePipe = 281,
+        OpIsValidReserveId = 282,
+        OpGetNumPipePackets = 283,
+        OpGetMaxPipePackets = 284,
+        OpGroupReserveReadPipePackets = 285,
+        OpGroupReserveWritePipePackets = 286,
+        OpGroupCommitReadPipe = 287,
+        OpGroupCommitWritePipe = 288,
+        OpEnqueueMarker = 291,
+        OpEnqueueKernel = 292,
+        OpGetKernelNDrangeSubGroupCount = 293,
+        OpGetKernelNDrangeMaxSubGroupSize = 294,
+        OpGetKernelWorkGroupSize = 295,
+        OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+        OpRetainEvent = 297,
+        OpReleaseEvent = 298,
+        OpCreateUserEvent = 299,
+        OpIsValidEvent = 300,
+        OpSetUserEventStatus = 301,
+        OpCaptureEventProfilingInfo = 302,
+        OpGetDefaultQueue = 303,
+        OpBuildNDRange = 304,
+        OpImageSparseSampleImplicitLod = 305,
+        OpImageSparseSampleExplicitLod = 306,
+        OpImageSparseSampleDrefImplicitLod = 307,
+        OpImageSparseSampleDrefExplicitLod = 308,
+        OpImageSparseSampleProjImplicitLod = 309,
+        OpImageSparseSampleProjExplicitLod = 310,
+        OpImageSparseSampleProjDrefImplicitLod = 311,
+        OpImageSparseSampleProjDrefExplicitLod = 312,
+        OpImageSparseFetch = 313,
+        OpImageSparseGather = 314,
+        OpImageSparseDrefGather = 315,
+        OpImageSparseTexelsResident = 316,
+        OpNoLine = 317,
+        OpAtomicFlagTestAndSet = 318,
+        OpAtomicFlagClear = 319,
+        OpImageSparseRead = 320,
+        OpDecorateId = 332,
+        OpSubgroupBallotKHR = 4421,
+        OpSubgroupFirstInvocationKHR = 4422,
+        OpSubgroupAllKHR = 4428,
+        OpSubgroupAnyKHR = 4429,
+        OpSubgroupAllEqualKHR = 4430,
+        OpSubgroupReadInvocationKHR = 4432,
+        OpGroupIAddNonUniformAMD = 5000,
+        OpGroupFAddNonUniformAMD = 5001,
+        OpGroupFMinNonUniformAMD = 5002,
+        OpGroupUMinNonUniformAMD = 5003,
+        OpGroupSMinNonUniformAMD = 5004,
+        OpGroupFMaxNonUniformAMD = 5005,
+        OpGroupUMaxNonUniformAMD = 5006,
+        OpGroupSMaxNonUniformAMD = 5007,
+        OpFragmentMaskFetchAMD = 5011,
+        OpFragmentFetchAMD = 5012,
+        OpSubgroupShuffleINTEL = 5571,
+        OpSubgroupShuffleDownINTEL = 5572,
+        OpSubgroupShuffleUpINTEL = 5573,
+        OpSubgroupShuffleXorINTEL = 5574,
+        OpSubgroupBlockReadINTEL = 5575,
+        OpSubgroupBlockWriteINTEL = 5576,
+        OpSubgroupImageBlockReadINTEL = 5577,
+        OpSubgroupImageBlockWriteINTEL = 5578,
+        OpDecorateStringGOOGLE = 5632,
+        OpMemberDecorateStringGOOGLE = 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.0/spirv.py

@@ -0,0 +1,949 @@
+# Copyright (c) 2014-2018 The Khronos Group Inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and/or associated documentation files (the "Materials"),
+# to deal in the Materials without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Materials, and to permit persons to whom the
+# Materials are furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Materials.
+# 
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+# STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+# HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+# 
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+# IN THE MATERIALS.
+
+# This header is automatically generated by the same tool that creates
+# the Binary Section of the SPIR-V specification.
+
+# Enumeration tokens for SPIR-V, in various styles:
+#   C, C++, C++11, JSON, Lua, Python
+# 
+# - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+# - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+# - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+# - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+# - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+# 
+# Some tokens act like mask values, which can be OR'd together,
+# while others are mutually exclusive.  The mask-like ones have
+# "Mask" in their name, and a parallel enum that has the shift
+# amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    'MagicNumber' : 0x07230203,
+    'Version' : 0x00010000,
+    'Revision' : 12,
+    'OpCodeMask' : 0xffff,
+    'WordCountShift' : 16,
+
+    'SourceLanguage' : {
+        'Unknown' : 0,
+        'ESSL' : 1,
+        'GLSL' : 2,
+        'OpenCL_C' : 3,
+        'OpenCL_CPP' : 4,
+        'HLSL' : 5,
+    },
+
+    'ExecutionModel' : {
+        'Vertex' : 0,
+        'TessellationControl' : 1,
+        'TessellationEvaluation' : 2,
+        'Geometry' : 3,
+        'Fragment' : 4,
+        'GLCompute' : 5,
+        'Kernel' : 6,
+    },
+
+    'AddressingModel' : {
+        'Logical' : 0,
+        'Physical32' : 1,
+        'Physical64' : 2,
+    },
+
+    'MemoryModel' : {
+        'Simple' : 0,
+        'GLSL450' : 1,
+        'OpenCL' : 2,
+    },
+
+    'ExecutionMode' : {
+        'Invocations' : 0,
+        'SpacingEqual' : 1,
+        'SpacingFractionalEven' : 2,
+        'SpacingFractionalOdd' : 3,
+        'VertexOrderCw' : 4,
+        'VertexOrderCcw' : 5,
+        'PixelCenterInteger' : 6,
+        'OriginUpperLeft' : 7,
+        'OriginLowerLeft' : 8,
+        'EarlyFragmentTests' : 9,
+        'PointMode' : 10,
+        'Xfb' : 11,
+        'DepthReplacing' : 12,
+        'DepthGreater' : 14,
+        'DepthLess' : 15,
+        'DepthUnchanged' : 16,
+        'LocalSize' : 17,
+        'LocalSizeHint' : 18,
+        'InputPoints' : 19,
+        'InputLines' : 20,
+        'InputLinesAdjacency' : 21,
+        'Triangles' : 22,
+        'InputTrianglesAdjacency' : 23,
+        'Quads' : 24,
+        'Isolines' : 25,
+        'OutputVertices' : 26,
+        'OutputPoints' : 27,
+        'OutputLineStrip' : 28,
+        'OutputTriangleStrip' : 29,
+        'VecTypeHint' : 30,
+        'ContractionOff' : 31,
+        'PostDepthCoverage' : 4446,
+        'StencilRefReplacingEXT' : 5027,
+    },
+
+    'StorageClass' : {
+        'UniformConstant' : 0,
+        'Input' : 1,
+        'Uniform' : 2,
+        'Output' : 3,
+        'Workgroup' : 4,
+        'CrossWorkgroup' : 5,
+        'Private' : 6,
+        'Function' : 7,
+        'Generic' : 8,
+        'PushConstant' : 9,
+        'AtomicCounter' : 10,
+        'Image' : 11,
+        'StorageBuffer' : 12,
+    },
+
+    'Dim' : {
+        'Dim1D' : 0,
+        'Dim2D' : 1,
+        'Dim3D' : 2,
+        'Cube' : 3,
+        'Rect' : 4,
+        'Buffer' : 5,
+        'SubpassData' : 6,
+    },
+
+    'SamplerAddressingMode' : {
+        'None' : 0,
+        'ClampToEdge' : 1,
+        'Clamp' : 2,
+        'Repeat' : 3,
+        'RepeatMirrored' : 4,
+    },
+
+    'SamplerFilterMode' : {
+        'Nearest' : 0,
+        'Linear' : 1,
+    },
+
+    'ImageFormat' : {
+        'Unknown' : 0,
+        'Rgba32f' : 1,
+        'Rgba16f' : 2,
+        'R32f' : 3,
+        'Rgba8' : 4,
+        'Rgba8Snorm' : 5,
+        'Rg32f' : 6,
+        'Rg16f' : 7,
+        'R11fG11fB10f' : 8,
+        'R16f' : 9,
+        'Rgba16' : 10,
+        'Rgb10A2' : 11,
+        'Rg16' : 12,
+        'Rg8' : 13,
+        'R16' : 14,
+        'R8' : 15,
+        'Rgba16Snorm' : 16,
+        'Rg16Snorm' : 17,
+        'Rg8Snorm' : 18,
+        'R16Snorm' : 19,
+        'R8Snorm' : 20,
+        'Rgba32i' : 21,
+        'Rgba16i' : 22,
+        'Rgba8i' : 23,
+        'R32i' : 24,
+        'Rg32i' : 25,
+        'Rg16i' : 26,
+        'Rg8i' : 27,
+        'R16i' : 28,
+        'R8i' : 29,
+        'Rgba32ui' : 30,
+        'Rgba16ui' : 31,
+        'Rgba8ui' : 32,
+        'R32ui' : 33,
+        'Rgb10a2ui' : 34,
+        'Rg32ui' : 35,
+        'Rg16ui' : 36,
+        'Rg8ui' : 37,
+        'R16ui' : 38,
+        'R8ui' : 39,
+    },
+
+    'ImageChannelOrder' : {
+        'R' : 0,
+        'A' : 1,
+        'RG' : 2,
+        'RA' : 3,
+        'RGB' : 4,
+        'RGBA' : 5,
+        'BGRA' : 6,
+        'ARGB' : 7,
+        'Intensity' : 8,
+        'Luminance' : 9,
+        'Rx' : 10,
+        'RGx' : 11,
+        'RGBx' : 12,
+        'Depth' : 13,
+        'DepthStencil' : 14,
+        'sRGB' : 15,
+        'sRGBx' : 16,
+        'sRGBA' : 17,
+        'sBGRA' : 18,
+        'ABGR' : 19,
+    },
+
+    'ImageChannelDataType' : {
+        'SnormInt8' : 0,
+        'SnormInt16' : 1,
+        'UnormInt8' : 2,
+        'UnormInt16' : 3,
+        'UnormShort565' : 4,
+        'UnormShort555' : 5,
+        'UnormInt101010' : 6,
+        'SignedInt8' : 7,
+        'SignedInt16' : 8,
+        'SignedInt32' : 9,
+        'UnsignedInt8' : 10,
+        'UnsignedInt16' : 11,
+        'UnsignedInt32' : 12,
+        'HalfFloat' : 13,
+        'Float' : 14,
+        'UnormInt24' : 15,
+        'UnormInt101010_2' : 16,
+    },
+
+    'ImageOperandsShift' : {
+        'Bias' : 0,
+        'Lod' : 1,
+        'Grad' : 2,
+        'ConstOffset' : 3,
+        'Offset' : 4,
+        'ConstOffsets' : 5,
+        'Sample' : 6,
+        'MinLod' : 7,
+    },
+
+    'ImageOperandsMask' : {
+        'MaskNone' : 0,
+        'Bias' : 0x00000001,
+        'Lod' : 0x00000002,
+        'Grad' : 0x00000004,
+        'ConstOffset' : 0x00000008,
+        'Offset' : 0x00000010,
+        'ConstOffsets' : 0x00000020,
+        'Sample' : 0x00000040,
+        'MinLod' : 0x00000080,
+    },
+
+    'FPFastMathModeShift' : {
+        'NotNaN' : 0,
+        'NotInf' : 1,
+        'NSZ' : 2,
+        'AllowRecip' : 3,
+        'Fast' : 4,
+    },
+
+    'FPFastMathModeMask' : {
+        'MaskNone' : 0,
+        'NotNaN' : 0x00000001,
+        'NotInf' : 0x00000002,
+        'NSZ' : 0x00000004,
+        'AllowRecip' : 0x00000008,
+        'Fast' : 0x00000010,
+    },
+
+    'FPRoundingMode' : {
+        'RTE' : 0,
+        'RTZ' : 1,
+        'RTP' : 2,
+        'RTN' : 3,
+    },
+
+    'LinkageType' : {
+        'Export' : 0,
+        'Import' : 1,
+    },
+
+    'AccessQualifier' : {
+        'ReadOnly' : 0,
+        'WriteOnly' : 1,
+        'ReadWrite' : 2,
+    },
+
+    'FunctionParameterAttribute' : {
+        'Zext' : 0,
+        'Sext' : 1,
+        'ByVal' : 2,
+        'Sret' : 3,
+        'NoAlias' : 4,
+        'NoCapture' : 5,
+        'NoWrite' : 6,
+        'NoReadWrite' : 7,
+    },
+
+    'Decoration' : {
+        'RelaxedPrecision' : 0,
+        'SpecId' : 1,
+        'Block' : 2,
+        'BufferBlock' : 3,
+        'RowMajor' : 4,
+        'ColMajor' : 5,
+        'ArrayStride' : 6,
+        'MatrixStride' : 7,
+        'GLSLShared' : 8,
+        'GLSLPacked' : 9,
+        'CPacked' : 10,
+        'BuiltIn' : 11,
+        'NoPerspective' : 13,
+        'Flat' : 14,
+        'Patch' : 15,
+        'Centroid' : 16,
+        'Sample' : 17,
+        'Invariant' : 18,
+        'Restrict' : 19,
+        'Aliased' : 20,
+        'Volatile' : 21,
+        'Constant' : 22,
+        'Coherent' : 23,
+        'NonWritable' : 24,
+        'NonReadable' : 25,
+        'Uniform' : 26,
+        'SaturatedConversion' : 28,
+        'Stream' : 29,
+        'Location' : 30,
+        'Component' : 31,
+        'Index' : 32,
+        'Binding' : 33,
+        'DescriptorSet' : 34,
+        'Offset' : 35,
+        'XfbBuffer' : 36,
+        'XfbStride' : 37,
+        'FuncParamAttr' : 38,
+        'FPRoundingMode' : 39,
+        'FPFastMathMode' : 40,
+        'LinkageAttributes' : 41,
+        'NoContraction' : 42,
+        'InputAttachmentIndex' : 43,
+        'Alignment' : 44,
+        'ExplicitInterpAMD' : 4999,
+        'OverrideCoverageNV' : 5248,
+        'PassthroughNV' : 5250,
+        'ViewportRelativeNV' : 5252,
+        'SecondaryViewportRelativeNV' : 5256,
+        'HlslCounterBufferGOOGLE' : 5634,
+        'HlslSemanticGOOGLE' : 5635,
+    },
+
+    'BuiltIn' : {
+        'Position' : 0,
+        'PointSize' : 1,
+        'ClipDistance' : 3,
+        'CullDistance' : 4,
+        'VertexId' : 5,
+        'InstanceId' : 6,
+        'PrimitiveId' : 7,
+        'InvocationId' : 8,
+        'Layer' : 9,
+        'ViewportIndex' : 10,
+        'TessLevelOuter' : 11,
+        'TessLevelInner' : 12,
+        'TessCoord' : 13,
+        'PatchVertices' : 14,
+        'FragCoord' : 15,
+        'PointCoord' : 16,
+        'FrontFacing' : 17,
+        'SampleId' : 18,
+        'SamplePosition' : 19,
+        'SampleMask' : 20,
+        'FragDepth' : 22,
+        'HelperInvocation' : 23,
+        'NumWorkgroups' : 24,
+        'WorkgroupSize' : 25,
+        'WorkgroupId' : 26,
+        'LocalInvocationId' : 27,
+        'GlobalInvocationId' : 28,
+        'LocalInvocationIndex' : 29,
+        'WorkDim' : 30,
+        'GlobalSize' : 31,
+        'EnqueuedWorkgroupSize' : 32,
+        'GlobalOffset' : 33,
+        'GlobalLinearId' : 34,
+        'SubgroupSize' : 36,
+        'SubgroupMaxSize' : 37,
+        'NumSubgroups' : 38,
+        'NumEnqueuedSubgroups' : 39,
+        'SubgroupId' : 40,
+        'SubgroupLocalInvocationId' : 41,
+        'VertexIndex' : 42,
+        'InstanceIndex' : 43,
+        'SubgroupEqMaskKHR' : 4416,
+        'SubgroupGeMaskKHR' : 4417,
+        'SubgroupGtMaskKHR' : 4418,
+        'SubgroupLeMaskKHR' : 4419,
+        'SubgroupLtMaskKHR' : 4420,
+        'BaseVertex' : 4424,
+        'BaseInstance' : 4425,
+        'DrawIndex' : 4426,
+        'DeviceIndex' : 4438,
+        'ViewIndex' : 4440,
+        'BaryCoordNoPerspAMD' : 4992,
+        'BaryCoordNoPerspCentroidAMD' : 4993,
+        'BaryCoordNoPerspSampleAMD' : 4994,
+        'BaryCoordSmoothAMD' : 4995,
+        'BaryCoordSmoothCentroidAMD' : 4996,
+        'BaryCoordSmoothSampleAMD' : 4997,
+        'BaryCoordPullModelAMD' : 4998,
+        'FragStencilRefEXT' : 5014,
+        'ViewportMaskNV' : 5253,
+        'SecondaryPositionNV' : 5257,
+        'SecondaryViewportMaskNV' : 5258,
+        'PositionPerViewNV' : 5261,
+        'ViewportMaskPerViewNV' : 5262,
+    },
+
+    'SelectionControlShift' : {
+        'Flatten' : 0,
+        'DontFlatten' : 1,
+    },
+
+    'SelectionControlMask' : {
+        'MaskNone' : 0,
+        'Flatten' : 0x00000001,
+        'DontFlatten' : 0x00000002,
+    },
+
+    'LoopControlShift' : {
+        'Unroll' : 0,
+        'DontUnroll' : 1,
+    },
+
+    'LoopControlMask' : {
+        'MaskNone' : 0,
+        'Unroll' : 0x00000001,
+        'DontUnroll' : 0x00000002,
+    },
+
+    'FunctionControlShift' : {
+        'Inline' : 0,
+        'DontInline' : 1,
+        'Pure' : 2,
+        'Const' : 3,
+    },
+
+    'FunctionControlMask' : {
+        'MaskNone' : 0,
+        'Inline' : 0x00000001,
+        'DontInline' : 0x00000002,
+        'Pure' : 0x00000004,
+        'Const' : 0x00000008,
+    },
+
+    'MemorySemanticsShift' : {
+        'Acquire' : 1,
+        'Release' : 2,
+        'AcquireRelease' : 3,
+        'SequentiallyConsistent' : 4,
+        'UniformMemory' : 6,
+        'SubgroupMemory' : 7,
+        'WorkgroupMemory' : 8,
+        'CrossWorkgroupMemory' : 9,
+        'AtomicCounterMemory' : 10,
+        'ImageMemory' : 11,
+    },
+
+    'MemorySemanticsMask' : {
+        'MaskNone' : 0,
+        'Acquire' : 0x00000002,
+        'Release' : 0x00000004,
+        'AcquireRelease' : 0x00000008,
+        'SequentiallyConsistent' : 0x00000010,
+        'UniformMemory' : 0x00000040,
+        'SubgroupMemory' : 0x00000080,
+        'WorkgroupMemory' : 0x00000100,
+        'CrossWorkgroupMemory' : 0x00000200,
+        'AtomicCounterMemory' : 0x00000400,
+        'ImageMemory' : 0x00000800,
+    },
+
+    'MemoryAccessShift' : {
+        'Volatile' : 0,
+        'Aligned' : 1,
+        'Nontemporal' : 2,
+    },
+
+    'MemoryAccessMask' : {
+        'MaskNone' : 0,
+        'Volatile' : 0x00000001,
+        'Aligned' : 0x00000002,
+        'Nontemporal' : 0x00000004,
+    },
+
+    'Scope' : {
+        'CrossDevice' : 0,
+        'Device' : 1,
+        'Workgroup' : 2,
+        'Subgroup' : 3,
+        'Invocation' : 4,
+    },
+
+    'GroupOperation' : {
+        'Reduce' : 0,
+        'InclusiveScan' : 1,
+        'ExclusiveScan' : 2,
+    },
+
+    'KernelEnqueueFlags' : {
+        'NoWait' : 0,
+        'WaitKernel' : 1,
+        'WaitWorkGroup' : 2,
+    },
+
+    'KernelProfilingInfoShift' : {
+        'CmdExecTime' : 0,
+    },
+
+    'KernelProfilingInfoMask' : {
+        'MaskNone' : 0,
+        'CmdExecTime' : 0x00000001,
+    },
+
+    'Capability' : {
+        'Matrix' : 0,
+        'Shader' : 1,
+        'Geometry' : 2,
+        'Tessellation' : 3,
+        'Addresses' : 4,
+        'Linkage' : 5,
+        'Kernel' : 6,
+        'Vector16' : 7,
+        'Float16Buffer' : 8,
+        'Float16' : 9,
+        'Float64' : 10,
+        'Int64' : 11,
+        'Int64Atomics' : 12,
+        'ImageBasic' : 13,
+        'ImageReadWrite' : 14,
+        'ImageMipmap' : 15,
+        'Pipes' : 17,
+        'Groups' : 18,
+        'DeviceEnqueue' : 19,
+        'LiteralSampler' : 20,
+        'AtomicStorage' : 21,
+        'Int16' : 22,
+        'TessellationPointSize' : 23,
+        'GeometryPointSize' : 24,
+        'ImageGatherExtended' : 25,
+        'StorageImageMultisample' : 27,
+        'UniformBufferArrayDynamicIndexing' : 28,
+        'SampledImageArrayDynamicIndexing' : 29,
+        'StorageBufferArrayDynamicIndexing' : 30,
+        'StorageImageArrayDynamicIndexing' : 31,
+        'ClipDistance' : 32,
+        'CullDistance' : 33,
+        'ImageCubeArray' : 34,
+        'SampleRateShading' : 35,
+        'ImageRect' : 36,
+        'SampledRect' : 37,
+        'GenericPointer' : 38,
+        'Int8' : 39,
+        'InputAttachment' : 40,
+        'SparseResidency' : 41,
+        'MinLod' : 42,
+        'Sampled1D' : 43,
+        'Image1D' : 44,
+        'SampledCubeArray' : 45,
+        'SampledBuffer' : 46,
+        'ImageBuffer' : 47,
+        'ImageMSArray' : 48,
+        'StorageImageExtendedFormats' : 49,
+        'ImageQuery' : 50,
+        'DerivativeControl' : 51,
+        'InterpolationFunction' : 52,
+        'TransformFeedback' : 53,
+        'GeometryStreams' : 54,
+        'StorageImageReadWithoutFormat' : 55,
+        'StorageImageWriteWithoutFormat' : 56,
+        'MultiViewport' : 57,
+        'SubgroupBallotKHR' : 4423,
+        'DrawParameters' : 4427,
+        'SubgroupVoteKHR' : 4431,
+        'StorageBuffer16BitAccess' : 4433,
+        'StorageUniformBufferBlock16' : 4433,
+        'StorageUniform16' : 4434,
+        'UniformAndStorageBuffer16BitAccess' : 4434,
+        'StoragePushConstant16' : 4435,
+        'StorageInputOutput16' : 4436,
+        'DeviceGroup' : 4437,
+        'MultiView' : 4439,
+        'VariablePointersStorageBuffer' : 4441,
+        'VariablePointers' : 4442,
+        'AtomicStorageOps' : 4445,
+        'SampleMaskPostDepthCoverage' : 4447,
+        'ImageGatherBiasLodAMD' : 5009,
+        'FragmentMaskAMD' : 5010,
+        'StencilExportEXT' : 5013,
+        'ImageReadWriteLodAMD' : 5015,
+        'SampleMaskOverrideCoverageNV' : 5249,
+        'GeometryShaderPassthroughNV' : 5251,
+        'ShaderViewportIndexLayerEXT' : 5254,
+        'ShaderViewportIndexLayerNV' : 5254,
+        'ShaderViewportMaskNV' : 5255,
+        'ShaderStereoViewNV' : 5259,
+        'PerViewAttributesNV' : 5260,
+        'SubgroupShuffleINTEL' : 5568,
+        'SubgroupBufferBlockIOINTEL' : 5569,
+        'SubgroupImageBlockIOINTEL' : 5570,
+    },
+
+    'Op' : {
+        'OpNop' : 0,
+        'OpUndef' : 1,
+        'OpSourceContinued' : 2,
+        'OpSource' : 3,
+        'OpSourceExtension' : 4,
+        'OpName' : 5,
+        'OpMemberName' : 6,
+        'OpString' : 7,
+        'OpLine' : 8,
+        'OpExtension' : 10,
+        'OpExtInstImport' : 11,
+        'OpExtInst' : 12,
+        'OpMemoryModel' : 14,
+        'OpEntryPoint' : 15,
+        'OpExecutionMode' : 16,
+        'OpCapability' : 17,
+        'OpTypeVoid' : 19,
+        'OpTypeBool' : 20,
+        'OpTypeInt' : 21,
+        'OpTypeFloat' : 22,
+        'OpTypeVector' : 23,
+        'OpTypeMatrix' : 24,
+        'OpTypeImage' : 25,
+        'OpTypeSampler' : 26,
+        'OpTypeSampledImage' : 27,
+        'OpTypeArray' : 28,
+        'OpTypeRuntimeArray' : 29,
+        'OpTypeStruct' : 30,
+        'OpTypeOpaque' : 31,
+        'OpTypePointer' : 32,
+        'OpTypeFunction' : 33,
+        'OpTypeEvent' : 34,
+        'OpTypeDeviceEvent' : 35,
+        'OpTypeReserveId' : 36,
+        'OpTypeQueue' : 37,
+        'OpTypePipe' : 38,
+        'OpTypeForwardPointer' : 39,
+        'OpConstantTrue' : 41,
+        'OpConstantFalse' : 42,
+        'OpConstant' : 43,
+        'OpConstantComposite' : 44,
+        'OpConstantSampler' : 45,
+        'OpConstantNull' : 46,
+        'OpSpecConstantTrue' : 48,
+        'OpSpecConstantFalse' : 49,
+        'OpSpecConstant' : 50,
+        'OpSpecConstantComposite' : 51,
+        'OpSpecConstantOp' : 52,
+        'OpFunction' : 54,
+        'OpFunctionParameter' : 55,
+        'OpFunctionEnd' : 56,
+        'OpFunctionCall' : 57,
+        'OpVariable' : 59,
+        'OpImageTexelPointer' : 60,
+        'OpLoad' : 61,
+        'OpStore' : 62,
+        'OpCopyMemory' : 63,
+        'OpCopyMemorySized' : 64,
+        'OpAccessChain' : 65,
+        'OpInBoundsAccessChain' : 66,
+        'OpPtrAccessChain' : 67,
+        'OpArrayLength' : 68,
+        'OpGenericPtrMemSemantics' : 69,
+        'OpInBoundsPtrAccessChain' : 70,
+        'OpDecorate' : 71,
+        'OpMemberDecorate' : 72,
+        'OpDecorationGroup' : 73,
+        'OpGroupDecorate' : 74,
+        'OpGroupMemberDecorate' : 75,
+        'OpVectorExtractDynamic' : 77,
+        'OpVectorInsertDynamic' : 78,
+        'OpVectorShuffle' : 79,
+        'OpCompositeConstruct' : 80,
+        'OpCompositeExtract' : 81,
+        'OpCompositeInsert' : 82,
+        'OpCopyObject' : 83,
+        'OpTranspose' : 84,
+        'OpSampledImage' : 86,
+        'OpImageSampleImplicitLod' : 87,
+        'OpImageSampleExplicitLod' : 88,
+        'OpImageSampleDrefImplicitLod' : 89,
+        'OpImageSampleDrefExplicitLod' : 90,
+        'OpImageSampleProjImplicitLod' : 91,
+        'OpImageSampleProjExplicitLod' : 92,
+        'OpImageSampleProjDrefImplicitLod' : 93,
+        'OpImageSampleProjDrefExplicitLod' : 94,
+        'OpImageFetch' : 95,
+        'OpImageGather' : 96,
+        'OpImageDrefGather' : 97,
+        'OpImageRead' : 98,
+        'OpImageWrite' : 99,
+        'OpImage' : 100,
+        'OpImageQueryFormat' : 101,
+        'OpImageQueryOrder' : 102,
+        'OpImageQuerySizeLod' : 103,
+        'OpImageQuerySize' : 104,
+        'OpImageQueryLod' : 105,
+        'OpImageQueryLevels' : 106,
+        'OpImageQuerySamples' : 107,
+        'OpConvertFToU' : 109,
+        'OpConvertFToS' : 110,
+        'OpConvertSToF' : 111,
+        'OpConvertUToF' : 112,
+        'OpUConvert' : 113,
+        'OpSConvert' : 114,
+        'OpFConvert' : 115,
+        'OpQuantizeToF16' : 116,
+        'OpConvertPtrToU' : 117,
+        'OpSatConvertSToU' : 118,
+        'OpSatConvertUToS' : 119,
+        'OpConvertUToPtr' : 120,
+        'OpPtrCastToGeneric' : 121,
+        'OpGenericCastToPtr' : 122,
+        'OpGenericCastToPtrExplicit' : 123,
+        'OpBitcast' : 124,
+        'OpSNegate' : 126,
+        'OpFNegate' : 127,
+        'OpIAdd' : 128,
+        'OpFAdd' : 129,
+        'OpISub' : 130,
+        'OpFSub' : 131,
+        'OpIMul' : 132,
+        'OpFMul' : 133,
+        'OpUDiv' : 134,
+        'OpSDiv' : 135,
+        'OpFDiv' : 136,
+        'OpUMod' : 137,
+        'OpSRem' : 138,
+        'OpSMod' : 139,
+        'OpFRem' : 140,
+        'OpFMod' : 141,
+        'OpVectorTimesScalar' : 142,
+        'OpMatrixTimesScalar' : 143,
+        'OpVectorTimesMatrix' : 144,
+        'OpMatrixTimesVector' : 145,
+        'OpMatrixTimesMatrix' : 146,
+        'OpOuterProduct' : 147,
+        'OpDot' : 148,
+        'OpIAddCarry' : 149,
+        'OpISubBorrow' : 150,
+        'OpUMulExtended' : 151,
+        'OpSMulExtended' : 152,
+        'OpAny' : 154,
+        'OpAll' : 155,
+        'OpIsNan' : 156,
+        'OpIsInf' : 157,
+        'OpIsFinite' : 158,
+        'OpIsNormal' : 159,
+        'OpSignBitSet' : 160,
+        'OpLessOrGreater' : 161,
+        'OpOrdered' : 162,
+        'OpUnordered' : 163,
+        'OpLogicalEqual' : 164,
+        'OpLogicalNotEqual' : 165,
+        'OpLogicalOr' : 166,
+        'OpLogicalAnd' : 167,
+        'OpLogicalNot' : 168,
+        'OpSelect' : 169,
+        'OpIEqual' : 170,
+        'OpINotEqual' : 171,
+        'OpUGreaterThan' : 172,
+        'OpSGreaterThan' : 173,
+        'OpUGreaterThanEqual' : 174,
+        'OpSGreaterThanEqual' : 175,
+        'OpULessThan' : 176,
+        'OpSLessThan' : 177,
+        'OpULessThanEqual' : 178,
+        'OpSLessThanEqual' : 179,
+        'OpFOrdEqual' : 180,
+        'OpFUnordEqual' : 181,
+        'OpFOrdNotEqual' : 182,
+        'OpFUnordNotEqual' : 183,
+        'OpFOrdLessThan' : 184,
+        'OpFUnordLessThan' : 185,
+        'OpFOrdGreaterThan' : 186,
+        'OpFUnordGreaterThan' : 187,
+        'OpFOrdLessThanEqual' : 188,
+        'OpFUnordLessThanEqual' : 189,
+        'OpFOrdGreaterThanEqual' : 190,
+        'OpFUnordGreaterThanEqual' : 191,
+        'OpShiftRightLogical' : 194,
+        'OpShiftRightArithmetic' : 195,
+        'OpShiftLeftLogical' : 196,
+        'OpBitwiseOr' : 197,
+        'OpBitwiseXor' : 198,
+        'OpBitwiseAnd' : 199,
+        'OpNot' : 200,
+        'OpBitFieldInsert' : 201,
+        'OpBitFieldSExtract' : 202,
+        'OpBitFieldUExtract' : 203,
+        'OpBitReverse' : 204,
+        'OpBitCount' : 205,
+        'OpDPdx' : 207,
+        'OpDPdy' : 208,
+        'OpFwidth' : 209,
+        'OpDPdxFine' : 210,
+        'OpDPdyFine' : 211,
+        'OpFwidthFine' : 212,
+        'OpDPdxCoarse' : 213,
+        'OpDPdyCoarse' : 214,
+        'OpFwidthCoarse' : 215,
+        'OpEmitVertex' : 218,
+        'OpEndPrimitive' : 219,
+        'OpEmitStreamVertex' : 220,
+        'OpEndStreamPrimitive' : 221,
+        'OpControlBarrier' : 224,
+        'OpMemoryBarrier' : 225,
+        'OpAtomicLoad' : 227,
+        'OpAtomicStore' : 228,
+        'OpAtomicExchange' : 229,
+        'OpAtomicCompareExchange' : 230,
+        'OpAtomicCompareExchangeWeak' : 231,
+        'OpAtomicIIncrement' : 232,
+        'OpAtomicIDecrement' : 233,
+        'OpAtomicIAdd' : 234,
+        'OpAtomicISub' : 235,
+        'OpAtomicSMin' : 236,
+        'OpAtomicUMin' : 237,
+        'OpAtomicSMax' : 238,
+        'OpAtomicUMax' : 239,
+        'OpAtomicAnd' : 240,
+        'OpAtomicOr' : 241,
+        'OpAtomicXor' : 242,
+        'OpPhi' : 245,
+        'OpLoopMerge' : 246,
+        'OpSelectionMerge' : 247,
+        'OpLabel' : 248,
+        'OpBranch' : 249,
+        'OpBranchConditional' : 250,
+        'OpSwitch' : 251,
+        'OpKill' : 252,
+        'OpReturn' : 253,
+        'OpReturnValue' : 254,
+        'OpUnreachable' : 255,
+        'OpLifetimeStart' : 256,
+        'OpLifetimeStop' : 257,
+        'OpGroupAsyncCopy' : 259,
+        'OpGroupWaitEvents' : 260,
+        'OpGroupAll' : 261,
+        'OpGroupAny' : 262,
+        'OpGroupBroadcast' : 263,
+        'OpGroupIAdd' : 264,
+        'OpGroupFAdd' : 265,
+        'OpGroupFMin' : 266,
+        'OpGroupUMin' : 267,
+        'OpGroupSMin' : 268,
+        'OpGroupFMax' : 269,
+        'OpGroupUMax' : 270,
+        'OpGroupSMax' : 271,
+        'OpReadPipe' : 274,
+        'OpWritePipe' : 275,
+        'OpReservedReadPipe' : 276,
+        'OpReservedWritePipe' : 277,
+        'OpReserveReadPipePackets' : 278,
+        'OpReserveWritePipePackets' : 279,
+        'OpCommitReadPipe' : 280,
+        'OpCommitWritePipe' : 281,
+        'OpIsValidReserveId' : 282,
+        'OpGetNumPipePackets' : 283,
+        'OpGetMaxPipePackets' : 284,
+        'OpGroupReserveReadPipePackets' : 285,
+        'OpGroupReserveWritePipePackets' : 286,
+        'OpGroupCommitReadPipe' : 287,
+        'OpGroupCommitWritePipe' : 288,
+        'OpEnqueueMarker' : 291,
+        'OpEnqueueKernel' : 292,
+        'OpGetKernelNDrangeSubGroupCount' : 293,
+        'OpGetKernelNDrangeMaxSubGroupSize' : 294,
+        'OpGetKernelWorkGroupSize' : 295,
+        'OpGetKernelPreferredWorkGroupSizeMultiple' : 296,
+        'OpRetainEvent' : 297,
+        'OpReleaseEvent' : 298,
+        'OpCreateUserEvent' : 299,
+        'OpIsValidEvent' : 300,
+        'OpSetUserEventStatus' : 301,
+        'OpCaptureEventProfilingInfo' : 302,
+        'OpGetDefaultQueue' : 303,
+        'OpBuildNDRange' : 304,
+        'OpImageSparseSampleImplicitLod' : 305,
+        'OpImageSparseSampleExplicitLod' : 306,
+        'OpImageSparseSampleDrefImplicitLod' : 307,
+        'OpImageSparseSampleDrefExplicitLod' : 308,
+        'OpImageSparseSampleProjImplicitLod' : 309,
+        'OpImageSparseSampleProjExplicitLod' : 310,
+        'OpImageSparseSampleProjDrefImplicitLod' : 311,
+        'OpImageSparseSampleProjDrefExplicitLod' : 312,
+        'OpImageSparseFetch' : 313,
+        'OpImageSparseGather' : 314,
+        'OpImageSparseDrefGather' : 315,
+        'OpImageSparseTexelsResident' : 316,
+        'OpNoLine' : 317,
+        'OpAtomicFlagTestAndSet' : 318,
+        'OpAtomicFlagClear' : 319,
+        'OpImageSparseRead' : 320,
+        'OpDecorateId' : 332,
+        'OpSubgroupBallotKHR' : 4421,
+        'OpSubgroupFirstInvocationKHR' : 4422,
+        'OpSubgroupAllKHR' : 4428,
+        'OpSubgroupAnyKHR' : 4429,
+        'OpSubgroupAllEqualKHR' : 4430,
+        'OpSubgroupReadInvocationKHR' : 4432,
+        'OpGroupIAddNonUniformAMD' : 5000,
+        'OpGroupFAddNonUniformAMD' : 5001,
+        'OpGroupFMinNonUniformAMD' : 5002,
+        'OpGroupUMinNonUniformAMD' : 5003,
+        'OpGroupSMinNonUniformAMD' : 5004,
+        'OpGroupFMaxNonUniformAMD' : 5005,
+        'OpGroupUMaxNonUniformAMD' : 5006,
+        'OpGroupSMaxNonUniformAMD' : 5007,
+        'OpFragmentMaskFetchAMD' : 5011,
+        'OpFragmentFetchAMD' : 5012,
+        'OpSubgroupShuffleINTEL' : 5571,
+        'OpSubgroupShuffleDownINTEL' : 5572,
+        'OpSubgroupShuffleUpINTEL' : 5573,
+        'OpSubgroupShuffleXorINTEL' : 5574,
+        'OpSubgroupBlockReadINTEL' : 5575,
+        'OpSubgroupBlockWriteINTEL' : 5576,
+        'OpSubgroupImageBlockReadINTEL' : 5577,
+        'OpSubgroupImageBlockWriteINTEL' : 5578,
+        'OpDecorateStringGOOGLE' : 5632,
+        'OpMemberDecorateStringGOOGLE' : 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.1/GLSL.std.450.h

@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.1/OpenCL.std.h

@@ -0,0 +1,210 @@
+/*
+** Copyright (c) 2015-2017 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+namespace OpenCLLIB {
+
+enum Entrypoints {
+
+    // Section 2.1: Math extended instructions
+    Acos = 0,
+    Acosh = 1,
+    Acospi = 2,
+    Asin = 3,
+    Asinh = 4,
+    Asinpi = 5,
+    Atan = 6,
+    Atan2 = 7,
+    Atanh = 8,
+    Atanpi = 9,
+    Atan2pi = 10,
+    Cbrt = 11,
+    Ceil = 12,
+    Copysign = 13,
+    Cos = 14,
+    Cosh = 15,
+    Cospi = 16,
+    Erfc = 17,
+    Erf = 18,
+    Exp = 19,
+    Exp2 = 20,
+    Exp10 = 21,
+    Expm1 = 22,
+    Fabs = 23,
+    Fdim = 24,
+    Floor = 25,
+    Fma = 26,
+    Fmax = 27,
+    Fmin = 28,
+    Fmod = 29,
+    Fract = 30, 
+    Frexp = 31,
+    Hypot = 32,
+    Ilogb = 33,
+    Ldexp = 34,
+    Lgamma = 35,
+    Lgamma_r = 36,
+    Log = 37,
+    Log2 = 38,
+    Log10 = 39,
+    Log1p = 40,
+    Logb = 41,
+    Mad = 42,
+    Maxmag = 43,
+    Minmag = 44,
+    Modf = 45,
+    Nan = 46,
+    Nextafter = 47,
+    Pow = 48,
+    Pown = 49,
+    Powr = 50,
+    Remainder = 51,
+    Remquo = 52,
+    Rint = 53,
+    Rootn = 54,
+    Round = 55,
+    Rsqrt = 56,
+    Sin = 57,
+    Sincos = 58,
+    Sinh = 59,
+    Sinpi = 60,
+    Sqrt = 61,
+    Tan = 62,
+    Tanh = 63,
+    Tanpi = 64,
+    Tgamma = 65,
+    Trunc = 66,
+    Half_cos = 67,
+    Half_divide = 68,
+    Half_exp = 69,
+    Half_exp2 = 70,
+    Half_exp10 = 71,
+    Half_log = 72,
+    Half_log2 = 73,
+    Half_log10 = 74,
+    Half_powr = 75,
+    Half_recip = 76,
+    Half_rsqrt = 77,
+    Half_sin = 78,
+    Half_sqrt = 79,
+    Half_tan = 80,
+    Native_cos = 81,
+    Native_divide = 82,
+    Native_exp = 83,
+    Native_exp2 = 84,
+    Native_exp10 = 85,
+    Native_log = 86,
+    Native_log2 = 87,
+    Native_log10 = 88,
+    Native_powr = 89,
+    Native_recip = 90,
+    Native_rsqrt = 91,
+    Native_sin = 92,
+    Native_sqrt = 93,
+    Native_tan = 94,
+    
+    // Section 2.2: Integer instructions
+    SAbs = 141,
+    SAbs_diff = 142,
+    SAdd_sat = 143,
+    UAdd_sat = 144,
+    SHadd = 145,
+    UHadd = 146,
+    SRhadd = 147,
+    URhadd = 148,
+    SClamp = 149,
+    UClamp = 150, 
+    Clz = 151,
+    Ctz = 152,    
+    SMad_hi = 153,
+    UMad_sat = 154,
+    SMad_sat = 155,
+    SMax = 156,
+    UMax = 157,
+    SMin = 158,
+    UMin = 159,
+    SMul_hi = 160,
+    Rotate = 161,
+    SSub_sat = 162,
+    USub_sat = 163,
+    U_Upsample = 164,
+    S_Upsample = 165,
+    Popcount = 166,
+    SMad24 = 167,
+    UMad24 = 168,
+    SMul24 = 169,
+    UMul24 = 170,
+    UAbs = 201,
+    UAbs_diff = 202,
+    UMul_hi = 203,
+    UMad_hi = 204,
+
+    // Section 2.3: Common instructions
+    FClamp = 95,
+    Degrees = 96,
+    FMax_common = 97,
+    FMin_common = 98, 
+    Mix = 99,
+    Radians = 100,
+    Step = 101,
+    Smoothstep = 102,
+    Sign = 103,
+
+    // Section 2.4: Geometric instructions
+    Cross = 104,
+    Distance = 105, 
+    Length = 106,
+    Normalize = 107,
+    Fast_distance = 108,
+    Fast_length = 109,
+    Fast_normalize = 110,
+
+    // Section 2.5: Relational instructions
+    Bitselect = 186,
+    Select = 187,
+
+    // Section 2.6: Vector Data Load and Store instructions
+    Vloadn = 171,
+    Vstoren = 172,
+    Vload_half = 173,
+    Vload_halfn = 174,
+    Vstore_half = 175,
+    Vstore_half_r = 176,
+    Vstore_halfn = 177,
+    Vstore_halfn_r = 178,
+    Vloada_halfn = 179,
+    Vstorea_halfn = 180,
+    Vstorea_halfn_r = 181,
+
+    // Section 2.7: Miscellaneous Vector instructions
+    Shuffle = 182,
+    Shuffle2 = 183,
+
+    // Section 2.8: Misc instructions 
+    Printf = 184,
+    Prefetch = 185,
+};
+
+} // end namespace OpenCLLIB

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.1/extinst.glsl.std.450.grammar.json

@@ -0,0 +1,642 @@
+{
+  "copyright" : [
+    "Copyright (c) 2014-2016 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "Round",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "RoundEven",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Trunc",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FAbs",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SAbs",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FSign",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SSign",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Floor",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ceil",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fract",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Radians",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'degrees'" }
+      ]
+    },
+    {
+      "opname" : "Degrees",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'radians'" }
+      ]
+    },
+    {
+      "opname" : "Sin",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cos",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tan",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asin",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acos",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y_over_x'" }
+      ]
+    },
+    {
+      "opname" : "Sinh",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cosh",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tanh",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asinh",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acosh",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atanh",
+      "opcode" : 24,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan2",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Pow",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Exp",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Exp2",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log2",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Sqrt",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "InverseSqrt",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Determinant",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "MatrixInverse",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Modf",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'i'" }
+      ]
+    },
+    {
+      "opname" : "ModfStruct",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FMin",
+      "opcode" : 37,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMin",
+      "opcode" : 38,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMin",
+      "opcode" : 39,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FMax",
+      "opcode" : 40,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMax",
+      "opcode" : 41,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMax",
+      "opcode" : 42,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FClamp",
+      "opcode" : 43,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "UClamp",
+      "opcode" : 44,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "SClamp",
+      "opcode" : 45,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "FMix",
+      "opcode" : 46,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "IMix",
+      "opcode" : 47,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "Step",
+      "opcode" : 48,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SmoothStep",
+      "opcode" : 49,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge0'" },
+        { "kind" : "IdRef", "name" : "'edge1'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fma",
+      "opcode" : 50,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'a'" },
+        { "kind" : "IdRef", "name" : "'b'" },
+        { "kind" : "IdRef", "name" : "'c'" }
+      ]
+    },
+    {
+      "opname" : "Frexp",
+      "opcode" : 51,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "FrexpStruct",
+      "opcode" : 52,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ldexp",
+      "opcode" : 53,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm4x8",
+      "opcode" : 54,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm4x8",
+      "opcode" : 55,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm2x16",
+      "opcode" : 56,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm2x16",
+      "opcode" : 57,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackHalf2x16",
+      "opcode" : 58,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackDouble2x32",
+      "opcode" : 59,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "UnpackSnorm2x16",
+      "opcode" : 60,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm2x16",
+      "opcode" : 61,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackHalf2x16",
+      "opcode" : 62,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "UnpackSnorm4x8",
+      "opcode" : 63,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm4x8",
+      "opcode" : 64,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackDouble2x32",
+      "opcode" : 65,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "Length",
+      "opcode" : 66,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Distance",
+      "opcode" : 67,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p0'" },
+        { "kind" : "IdRef", "name" : "'p1'" }
+      ]
+    },
+    {
+      "opname" : "Cross",
+      "opcode" : 68,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Normalize",
+      "opcode" : 69,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FaceForward",
+      "opcode" : 70,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'Nref'" }
+      ]
+    },
+    {
+      "opname" : "Reflect",
+      "opcode" : 71,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" }
+      ]
+    },
+    {
+      "opname" : "Refract",
+      "opcode" : 72,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'eta'" }
+      ]
+    },
+    {
+      "opname" : "FindILsb",
+      "opcode" : 73,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindSMsb",
+      "opcode" : 74,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindUMsb",
+      "opcode" : 75,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "InterpolateAtCentroid",
+      "opcode" : 76,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtSample",
+      "opcode" : 77,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'sample'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtOffset",
+      "opcode" : 78,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'offset'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "NMin",
+      "opcode" : 79,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NMax",
+      "opcode" : 80,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NClamp",
+      "opcode" : 81,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.1/spirv.lua

@@ -0,0 +1,971 @@
+-- Copyright (c) 2014-2018 The Khronos Group Inc.
+-- 
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and/or associated documentation files (the "Materials"),
+-- to deal in the Materials without restriction, including without limitation
+-- the rights to use, copy, modify, merge, publish, distribute, sublicense,
+-- and/or sell copies of the Materials, and to permit persons to whom the
+-- Materials are furnished to do so, subject to the following conditions:
+-- 
+-- The above copyright notice and this permission notice shall be included in
+-- all copies or substantial portions of the Materials.
+-- 
+-- MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+-- STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+-- HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+-- 
+-- THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+-- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+-- THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-- FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+-- IN THE MATERIALS.
+
+-- This header is automatically generated by the same tool that creates
+-- the Binary Section of the SPIR-V specification.
+
+-- Enumeration tokens for SPIR-V, in various styles:
+--   C, C++, C++11, JSON, Lua, Python
+-- 
+-- - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+-- - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+-- - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+-- - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+-- - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+-- 
+-- Some tokens act like mask values, which can be OR'd together,
+-- while others are mutually exclusive.  The mask-like ones have
+-- "Mask" in their name, and a parallel enum that has the shift
+-- amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    MagicNumber = 0x07230203,
+    Version = 0x00010100,
+    Revision = 8,
+    OpCodeMask = 0xffff,
+    WordCountShift = 16,
+
+    SourceLanguage = {
+        Unknown = 0,
+        ESSL = 1,
+        GLSL = 2,
+        OpenCL_C = 3,
+        OpenCL_CPP = 4,
+        HLSL = 5,
+    },
+
+    ExecutionModel = {
+        Vertex = 0,
+        TessellationControl = 1,
+        TessellationEvaluation = 2,
+        Geometry = 3,
+        Fragment = 4,
+        GLCompute = 5,
+        Kernel = 6,
+    },
+
+    AddressingModel = {
+        Logical = 0,
+        Physical32 = 1,
+        Physical64 = 2,
+    },
+
+    MemoryModel = {
+        Simple = 0,
+        GLSL450 = 1,
+        OpenCL = 2,
+    },
+
+    ExecutionMode = {
+        Invocations = 0,
+        SpacingEqual = 1,
+        SpacingFractionalEven = 2,
+        SpacingFractionalOdd = 3,
+        VertexOrderCw = 4,
+        VertexOrderCcw = 5,
+        PixelCenterInteger = 6,
+        OriginUpperLeft = 7,
+        OriginLowerLeft = 8,
+        EarlyFragmentTests = 9,
+        PointMode = 10,
+        Xfb = 11,
+        DepthReplacing = 12,
+        DepthGreater = 14,
+        DepthLess = 15,
+        DepthUnchanged = 16,
+        LocalSize = 17,
+        LocalSizeHint = 18,
+        InputPoints = 19,
+        InputLines = 20,
+        InputLinesAdjacency = 21,
+        Triangles = 22,
+        InputTrianglesAdjacency = 23,
+        Quads = 24,
+        Isolines = 25,
+        OutputVertices = 26,
+        OutputPoints = 27,
+        OutputLineStrip = 28,
+        OutputTriangleStrip = 29,
+        VecTypeHint = 30,
+        ContractionOff = 31,
+        Initializer = 33,
+        Finalizer = 34,
+        SubgroupSize = 35,
+        SubgroupsPerWorkgroup = 36,
+        PostDepthCoverage = 4446,
+        StencilRefReplacingEXT = 5027,
+    },
+
+    StorageClass = {
+        UniformConstant = 0,
+        Input = 1,
+        Uniform = 2,
+        Output = 3,
+        Workgroup = 4,
+        CrossWorkgroup = 5,
+        Private = 6,
+        Function = 7,
+        Generic = 8,
+        PushConstant = 9,
+        AtomicCounter = 10,
+        Image = 11,
+        StorageBuffer = 12,
+    },
+
+    Dim = {
+        Dim1D = 0,
+        Dim2D = 1,
+        Dim3D = 2,
+        Cube = 3,
+        Rect = 4,
+        Buffer = 5,
+        SubpassData = 6,
+    },
+
+    SamplerAddressingMode = {
+        None = 0,
+        ClampToEdge = 1,
+        Clamp = 2,
+        Repeat = 3,
+        RepeatMirrored = 4,
+    },
+
+    SamplerFilterMode = {
+        Nearest = 0,
+        Linear = 1,
+    },
+
+    ImageFormat = {
+        Unknown = 0,
+        Rgba32f = 1,
+        Rgba16f = 2,
+        R32f = 3,
+        Rgba8 = 4,
+        Rgba8Snorm = 5,
+        Rg32f = 6,
+        Rg16f = 7,
+        R11fG11fB10f = 8,
+        R16f = 9,
+        Rgba16 = 10,
+        Rgb10A2 = 11,
+        Rg16 = 12,
+        Rg8 = 13,
+        R16 = 14,
+        R8 = 15,
+        Rgba16Snorm = 16,
+        Rg16Snorm = 17,
+        Rg8Snorm = 18,
+        R16Snorm = 19,
+        R8Snorm = 20,
+        Rgba32i = 21,
+        Rgba16i = 22,
+        Rgba8i = 23,
+        R32i = 24,
+        Rg32i = 25,
+        Rg16i = 26,
+        Rg8i = 27,
+        R16i = 28,
+        R8i = 29,
+        Rgba32ui = 30,
+        Rgba16ui = 31,
+        Rgba8ui = 32,
+        R32ui = 33,
+        Rgb10a2ui = 34,
+        Rg32ui = 35,
+        Rg16ui = 36,
+        Rg8ui = 37,
+        R16ui = 38,
+        R8ui = 39,
+    },
+
+    ImageChannelOrder = {
+        R = 0,
+        A = 1,
+        RG = 2,
+        RA = 3,
+        RGB = 4,
+        RGBA = 5,
+        BGRA = 6,
+        ARGB = 7,
+        Intensity = 8,
+        Luminance = 9,
+        Rx = 10,
+        RGx = 11,
+        RGBx = 12,
+        Depth = 13,
+        DepthStencil = 14,
+        sRGB = 15,
+        sRGBx = 16,
+        sRGBA = 17,
+        sBGRA = 18,
+        ABGR = 19,
+    },
+
+    ImageChannelDataType = {
+        SnormInt8 = 0,
+        SnormInt16 = 1,
+        UnormInt8 = 2,
+        UnormInt16 = 3,
+        UnormShort565 = 4,
+        UnormShort555 = 5,
+        UnormInt101010 = 6,
+        SignedInt8 = 7,
+        SignedInt16 = 8,
+        SignedInt32 = 9,
+        UnsignedInt8 = 10,
+        UnsignedInt16 = 11,
+        UnsignedInt32 = 12,
+        HalfFloat = 13,
+        Float = 14,
+        UnormInt24 = 15,
+        UnormInt101010_2 = 16,
+    },
+
+    ImageOperandsShift = {
+        Bias = 0,
+        Lod = 1,
+        Grad = 2,
+        ConstOffset = 3,
+        Offset = 4,
+        ConstOffsets = 5,
+        Sample = 6,
+        MinLod = 7,
+    },
+
+    ImageOperandsMask = {
+        MaskNone = 0,
+        Bias = 0x00000001,
+        Lod = 0x00000002,
+        Grad = 0x00000004,
+        ConstOffset = 0x00000008,
+        Offset = 0x00000010,
+        ConstOffsets = 0x00000020,
+        Sample = 0x00000040,
+        MinLod = 0x00000080,
+    },
+
+    FPFastMathModeShift = {
+        NotNaN = 0,
+        NotInf = 1,
+        NSZ = 2,
+        AllowRecip = 3,
+        Fast = 4,
+    },
+
+    FPFastMathModeMask = {
+        MaskNone = 0,
+        NotNaN = 0x00000001,
+        NotInf = 0x00000002,
+        NSZ = 0x00000004,
+        AllowRecip = 0x00000008,
+        Fast = 0x00000010,
+    },
+
+    FPRoundingMode = {
+        RTE = 0,
+        RTZ = 1,
+        RTP = 2,
+        RTN = 3,
+    },
+
+    LinkageType = {
+        Export = 0,
+        Import = 1,
+    },
+
+    AccessQualifier = {
+        ReadOnly = 0,
+        WriteOnly = 1,
+        ReadWrite = 2,
+    },
+
+    FunctionParameterAttribute = {
+        Zext = 0,
+        Sext = 1,
+        ByVal = 2,
+        Sret = 3,
+        NoAlias = 4,
+        NoCapture = 5,
+        NoWrite = 6,
+        NoReadWrite = 7,
+    },
+
+    Decoration = {
+        RelaxedPrecision = 0,
+        SpecId = 1,
+        Block = 2,
+        BufferBlock = 3,
+        RowMajor = 4,
+        ColMajor = 5,
+        ArrayStride = 6,
+        MatrixStride = 7,
+        GLSLShared = 8,
+        GLSLPacked = 9,
+        CPacked = 10,
+        BuiltIn = 11,
+        NoPerspective = 13,
+        Flat = 14,
+        Patch = 15,
+        Centroid = 16,
+        Sample = 17,
+        Invariant = 18,
+        Restrict = 19,
+        Aliased = 20,
+        Volatile = 21,
+        Constant = 22,
+        Coherent = 23,
+        NonWritable = 24,
+        NonReadable = 25,
+        Uniform = 26,
+        SaturatedConversion = 28,
+        Stream = 29,
+        Location = 30,
+        Component = 31,
+        Index = 32,
+        Binding = 33,
+        DescriptorSet = 34,
+        Offset = 35,
+        XfbBuffer = 36,
+        XfbStride = 37,
+        FuncParamAttr = 38,
+        FPRoundingMode = 39,
+        FPFastMathMode = 40,
+        LinkageAttributes = 41,
+        NoContraction = 42,
+        InputAttachmentIndex = 43,
+        Alignment = 44,
+        MaxByteOffset = 45,
+        ExplicitInterpAMD = 4999,
+        OverrideCoverageNV = 5248,
+        PassthroughNV = 5250,
+        ViewportRelativeNV = 5252,
+        SecondaryViewportRelativeNV = 5256,
+        HlslCounterBufferGOOGLE = 5634,
+        HlslSemanticGOOGLE = 5635,
+    },
+
+    BuiltIn = {
+        Position = 0,
+        PointSize = 1,
+        ClipDistance = 3,
+        CullDistance = 4,
+        VertexId = 5,
+        InstanceId = 6,
+        PrimitiveId = 7,
+        InvocationId = 8,
+        Layer = 9,
+        ViewportIndex = 10,
+        TessLevelOuter = 11,
+        TessLevelInner = 12,
+        TessCoord = 13,
+        PatchVertices = 14,
+        FragCoord = 15,
+        PointCoord = 16,
+        FrontFacing = 17,
+        SampleId = 18,
+        SamplePosition = 19,
+        SampleMask = 20,
+        FragDepth = 22,
+        HelperInvocation = 23,
+        NumWorkgroups = 24,
+        WorkgroupSize = 25,
+        WorkgroupId = 26,
+        LocalInvocationId = 27,
+        GlobalInvocationId = 28,
+        LocalInvocationIndex = 29,
+        WorkDim = 30,
+        GlobalSize = 31,
+        EnqueuedWorkgroupSize = 32,
+        GlobalOffset = 33,
+        GlobalLinearId = 34,
+        SubgroupSize = 36,
+        SubgroupMaxSize = 37,
+        NumSubgroups = 38,
+        NumEnqueuedSubgroups = 39,
+        SubgroupId = 40,
+        SubgroupLocalInvocationId = 41,
+        VertexIndex = 42,
+        InstanceIndex = 43,
+        SubgroupEqMaskKHR = 4416,
+        SubgroupGeMaskKHR = 4417,
+        SubgroupGtMaskKHR = 4418,
+        SubgroupLeMaskKHR = 4419,
+        SubgroupLtMaskKHR = 4420,
+        BaseVertex = 4424,
+        BaseInstance = 4425,
+        DrawIndex = 4426,
+        DeviceIndex = 4438,
+        ViewIndex = 4440,
+        BaryCoordNoPerspAMD = 4992,
+        BaryCoordNoPerspCentroidAMD = 4993,
+        BaryCoordNoPerspSampleAMD = 4994,
+        BaryCoordSmoothAMD = 4995,
+        BaryCoordSmoothCentroidAMD = 4996,
+        BaryCoordSmoothSampleAMD = 4997,
+        BaryCoordPullModelAMD = 4998,
+        FragStencilRefEXT = 5014,
+        ViewportMaskNV = 5253,
+        SecondaryPositionNV = 5257,
+        SecondaryViewportMaskNV = 5258,
+        PositionPerViewNV = 5261,
+        ViewportMaskPerViewNV = 5262,
+    },
+
+    SelectionControlShift = {
+        Flatten = 0,
+        DontFlatten = 1,
+    },
+
+    SelectionControlMask = {
+        MaskNone = 0,
+        Flatten = 0x00000001,
+        DontFlatten = 0x00000002,
+    },
+
+    LoopControlShift = {
+        Unroll = 0,
+        DontUnroll = 1,
+        DependencyInfinite = 2,
+        DependencyLength = 3,
+    },
+
+    LoopControlMask = {
+        MaskNone = 0,
+        Unroll = 0x00000001,
+        DontUnroll = 0x00000002,
+        DependencyInfinite = 0x00000004,
+        DependencyLength = 0x00000008,
+    },
+
+    FunctionControlShift = {
+        Inline = 0,
+        DontInline = 1,
+        Pure = 2,
+        Const = 3,
+    },
+
+    FunctionControlMask = {
+        MaskNone = 0,
+        Inline = 0x00000001,
+        DontInline = 0x00000002,
+        Pure = 0x00000004,
+        Const = 0x00000008,
+    },
+
+    MemorySemanticsShift = {
+        Acquire = 1,
+        Release = 2,
+        AcquireRelease = 3,
+        SequentiallyConsistent = 4,
+        UniformMemory = 6,
+        SubgroupMemory = 7,
+        WorkgroupMemory = 8,
+        CrossWorkgroupMemory = 9,
+        AtomicCounterMemory = 10,
+        ImageMemory = 11,
+    },
+
+    MemorySemanticsMask = {
+        MaskNone = 0,
+        Acquire = 0x00000002,
+        Release = 0x00000004,
+        AcquireRelease = 0x00000008,
+        SequentiallyConsistent = 0x00000010,
+        UniformMemory = 0x00000040,
+        SubgroupMemory = 0x00000080,
+        WorkgroupMemory = 0x00000100,
+        CrossWorkgroupMemory = 0x00000200,
+        AtomicCounterMemory = 0x00000400,
+        ImageMemory = 0x00000800,
+    },
+
+    MemoryAccessShift = {
+        Volatile = 0,
+        Aligned = 1,
+        Nontemporal = 2,
+    },
+
+    MemoryAccessMask = {
+        MaskNone = 0,
+        Volatile = 0x00000001,
+        Aligned = 0x00000002,
+        Nontemporal = 0x00000004,
+    },
+
+    Scope = {
+        CrossDevice = 0,
+        Device = 1,
+        Workgroup = 2,
+        Subgroup = 3,
+        Invocation = 4,
+    },
+
+    GroupOperation = {
+        Reduce = 0,
+        InclusiveScan = 1,
+        ExclusiveScan = 2,
+    },
+
+    KernelEnqueueFlags = {
+        NoWait = 0,
+        WaitKernel = 1,
+        WaitWorkGroup = 2,
+    },
+
+    KernelProfilingInfoShift = {
+        CmdExecTime = 0,
+    },
+
+    KernelProfilingInfoMask = {
+        MaskNone = 0,
+        CmdExecTime = 0x00000001,
+    },
+
+    Capability = {
+        Matrix = 0,
+        Shader = 1,
+        Geometry = 2,
+        Tessellation = 3,
+        Addresses = 4,
+        Linkage = 5,
+        Kernel = 6,
+        Vector16 = 7,
+        Float16Buffer = 8,
+        Float16 = 9,
+        Float64 = 10,
+        Int64 = 11,
+        Int64Atomics = 12,
+        ImageBasic = 13,
+        ImageReadWrite = 14,
+        ImageMipmap = 15,
+        Pipes = 17,
+        Groups = 18,
+        DeviceEnqueue = 19,
+        LiteralSampler = 20,
+        AtomicStorage = 21,
+        Int16 = 22,
+        TessellationPointSize = 23,
+        GeometryPointSize = 24,
+        ImageGatherExtended = 25,
+        StorageImageMultisample = 27,
+        UniformBufferArrayDynamicIndexing = 28,
+        SampledImageArrayDynamicIndexing = 29,
+        StorageBufferArrayDynamicIndexing = 30,
+        StorageImageArrayDynamicIndexing = 31,
+        ClipDistance = 32,
+        CullDistance = 33,
+        ImageCubeArray = 34,
+        SampleRateShading = 35,
+        ImageRect = 36,
+        SampledRect = 37,
+        GenericPointer = 38,
+        Int8 = 39,
+        InputAttachment = 40,
+        SparseResidency = 41,
+        MinLod = 42,
+        Sampled1D = 43,
+        Image1D = 44,
+        SampledCubeArray = 45,
+        SampledBuffer = 46,
+        ImageBuffer = 47,
+        ImageMSArray = 48,
+        StorageImageExtendedFormats = 49,
+        ImageQuery = 50,
+        DerivativeControl = 51,
+        InterpolationFunction = 52,
+        TransformFeedback = 53,
+        GeometryStreams = 54,
+        StorageImageReadWithoutFormat = 55,
+        StorageImageWriteWithoutFormat = 56,
+        MultiViewport = 57,
+        SubgroupDispatch = 58,
+        NamedBarrier = 59,
+        PipeStorage = 60,
+        SubgroupBallotKHR = 4423,
+        DrawParameters = 4427,
+        SubgroupVoteKHR = 4431,
+        StorageBuffer16BitAccess = 4433,
+        StorageUniformBufferBlock16 = 4433,
+        StorageUniform16 = 4434,
+        UniformAndStorageBuffer16BitAccess = 4434,
+        StoragePushConstant16 = 4435,
+        StorageInputOutput16 = 4436,
+        DeviceGroup = 4437,
+        MultiView = 4439,
+        VariablePointersStorageBuffer = 4441,
+        VariablePointers = 4442,
+        AtomicStorageOps = 4445,
+        SampleMaskPostDepthCoverage = 4447,
+        ImageGatherBiasLodAMD = 5009,
+        FragmentMaskAMD = 5010,
+        StencilExportEXT = 5013,
+        ImageReadWriteLodAMD = 5015,
+        SampleMaskOverrideCoverageNV = 5249,
+        GeometryShaderPassthroughNV = 5251,
+        ShaderViewportIndexLayerEXT = 5254,
+        ShaderViewportIndexLayerNV = 5254,
+        ShaderViewportMaskNV = 5255,
+        ShaderStereoViewNV = 5259,
+        PerViewAttributesNV = 5260,
+        SubgroupShuffleINTEL = 5568,
+        SubgroupBufferBlockIOINTEL = 5569,
+        SubgroupImageBlockIOINTEL = 5570,
+    },
+
+    Op = {
+        OpNop = 0,
+        OpUndef = 1,
+        OpSourceContinued = 2,
+        OpSource = 3,
+        OpSourceExtension = 4,
+        OpName = 5,
+        OpMemberName = 6,
+        OpString = 7,
+        OpLine = 8,
+        OpExtension = 10,
+        OpExtInstImport = 11,
+        OpExtInst = 12,
+        OpMemoryModel = 14,
+        OpEntryPoint = 15,
+        OpExecutionMode = 16,
+        OpCapability = 17,
+        OpTypeVoid = 19,
+        OpTypeBool = 20,
+        OpTypeInt = 21,
+        OpTypeFloat = 22,
+        OpTypeVector = 23,
+        OpTypeMatrix = 24,
+        OpTypeImage = 25,
+        OpTypeSampler = 26,
+        OpTypeSampledImage = 27,
+        OpTypeArray = 28,
+        OpTypeRuntimeArray = 29,
+        OpTypeStruct = 30,
+        OpTypeOpaque = 31,
+        OpTypePointer = 32,
+        OpTypeFunction = 33,
+        OpTypeEvent = 34,
+        OpTypeDeviceEvent = 35,
+        OpTypeReserveId = 36,
+        OpTypeQueue = 37,
+        OpTypePipe = 38,
+        OpTypeForwardPointer = 39,
+        OpConstantTrue = 41,
+        OpConstantFalse = 42,
+        OpConstant = 43,
+        OpConstantComposite = 44,
+        OpConstantSampler = 45,
+        OpConstantNull = 46,
+        OpSpecConstantTrue = 48,
+        OpSpecConstantFalse = 49,
+        OpSpecConstant = 50,
+        OpSpecConstantComposite = 51,
+        OpSpecConstantOp = 52,
+        OpFunction = 54,
+        OpFunctionParameter = 55,
+        OpFunctionEnd = 56,
+        OpFunctionCall = 57,
+        OpVariable = 59,
+        OpImageTexelPointer = 60,
+        OpLoad = 61,
+        OpStore = 62,
+        OpCopyMemory = 63,
+        OpCopyMemorySized = 64,
+        OpAccessChain = 65,
+        OpInBoundsAccessChain = 66,
+        OpPtrAccessChain = 67,
+        OpArrayLength = 68,
+        OpGenericPtrMemSemantics = 69,
+        OpInBoundsPtrAccessChain = 70,
+        OpDecorate = 71,
+        OpMemberDecorate = 72,
+        OpDecorationGroup = 73,
+        OpGroupDecorate = 74,
+        OpGroupMemberDecorate = 75,
+        OpVectorExtractDynamic = 77,
+        OpVectorInsertDynamic = 78,
+        OpVectorShuffle = 79,
+        OpCompositeConstruct = 80,
+        OpCompositeExtract = 81,
+        OpCompositeInsert = 82,
+        OpCopyObject = 83,
+        OpTranspose = 84,
+        OpSampledImage = 86,
+        OpImageSampleImplicitLod = 87,
+        OpImageSampleExplicitLod = 88,
+        OpImageSampleDrefImplicitLod = 89,
+        OpImageSampleDrefExplicitLod = 90,
+        OpImageSampleProjImplicitLod = 91,
+        OpImageSampleProjExplicitLod = 92,
+        OpImageSampleProjDrefImplicitLod = 93,
+        OpImageSampleProjDrefExplicitLod = 94,
+        OpImageFetch = 95,
+        OpImageGather = 96,
+        OpImageDrefGather = 97,
+        OpImageRead = 98,
+        OpImageWrite = 99,
+        OpImage = 100,
+        OpImageQueryFormat = 101,
+        OpImageQueryOrder = 102,
+        OpImageQuerySizeLod = 103,
+        OpImageQuerySize = 104,
+        OpImageQueryLod = 105,
+        OpImageQueryLevels = 106,
+        OpImageQuerySamples = 107,
+        OpConvertFToU = 109,
+        OpConvertFToS = 110,
+        OpConvertSToF = 111,
+        OpConvertUToF = 112,
+        OpUConvert = 113,
+        OpSConvert = 114,
+        OpFConvert = 115,
+        OpQuantizeToF16 = 116,
+        OpConvertPtrToU = 117,
+        OpSatConvertSToU = 118,
+        OpSatConvertUToS = 119,
+        OpConvertUToPtr = 120,
+        OpPtrCastToGeneric = 121,
+        OpGenericCastToPtr = 122,
+        OpGenericCastToPtrExplicit = 123,
+        OpBitcast = 124,
+        OpSNegate = 126,
+        OpFNegate = 127,
+        OpIAdd = 128,
+        OpFAdd = 129,
+        OpISub = 130,
+        OpFSub = 131,
+        OpIMul = 132,
+        OpFMul = 133,
+        OpUDiv = 134,
+        OpSDiv = 135,
+        OpFDiv = 136,
+        OpUMod = 137,
+        OpSRem = 138,
+        OpSMod = 139,
+        OpFRem = 140,
+        OpFMod = 141,
+        OpVectorTimesScalar = 142,
+        OpMatrixTimesScalar = 143,
+        OpVectorTimesMatrix = 144,
+        OpMatrixTimesVector = 145,
+        OpMatrixTimesMatrix = 146,
+        OpOuterProduct = 147,
+        OpDot = 148,
+        OpIAddCarry = 149,
+        OpISubBorrow = 150,
+        OpUMulExtended = 151,
+        OpSMulExtended = 152,
+        OpAny = 154,
+        OpAll = 155,
+        OpIsNan = 156,
+        OpIsInf = 157,
+        OpIsFinite = 158,
+        OpIsNormal = 159,
+        OpSignBitSet = 160,
+        OpLessOrGreater = 161,
+        OpOrdered = 162,
+        OpUnordered = 163,
+        OpLogicalEqual = 164,
+        OpLogicalNotEqual = 165,
+        OpLogicalOr = 166,
+        OpLogicalAnd = 167,
+        OpLogicalNot = 168,
+        OpSelect = 169,
+        OpIEqual = 170,
+        OpINotEqual = 171,
+        OpUGreaterThan = 172,
+        OpSGreaterThan = 173,
+        OpUGreaterThanEqual = 174,
+        OpSGreaterThanEqual = 175,
+        OpULessThan = 176,
+        OpSLessThan = 177,
+        OpULessThanEqual = 178,
+        OpSLessThanEqual = 179,
+        OpFOrdEqual = 180,
+        OpFUnordEqual = 181,
+        OpFOrdNotEqual = 182,
+        OpFUnordNotEqual = 183,
+        OpFOrdLessThan = 184,
+        OpFUnordLessThan = 185,
+        OpFOrdGreaterThan = 186,
+        OpFUnordGreaterThan = 187,
+        OpFOrdLessThanEqual = 188,
+        OpFUnordLessThanEqual = 189,
+        OpFOrdGreaterThanEqual = 190,
+        OpFUnordGreaterThanEqual = 191,
+        OpShiftRightLogical = 194,
+        OpShiftRightArithmetic = 195,
+        OpShiftLeftLogical = 196,
+        OpBitwiseOr = 197,
+        OpBitwiseXor = 198,
+        OpBitwiseAnd = 199,
+        OpNot = 200,
+        OpBitFieldInsert = 201,
+        OpBitFieldSExtract = 202,
+        OpBitFieldUExtract = 203,
+        OpBitReverse = 204,
+        OpBitCount = 205,
+        OpDPdx = 207,
+        OpDPdy = 208,
+        OpFwidth = 209,
+        OpDPdxFine = 210,
+        OpDPdyFine = 211,
+        OpFwidthFine = 212,
+        OpDPdxCoarse = 213,
+        OpDPdyCoarse = 214,
+        OpFwidthCoarse = 215,
+        OpEmitVertex = 218,
+        OpEndPrimitive = 219,
+        OpEmitStreamVertex = 220,
+        OpEndStreamPrimitive = 221,
+        OpControlBarrier = 224,
+        OpMemoryBarrier = 225,
+        OpAtomicLoad = 227,
+        OpAtomicStore = 228,
+        OpAtomicExchange = 229,
+        OpAtomicCompareExchange = 230,
+        OpAtomicCompareExchangeWeak = 231,
+        OpAtomicIIncrement = 232,
+        OpAtomicIDecrement = 233,
+        OpAtomicIAdd = 234,
+        OpAtomicISub = 235,
+        OpAtomicSMin = 236,
+        OpAtomicUMin = 237,
+        OpAtomicSMax = 238,
+        OpAtomicUMax = 239,
+        OpAtomicAnd = 240,
+        OpAtomicOr = 241,
+        OpAtomicXor = 242,
+        OpPhi = 245,
+        OpLoopMerge = 246,
+        OpSelectionMerge = 247,
+        OpLabel = 248,
+        OpBranch = 249,
+        OpBranchConditional = 250,
+        OpSwitch = 251,
+        OpKill = 252,
+        OpReturn = 253,
+        OpReturnValue = 254,
+        OpUnreachable = 255,
+        OpLifetimeStart = 256,
+        OpLifetimeStop = 257,
+        OpGroupAsyncCopy = 259,
+        OpGroupWaitEvents = 260,
+        OpGroupAll = 261,
+        OpGroupAny = 262,
+        OpGroupBroadcast = 263,
+        OpGroupIAdd = 264,
+        OpGroupFAdd = 265,
+        OpGroupFMin = 266,
+        OpGroupUMin = 267,
+        OpGroupSMin = 268,
+        OpGroupFMax = 269,
+        OpGroupUMax = 270,
+        OpGroupSMax = 271,
+        OpReadPipe = 274,
+        OpWritePipe = 275,
+        OpReservedReadPipe = 276,
+        OpReservedWritePipe = 277,
+        OpReserveReadPipePackets = 278,
+        OpReserveWritePipePackets = 279,
+        OpCommitReadPipe = 280,
+        OpCommitWritePipe = 281,
+        OpIsValidReserveId = 282,
+        OpGetNumPipePackets = 283,
+        OpGetMaxPipePackets = 284,
+        OpGroupReserveReadPipePackets = 285,
+        OpGroupReserveWritePipePackets = 286,
+        OpGroupCommitReadPipe = 287,
+        OpGroupCommitWritePipe = 288,
+        OpEnqueueMarker = 291,
+        OpEnqueueKernel = 292,
+        OpGetKernelNDrangeSubGroupCount = 293,
+        OpGetKernelNDrangeMaxSubGroupSize = 294,
+        OpGetKernelWorkGroupSize = 295,
+        OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+        OpRetainEvent = 297,
+        OpReleaseEvent = 298,
+        OpCreateUserEvent = 299,
+        OpIsValidEvent = 300,
+        OpSetUserEventStatus = 301,
+        OpCaptureEventProfilingInfo = 302,
+        OpGetDefaultQueue = 303,
+        OpBuildNDRange = 304,
+        OpImageSparseSampleImplicitLod = 305,
+        OpImageSparseSampleExplicitLod = 306,
+        OpImageSparseSampleDrefImplicitLod = 307,
+        OpImageSparseSampleDrefExplicitLod = 308,
+        OpImageSparseSampleProjImplicitLod = 309,
+        OpImageSparseSampleProjExplicitLod = 310,
+        OpImageSparseSampleProjDrefImplicitLod = 311,
+        OpImageSparseSampleProjDrefExplicitLod = 312,
+        OpImageSparseFetch = 313,
+        OpImageSparseGather = 314,
+        OpImageSparseDrefGather = 315,
+        OpImageSparseTexelsResident = 316,
+        OpNoLine = 317,
+        OpAtomicFlagTestAndSet = 318,
+        OpAtomicFlagClear = 319,
+        OpImageSparseRead = 320,
+        OpSizeOf = 321,
+        OpTypePipeStorage = 322,
+        OpConstantPipeStorage = 323,
+        OpCreatePipeFromPipeStorage = 324,
+        OpGetKernelLocalSizeForSubgroupCount = 325,
+        OpGetKernelMaxNumSubgroups = 326,
+        OpTypeNamedBarrier = 327,
+        OpNamedBarrierInitialize = 328,
+        OpMemoryNamedBarrier = 329,
+        OpModuleProcessed = 330,
+        OpDecorateId = 332,
+        OpSubgroupBallotKHR = 4421,
+        OpSubgroupFirstInvocationKHR = 4422,
+        OpSubgroupAllKHR = 4428,
+        OpSubgroupAnyKHR = 4429,
+        OpSubgroupAllEqualKHR = 4430,
+        OpSubgroupReadInvocationKHR = 4432,
+        OpGroupIAddNonUniformAMD = 5000,
+        OpGroupFAddNonUniformAMD = 5001,
+        OpGroupFMinNonUniformAMD = 5002,
+        OpGroupUMinNonUniformAMD = 5003,
+        OpGroupSMinNonUniformAMD = 5004,
+        OpGroupFMaxNonUniformAMD = 5005,
+        OpGroupUMaxNonUniformAMD = 5006,
+        OpGroupSMaxNonUniformAMD = 5007,
+        OpFragmentMaskFetchAMD = 5011,
+        OpFragmentFetchAMD = 5012,
+        OpSubgroupShuffleINTEL = 5571,
+        OpSubgroupShuffleDownINTEL = 5572,
+        OpSubgroupShuffleUpINTEL = 5573,
+        OpSubgroupShuffleXorINTEL = 5574,
+        OpSubgroupBlockReadINTEL = 5575,
+        OpSubgroupBlockWriteINTEL = 5576,
+        OpSubgroupImageBlockReadINTEL = 5577,
+        OpSubgroupImageBlockWriteINTEL = 5578,
+        OpDecorateStringGOOGLE = 5632,
+        OpMemberDecorateStringGOOGLE = 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.1/spirv.py

@@ -0,0 +1,971 @@
+# Copyright (c) 2014-2018 The Khronos Group Inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and/or associated documentation files (the "Materials"),
+# to deal in the Materials without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Materials, and to permit persons to whom the
+# Materials are furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Materials.
+# 
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+# STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+# HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+# 
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+# IN THE MATERIALS.
+
+# This header is automatically generated by the same tool that creates
+# the Binary Section of the SPIR-V specification.
+
+# Enumeration tokens for SPIR-V, in various styles:
+#   C, C++, C++11, JSON, Lua, Python
+# 
+# - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+# - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+# - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+# - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+# - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+# 
+# Some tokens act like mask values, which can be OR'd together,
+# while others are mutually exclusive.  The mask-like ones have
+# "Mask" in their name, and a parallel enum that has the shift
+# amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    'MagicNumber' : 0x07230203,
+    'Version' : 0x00010100,
+    'Revision' : 8,
+    'OpCodeMask' : 0xffff,
+    'WordCountShift' : 16,
+
+    'SourceLanguage' : {
+        'Unknown' : 0,
+        'ESSL' : 1,
+        'GLSL' : 2,
+        'OpenCL_C' : 3,
+        'OpenCL_CPP' : 4,
+        'HLSL' : 5,
+    },
+
+    'ExecutionModel' : {
+        'Vertex' : 0,
+        'TessellationControl' : 1,
+        'TessellationEvaluation' : 2,
+        'Geometry' : 3,
+        'Fragment' : 4,
+        'GLCompute' : 5,
+        'Kernel' : 6,
+    },
+
+    'AddressingModel' : {
+        'Logical' : 0,
+        'Physical32' : 1,
+        'Physical64' : 2,
+    },
+
+    'MemoryModel' : {
+        'Simple' : 0,
+        'GLSL450' : 1,
+        'OpenCL' : 2,
+    },
+
+    'ExecutionMode' : {
+        'Invocations' : 0,
+        'SpacingEqual' : 1,
+        'SpacingFractionalEven' : 2,
+        'SpacingFractionalOdd' : 3,
+        'VertexOrderCw' : 4,
+        'VertexOrderCcw' : 5,
+        'PixelCenterInteger' : 6,
+        'OriginUpperLeft' : 7,
+        'OriginLowerLeft' : 8,
+        'EarlyFragmentTests' : 9,
+        'PointMode' : 10,
+        'Xfb' : 11,
+        'DepthReplacing' : 12,
+        'DepthGreater' : 14,
+        'DepthLess' : 15,
+        'DepthUnchanged' : 16,
+        'LocalSize' : 17,
+        'LocalSizeHint' : 18,
+        'InputPoints' : 19,
+        'InputLines' : 20,
+        'InputLinesAdjacency' : 21,
+        'Triangles' : 22,
+        'InputTrianglesAdjacency' : 23,
+        'Quads' : 24,
+        'Isolines' : 25,
+        'OutputVertices' : 26,
+        'OutputPoints' : 27,
+        'OutputLineStrip' : 28,
+        'OutputTriangleStrip' : 29,
+        'VecTypeHint' : 30,
+        'ContractionOff' : 31,
+        'Initializer' : 33,
+        'Finalizer' : 34,
+        'SubgroupSize' : 35,
+        'SubgroupsPerWorkgroup' : 36,
+        'PostDepthCoverage' : 4446,
+        'StencilRefReplacingEXT' : 5027,
+    },
+
+    'StorageClass' : {
+        'UniformConstant' : 0,
+        'Input' : 1,
+        'Uniform' : 2,
+        'Output' : 3,
+        'Workgroup' : 4,
+        'CrossWorkgroup' : 5,
+        'Private' : 6,
+        'Function' : 7,
+        'Generic' : 8,
+        'PushConstant' : 9,
+        'AtomicCounter' : 10,
+        'Image' : 11,
+        'StorageBuffer' : 12,
+    },
+
+    'Dim' : {
+        'Dim1D' : 0,
+        'Dim2D' : 1,
+        'Dim3D' : 2,
+        'Cube' : 3,
+        'Rect' : 4,
+        'Buffer' : 5,
+        'SubpassData' : 6,
+    },
+
+    'SamplerAddressingMode' : {
+        'None' : 0,
+        'ClampToEdge' : 1,
+        'Clamp' : 2,
+        'Repeat' : 3,
+        'RepeatMirrored' : 4,
+    },
+
+    'SamplerFilterMode' : {
+        'Nearest' : 0,
+        'Linear' : 1,
+    },
+
+    'ImageFormat' : {
+        'Unknown' : 0,
+        'Rgba32f' : 1,
+        'Rgba16f' : 2,
+        'R32f' : 3,
+        'Rgba8' : 4,
+        'Rgba8Snorm' : 5,
+        'Rg32f' : 6,
+        'Rg16f' : 7,
+        'R11fG11fB10f' : 8,
+        'R16f' : 9,
+        'Rgba16' : 10,
+        'Rgb10A2' : 11,
+        'Rg16' : 12,
+        'Rg8' : 13,
+        'R16' : 14,
+        'R8' : 15,
+        'Rgba16Snorm' : 16,
+        'Rg16Snorm' : 17,
+        'Rg8Snorm' : 18,
+        'R16Snorm' : 19,
+        'R8Snorm' : 20,
+        'Rgba32i' : 21,
+        'Rgba16i' : 22,
+        'Rgba8i' : 23,
+        'R32i' : 24,
+        'Rg32i' : 25,
+        'Rg16i' : 26,
+        'Rg8i' : 27,
+        'R16i' : 28,
+        'R8i' : 29,
+        'Rgba32ui' : 30,
+        'Rgba16ui' : 31,
+        'Rgba8ui' : 32,
+        'R32ui' : 33,
+        'Rgb10a2ui' : 34,
+        'Rg32ui' : 35,
+        'Rg16ui' : 36,
+        'Rg8ui' : 37,
+        'R16ui' : 38,
+        'R8ui' : 39,
+    },
+
+    'ImageChannelOrder' : {
+        'R' : 0,
+        'A' : 1,
+        'RG' : 2,
+        'RA' : 3,
+        'RGB' : 4,
+        'RGBA' : 5,
+        'BGRA' : 6,
+        'ARGB' : 7,
+        'Intensity' : 8,
+        'Luminance' : 9,
+        'Rx' : 10,
+        'RGx' : 11,
+        'RGBx' : 12,
+        'Depth' : 13,
+        'DepthStencil' : 14,
+        'sRGB' : 15,
+        'sRGBx' : 16,
+        'sRGBA' : 17,
+        'sBGRA' : 18,
+        'ABGR' : 19,
+    },
+
+    'ImageChannelDataType' : {
+        'SnormInt8' : 0,
+        'SnormInt16' : 1,
+        'UnormInt8' : 2,
+        'UnormInt16' : 3,
+        'UnormShort565' : 4,
+        'UnormShort555' : 5,
+        'UnormInt101010' : 6,
+        'SignedInt8' : 7,
+        'SignedInt16' : 8,
+        'SignedInt32' : 9,
+        'UnsignedInt8' : 10,
+        'UnsignedInt16' : 11,
+        'UnsignedInt32' : 12,
+        'HalfFloat' : 13,
+        'Float' : 14,
+        'UnormInt24' : 15,
+        'UnormInt101010_2' : 16,
+    },
+
+    'ImageOperandsShift' : {
+        'Bias' : 0,
+        'Lod' : 1,
+        'Grad' : 2,
+        'ConstOffset' : 3,
+        'Offset' : 4,
+        'ConstOffsets' : 5,
+        'Sample' : 6,
+        'MinLod' : 7,
+    },
+
+    'ImageOperandsMask' : {
+        'MaskNone' : 0,
+        'Bias' : 0x00000001,
+        'Lod' : 0x00000002,
+        'Grad' : 0x00000004,
+        'ConstOffset' : 0x00000008,
+        'Offset' : 0x00000010,
+        'ConstOffsets' : 0x00000020,
+        'Sample' : 0x00000040,
+        'MinLod' : 0x00000080,
+    },
+
+    'FPFastMathModeShift' : {
+        'NotNaN' : 0,
+        'NotInf' : 1,
+        'NSZ' : 2,
+        'AllowRecip' : 3,
+        'Fast' : 4,
+    },
+
+    'FPFastMathModeMask' : {
+        'MaskNone' : 0,
+        'NotNaN' : 0x00000001,
+        'NotInf' : 0x00000002,
+        'NSZ' : 0x00000004,
+        'AllowRecip' : 0x00000008,
+        'Fast' : 0x00000010,
+    },
+
+    'FPRoundingMode' : {
+        'RTE' : 0,
+        'RTZ' : 1,
+        'RTP' : 2,
+        'RTN' : 3,
+    },
+
+    'LinkageType' : {
+        'Export' : 0,
+        'Import' : 1,
+    },
+
+    'AccessQualifier' : {
+        'ReadOnly' : 0,
+        'WriteOnly' : 1,
+        'ReadWrite' : 2,
+    },
+
+    'FunctionParameterAttribute' : {
+        'Zext' : 0,
+        'Sext' : 1,
+        'ByVal' : 2,
+        'Sret' : 3,
+        'NoAlias' : 4,
+        'NoCapture' : 5,
+        'NoWrite' : 6,
+        'NoReadWrite' : 7,
+    },
+
+    'Decoration' : {
+        'RelaxedPrecision' : 0,
+        'SpecId' : 1,
+        'Block' : 2,
+        'BufferBlock' : 3,
+        'RowMajor' : 4,
+        'ColMajor' : 5,
+        'ArrayStride' : 6,
+        'MatrixStride' : 7,
+        'GLSLShared' : 8,
+        'GLSLPacked' : 9,
+        'CPacked' : 10,
+        'BuiltIn' : 11,
+        'NoPerspective' : 13,
+        'Flat' : 14,
+        'Patch' : 15,
+        'Centroid' : 16,
+        'Sample' : 17,
+        'Invariant' : 18,
+        'Restrict' : 19,
+        'Aliased' : 20,
+        'Volatile' : 21,
+        'Constant' : 22,
+        'Coherent' : 23,
+        'NonWritable' : 24,
+        'NonReadable' : 25,
+        'Uniform' : 26,
+        'SaturatedConversion' : 28,
+        'Stream' : 29,
+        'Location' : 30,
+        'Component' : 31,
+        'Index' : 32,
+        'Binding' : 33,
+        'DescriptorSet' : 34,
+        'Offset' : 35,
+        'XfbBuffer' : 36,
+        'XfbStride' : 37,
+        'FuncParamAttr' : 38,
+        'FPRoundingMode' : 39,
+        'FPFastMathMode' : 40,
+        'LinkageAttributes' : 41,
+        'NoContraction' : 42,
+        'InputAttachmentIndex' : 43,
+        'Alignment' : 44,
+        'MaxByteOffset' : 45,
+        'ExplicitInterpAMD' : 4999,
+        'OverrideCoverageNV' : 5248,
+        'PassthroughNV' : 5250,
+        'ViewportRelativeNV' : 5252,
+        'SecondaryViewportRelativeNV' : 5256,
+        'HlslCounterBufferGOOGLE' : 5634,
+        'HlslSemanticGOOGLE' : 5635,
+    },
+
+    'BuiltIn' : {
+        'Position' : 0,
+        'PointSize' : 1,
+        'ClipDistance' : 3,
+        'CullDistance' : 4,
+        'VertexId' : 5,
+        'InstanceId' : 6,
+        'PrimitiveId' : 7,
+        'InvocationId' : 8,
+        'Layer' : 9,
+        'ViewportIndex' : 10,
+        'TessLevelOuter' : 11,
+        'TessLevelInner' : 12,
+        'TessCoord' : 13,
+        'PatchVertices' : 14,
+        'FragCoord' : 15,
+        'PointCoord' : 16,
+        'FrontFacing' : 17,
+        'SampleId' : 18,
+        'SamplePosition' : 19,
+        'SampleMask' : 20,
+        'FragDepth' : 22,
+        'HelperInvocation' : 23,
+        'NumWorkgroups' : 24,
+        'WorkgroupSize' : 25,
+        'WorkgroupId' : 26,
+        'LocalInvocationId' : 27,
+        'GlobalInvocationId' : 28,
+        'LocalInvocationIndex' : 29,
+        'WorkDim' : 30,
+        'GlobalSize' : 31,
+        'EnqueuedWorkgroupSize' : 32,
+        'GlobalOffset' : 33,
+        'GlobalLinearId' : 34,
+        'SubgroupSize' : 36,
+        'SubgroupMaxSize' : 37,
+        'NumSubgroups' : 38,
+        'NumEnqueuedSubgroups' : 39,
+        'SubgroupId' : 40,
+        'SubgroupLocalInvocationId' : 41,
+        'VertexIndex' : 42,
+        'InstanceIndex' : 43,
+        'SubgroupEqMaskKHR' : 4416,
+        'SubgroupGeMaskKHR' : 4417,
+        'SubgroupGtMaskKHR' : 4418,
+        'SubgroupLeMaskKHR' : 4419,
+        'SubgroupLtMaskKHR' : 4420,
+        'BaseVertex' : 4424,
+        'BaseInstance' : 4425,
+        'DrawIndex' : 4426,
+        'DeviceIndex' : 4438,
+        'ViewIndex' : 4440,
+        'BaryCoordNoPerspAMD' : 4992,
+        'BaryCoordNoPerspCentroidAMD' : 4993,
+        'BaryCoordNoPerspSampleAMD' : 4994,
+        'BaryCoordSmoothAMD' : 4995,
+        'BaryCoordSmoothCentroidAMD' : 4996,
+        'BaryCoordSmoothSampleAMD' : 4997,
+        'BaryCoordPullModelAMD' : 4998,
+        'FragStencilRefEXT' : 5014,
+        'ViewportMaskNV' : 5253,
+        'SecondaryPositionNV' : 5257,
+        'SecondaryViewportMaskNV' : 5258,
+        'PositionPerViewNV' : 5261,
+        'ViewportMaskPerViewNV' : 5262,
+    },
+
+    'SelectionControlShift' : {
+        'Flatten' : 0,
+        'DontFlatten' : 1,
+    },
+
+    'SelectionControlMask' : {
+        'MaskNone' : 0,
+        'Flatten' : 0x00000001,
+        'DontFlatten' : 0x00000002,
+    },
+
+    'LoopControlShift' : {
+        'Unroll' : 0,
+        'DontUnroll' : 1,
+        'DependencyInfinite' : 2,
+        'DependencyLength' : 3,
+    },
+
+    'LoopControlMask' : {
+        'MaskNone' : 0,
+        'Unroll' : 0x00000001,
+        'DontUnroll' : 0x00000002,
+        'DependencyInfinite' : 0x00000004,
+        'DependencyLength' : 0x00000008,
+    },
+
+    'FunctionControlShift' : {
+        'Inline' : 0,
+        'DontInline' : 1,
+        'Pure' : 2,
+        'Const' : 3,
+    },
+
+    'FunctionControlMask' : {
+        'MaskNone' : 0,
+        'Inline' : 0x00000001,
+        'DontInline' : 0x00000002,
+        'Pure' : 0x00000004,
+        'Const' : 0x00000008,
+    },
+
+    'MemorySemanticsShift' : {
+        'Acquire' : 1,
+        'Release' : 2,
+        'AcquireRelease' : 3,
+        'SequentiallyConsistent' : 4,
+        'UniformMemory' : 6,
+        'SubgroupMemory' : 7,
+        'WorkgroupMemory' : 8,
+        'CrossWorkgroupMemory' : 9,
+        'AtomicCounterMemory' : 10,
+        'ImageMemory' : 11,
+    },
+
+    'MemorySemanticsMask' : {
+        'MaskNone' : 0,
+        'Acquire' : 0x00000002,
+        'Release' : 0x00000004,
+        'AcquireRelease' : 0x00000008,
+        'SequentiallyConsistent' : 0x00000010,
+        'UniformMemory' : 0x00000040,
+        'SubgroupMemory' : 0x00000080,
+        'WorkgroupMemory' : 0x00000100,
+        'CrossWorkgroupMemory' : 0x00000200,
+        'AtomicCounterMemory' : 0x00000400,
+        'ImageMemory' : 0x00000800,
+    },
+
+    'MemoryAccessShift' : {
+        'Volatile' : 0,
+        'Aligned' : 1,
+        'Nontemporal' : 2,
+    },
+
+    'MemoryAccessMask' : {
+        'MaskNone' : 0,
+        'Volatile' : 0x00000001,
+        'Aligned' : 0x00000002,
+        'Nontemporal' : 0x00000004,
+    },
+
+    'Scope' : {
+        'CrossDevice' : 0,
+        'Device' : 1,
+        'Workgroup' : 2,
+        'Subgroup' : 3,
+        'Invocation' : 4,
+    },
+
+    'GroupOperation' : {
+        'Reduce' : 0,
+        'InclusiveScan' : 1,
+        'ExclusiveScan' : 2,
+    },
+
+    'KernelEnqueueFlags' : {
+        'NoWait' : 0,
+        'WaitKernel' : 1,
+        'WaitWorkGroup' : 2,
+    },
+
+    'KernelProfilingInfoShift' : {
+        'CmdExecTime' : 0,
+    },
+
+    'KernelProfilingInfoMask' : {
+        'MaskNone' : 0,
+        'CmdExecTime' : 0x00000001,
+    },
+
+    'Capability' : {
+        'Matrix' : 0,
+        'Shader' : 1,
+        'Geometry' : 2,
+        'Tessellation' : 3,
+        'Addresses' : 4,
+        'Linkage' : 5,
+        'Kernel' : 6,
+        'Vector16' : 7,
+        'Float16Buffer' : 8,
+        'Float16' : 9,
+        'Float64' : 10,
+        'Int64' : 11,
+        'Int64Atomics' : 12,
+        'ImageBasic' : 13,
+        'ImageReadWrite' : 14,
+        'ImageMipmap' : 15,
+        'Pipes' : 17,
+        'Groups' : 18,
+        'DeviceEnqueue' : 19,
+        'LiteralSampler' : 20,
+        'AtomicStorage' : 21,
+        'Int16' : 22,
+        'TessellationPointSize' : 23,
+        'GeometryPointSize' : 24,
+        'ImageGatherExtended' : 25,
+        'StorageImageMultisample' : 27,
+        'UniformBufferArrayDynamicIndexing' : 28,
+        'SampledImageArrayDynamicIndexing' : 29,
+        'StorageBufferArrayDynamicIndexing' : 30,
+        'StorageImageArrayDynamicIndexing' : 31,
+        'ClipDistance' : 32,
+        'CullDistance' : 33,
+        'ImageCubeArray' : 34,
+        'SampleRateShading' : 35,
+        'ImageRect' : 36,
+        'SampledRect' : 37,
+        'GenericPointer' : 38,
+        'Int8' : 39,
+        'InputAttachment' : 40,
+        'SparseResidency' : 41,
+        'MinLod' : 42,
+        'Sampled1D' : 43,
+        'Image1D' : 44,
+        'SampledCubeArray' : 45,
+        'SampledBuffer' : 46,
+        'ImageBuffer' : 47,
+        'ImageMSArray' : 48,
+        'StorageImageExtendedFormats' : 49,
+        'ImageQuery' : 50,
+        'DerivativeControl' : 51,
+        'InterpolationFunction' : 52,
+        'TransformFeedback' : 53,
+        'GeometryStreams' : 54,
+        'StorageImageReadWithoutFormat' : 55,
+        'StorageImageWriteWithoutFormat' : 56,
+        'MultiViewport' : 57,
+        'SubgroupDispatch' : 58,
+        'NamedBarrier' : 59,
+        'PipeStorage' : 60,
+        'SubgroupBallotKHR' : 4423,
+        'DrawParameters' : 4427,
+        'SubgroupVoteKHR' : 4431,
+        'StorageBuffer16BitAccess' : 4433,
+        'StorageUniformBufferBlock16' : 4433,
+        'StorageUniform16' : 4434,
+        'UniformAndStorageBuffer16BitAccess' : 4434,
+        'StoragePushConstant16' : 4435,
+        'StorageInputOutput16' : 4436,
+        'DeviceGroup' : 4437,
+        'MultiView' : 4439,
+        'VariablePointersStorageBuffer' : 4441,
+        'VariablePointers' : 4442,
+        'AtomicStorageOps' : 4445,
+        'SampleMaskPostDepthCoverage' : 4447,
+        'ImageGatherBiasLodAMD' : 5009,
+        'FragmentMaskAMD' : 5010,
+        'StencilExportEXT' : 5013,
+        'ImageReadWriteLodAMD' : 5015,
+        'SampleMaskOverrideCoverageNV' : 5249,
+        'GeometryShaderPassthroughNV' : 5251,
+        'ShaderViewportIndexLayerEXT' : 5254,
+        'ShaderViewportIndexLayerNV' : 5254,
+        'ShaderViewportMaskNV' : 5255,
+        'ShaderStereoViewNV' : 5259,
+        'PerViewAttributesNV' : 5260,
+        'SubgroupShuffleINTEL' : 5568,
+        'SubgroupBufferBlockIOINTEL' : 5569,
+        'SubgroupImageBlockIOINTEL' : 5570,
+    },
+
+    'Op' : {
+        'OpNop' : 0,
+        'OpUndef' : 1,
+        'OpSourceContinued' : 2,
+        'OpSource' : 3,
+        'OpSourceExtension' : 4,
+        'OpName' : 5,
+        'OpMemberName' : 6,
+        'OpString' : 7,
+        'OpLine' : 8,
+        'OpExtension' : 10,
+        'OpExtInstImport' : 11,
+        'OpExtInst' : 12,
+        'OpMemoryModel' : 14,
+        'OpEntryPoint' : 15,
+        'OpExecutionMode' : 16,
+        'OpCapability' : 17,
+        'OpTypeVoid' : 19,
+        'OpTypeBool' : 20,
+        'OpTypeInt' : 21,
+        'OpTypeFloat' : 22,
+        'OpTypeVector' : 23,
+        'OpTypeMatrix' : 24,
+        'OpTypeImage' : 25,
+        'OpTypeSampler' : 26,
+        'OpTypeSampledImage' : 27,
+        'OpTypeArray' : 28,
+        'OpTypeRuntimeArray' : 29,
+        'OpTypeStruct' : 30,
+        'OpTypeOpaque' : 31,
+        'OpTypePointer' : 32,
+        'OpTypeFunction' : 33,
+        'OpTypeEvent' : 34,
+        'OpTypeDeviceEvent' : 35,
+        'OpTypeReserveId' : 36,
+        'OpTypeQueue' : 37,
+        'OpTypePipe' : 38,
+        'OpTypeForwardPointer' : 39,
+        'OpConstantTrue' : 41,
+        'OpConstantFalse' : 42,
+        'OpConstant' : 43,
+        'OpConstantComposite' : 44,
+        'OpConstantSampler' : 45,
+        'OpConstantNull' : 46,
+        'OpSpecConstantTrue' : 48,
+        'OpSpecConstantFalse' : 49,
+        'OpSpecConstant' : 50,
+        'OpSpecConstantComposite' : 51,
+        'OpSpecConstantOp' : 52,
+        'OpFunction' : 54,
+        'OpFunctionParameter' : 55,
+        'OpFunctionEnd' : 56,
+        'OpFunctionCall' : 57,
+        'OpVariable' : 59,
+        'OpImageTexelPointer' : 60,
+        'OpLoad' : 61,
+        'OpStore' : 62,
+        'OpCopyMemory' : 63,
+        'OpCopyMemorySized' : 64,
+        'OpAccessChain' : 65,
+        'OpInBoundsAccessChain' : 66,
+        'OpPtrAccessChain' : 67,
+        'OpArrayLength' : 68,
+        'OpGenericPtrMemSemantics' : 69,
+        'OpInBoundsPtrAccessChain' : 70,
+        'OpDecorate' : 71,
+        'OpMemberDecorate' : 72,
+        'OpDecorationGroup' : 73,
+        'OpGroupDecorate' : 74,
+        'OpGroupMemberDecorate' : 75,
+        'OpVectorExtractDynamic' : 77,
+        'OpVectorInsertDynamic' : 78,
+        'OpVectorShuffle' : 79,
+        'OpCompositeConstruct' : 80,
+        'OpCompositeExtract' : 81,
+        'OpCompositeInsert' : 82,
+        'OpCopyObject' : 83,
+        'OpTranspose' : 84,
+        'OpSampledImage' : 86,
+        'OpImageSampleImplicitLod' : 87,
+        'OpImageSampleExplicitLod' : 88,
+        'OpImageSampleDrefImplicitLod' : 89,
+        'OpImageSampleDrefExplicitLod' : 90,
+        'OpImageSampleProjImplicitLod' : 91,
+        'OpImageSampleProjExplicitLod' : 92,
+        'OpImageSampleProjDrefImplicitLod' : 93,
+        'OpImageSampleProjDrefExplicitLod' : 94,
+        'OpImageFetch' : 95,
+        'OpImageGather' : 96,
+        'OpImageDrefGather' : 97,
+        'OpImageRead' : 98,
+        'OpImageWrite' : 99,
+        'OpImage' : 100,
+        'OpImageQueryFormat' : 101,
+        'OpImageQueryOrder' : 102,
+        'OpImageQuerySizeLod' : 103,
+        'OpImageQuerySize' : 104,
+        'OpImageQueryLod' : 105,
+        'OpImageQueryLevels' : 106,
+        'OpImageQuerySamples' : 107,
+        'OpConvertFToU' : 109,
+        'OpConvertFToS' : 110,
+        'OpConvertSToF' : 111,
+        'OpConvertUToF' : 112,
+        'OpUConvert' : 113,
+        'OpSConvert' : 114,
+        'OpFConvert' : 115,
+        'OpQuantizeToF16' : 116,
+        'OpConvertPtrToU' : 117,
+        'OpSatConvertSToU' : 118,
+        'OpSatConvertUToS' : 119,
+        'OpConvertUToPtr' : 120,
+        'OpPtrCastToGeneric' : 121,
+        'OpGenericCastToPtr' : 122,
+        'OpGenericCastToPtrExplicit' : 123,
+        'OpBitcast' : 124,
+        'OpSNegate' : 126,
+        'OpFNegate' : 127,
+        'OpIAdd' : 128,
+        'OpFAdd' : 129,
+        'OpISub' : 130,
+        'OpFSub' : 131,
+        'OpIMul' : 132,
+        'OpFMul' : 133,
+        'OpUDiv' : 134,
+        'OpSDiv' : 135,
+        'OpFDiv' : 136,
+        'OpUMod' : 137,
+        'OpSRem' : 138,
+        'OpSMod' : 139,
+        'OpFRem' : 140,
+        'OpFMod' : 141,
+        'OpVectorTimesScalar' : 142,
+        'OpMatrixTimesScalar' : 143,
+        'OpVectorTimesMatrix' : 144,
+        'OpMatrixTimesVector' : 145,
+        'OpMatrixTimesMatrix' : 146,
+        'OpOuterProduct' : 147,
+        'OpDot' : 148,
+        'OpIAddCarry' : 149,
+        'OpISubBorrow' : 150,
+        'OpUMulExtended' : 151,
+        'OpSMulExtended' : 152,
+        'OpAny' : 154,
+        'OpAll' : 155,
+        'OpIsNan' : 156,
+        'OpIsInf' : 157,
+        'OpIsFinite' : 158,
+        'OpIsNormal' : 159,
+        'OpSignBitSet' : 160,
+        'OpLessOrGreater' : 161,
+        'OpOrdered' : 162,
+        'OpUnordered' : 163,
+        'OpLogicalEqual' : 164,
+        'OpLogicalNotEqual' : 165,
+        'OpLogicalOr' : 166,
+        'OpLogicalAnd' : 167,
+        'OpLogicalNot' : 168,
+        'OpSelect' : 169,
+        'OpIEqual' : 170,
+        'OpINotEqual' : 171,
+        'OpUGreaterThan' : 172,
+        'OpSGreaterThan' : 173,
+        'OpUGreaterThanEqual' : 174,
+        'OpSGreaterThanEqual' : 175,
+        'OpULessThan' : 176,
+        'OpSLessThan' : 177,
+        'OpULessThanEqual' : 178,
+        'OpSLessThanEqual' : 179,
+        'OpFOrdEqual' : 180,
+        'OpFUnordEqual' : 181,
+        'OpFOrdNotEqual' : 182,
+        'OpFUnordNotEqual' : 183,
+        'OpFOrdLessThan' : 184,
+        'OpFUnordLessThan' : 185,
+        'OpFOrdGreaterThan' : 186,
+        'OpFUnordGreaterThan' : 187,
+        'OpFOrdLessThanEqual' : 188,
+        'OpFUnordLessThanEqual' : 189,
+        'OpFOrdGreaterThanEqual' : 190,
+        'OpFUnordGreaterThanEqual' : 191,
+        'OpShiftRightLogical' : 194,
+        'OpShiftRightArithmetic' : 195,
+        'OpShiftLeftLogical' : 196,
+        'OpBitwiseOr' : 197,
+        'OpBitwiseXor' : 198,
+        'OpBitwiseAnd' : 199,
+        'OpNot' : 200,
+        'OpBitFieldInsert' : 201,
+        'OpBitFieldSExtract' : 202,
+        'OpBitFieldUExtract' : 203,
+        'OpBitReverse' : 204,
+        'OpBitCount' : 205,
+        'OpDPdx' : 207,
+        'OpDPdy' : 208,
+        'OpFwidth' : 209,
+        'OpDPdxFine' : 210,
+        'OpDPdyFine' : 211,
+        'OpFwidthFine' : 212,
+        'OpDPdxCoarse' : 213,
+        'OpDPdyCoarse' : 214,
+        'OpFwidthCoarse' : 215,
+        'OpEmitVertex' : 218,
+        'OpEndPrimitive' : 219,
+        'OpEmitStreamVertex' : 220,
+        'OpEndStreamPrimitive' : 221,
+        'OpControlBarrier' : 224,
+        'OpMemoryBarrier' : 225,
+        'OpAtomicLoad' : 227,
+        'OpAtomicStore' : 228,
+        'OpAtomicExchange' : 229,
+        'OpAtomicCompareExchange' : 230,
+        'OpAtomicCompareExchangeWeak' : 231,
+        'OpAtomicIIncrement' : 232,
+        'OpAtomicIDecrement' : 233,
+        'OpAtomicIAdd' : 234,
+        'OpAtomicISub' : 235,
+        'OpAtomicSMin' : 236,
+        'OpAtomicUMin' : 237,
+        'OpAtomicSMax' : 238,
+        'OpAtomicUMax' : 239,
+        'OpAtomicAnd' : 240,
+        'OpAtomicOr' : 241,
+        'OpAtomicXor' : 242,
+        'OpPhi' : 245,
+        'OpLoopMerge' : 246,
+        'OpSelectionMerge' : 247,
+        'OpLabel' : 248,
+        'OpBranch' : 249,
+        'OpBranchConditional' : 250,
+        'OpSwitch' : 251,
+        'OpKill' : 252,
+        'OpReturn' : 253,
+        'OpReturnValue' : 254,
+        'OpUnreachable' : 255,
+        'OpLifetimeStart' : 256,
+        'OpLifetimeStop' : 257,
+        'OpGroupAsyncCopy' : 259,
+        'OpGroupWaitEvents' : 260,
+        'OpGroupAll' : 261,
+        'OpGroupAny' : 262,
+        'OpGroupBroadcast' : 263,
+        'OpGroupIAdd' : 264,
+        'OpGroupFAdd' : 265,
+        'OpGroupFMin' : 266,
+        'OpGroupUMin' : 267,
+        'OpGroupSMin' : 268,
+        'OpGroupFMax' : 269,
+        'OpGroupUMax' : 270,
+        'OpGroupSMax' : 271,
+        'OpReadPipe' : 274,
+        'OpWritePipe' : 275,
+        'OpReservedReadPipe' : 276,
+        'OpReservedWritePipe' : 277,
+        'OpReserveReadPipePackets' : 278,
+        'OpReserveWritePipePackets' : 279,
+        'OpCommitReadPipe' : 280,
+        'OpCommitWritePipe' : 281,
+        'OpIsValidReserveId' : 282,
+        'OpGetNumPipePackets' : 283,
+        'OpGetMaxPipePackets' : 284,
+        'OpGroupReserveReadPipePackets' : 285,
+        'OpGroupReserveWritePipePackets' : 286,
+        'OpGroupCommitReadPipe' : 287,
+        'OpGroupCommitWritePipe' : 288,
+        'OpEnqueueMarker' : 291,
+        'OpEnqueueKernel' : 292,
+        'OpGetKernelNDrangeSubGroupCount' : 293,
+        'OpGetKernelNDrangeMaxSubGroupSize' : 294,
+        'OpGetKernelWorkGroupSize' : 295,
+        'OpGetKernelPreferredWorkGroupSizeMultiple' : 296,
+        'OpRetainEvent' : 297,
+        'OpReleaseEvent' : 298,
+        'OpCreateUserEvent' : 299,
+        'OpIsValidEvent' : 300,
+        'OpSetUserEventStatus' : 301,
+        'OpCaptureEventProfilingInfo' : 302,
+        'OpGetDefaultQueue' : 303,
+        'OpBuildNDRange' : 304,
+        'OpImageSparseSampleImplicitLod' : 305,
+        'OpImageSparseSampleExplicitLod' : 306,
+        'OpImageSparseSampleDrefImplicitLod' : 307,
+        'OpImageSparseSampleDrefExplicitLod' : 308,
+        'OpImageSparseSampleProjImplicitLod' : 309,
+        'OpImageSparseSampleProjExplicitLod' : 310,
+        'OpImageSparseSampleProjDrefImplicitLod' : 311,
+        'OpImageSparseSampleProjDrefExplicitLod' : 312,
+        'OpImageSparseFetch' : 313,
+        'OpImageSparseGather' : 314,
+        'OpImageSparseDrefGather' : 315,
+        'OpImageSparseTexelsResident' : 316,
+        'OpNoLine' : 317,
+        'OpAtomicFlagTestAndSet' : 318,
+        'OpAtomicFlagClear' : 319,
+        'OpImageSparseRead' : 320,
+        'OpSizeOf' : 321,
+        'OpTypePipeStorage' : 322,
+        'OpConstantPipeStorage' : 323,
+        'OpCreatePipeFromPipeStorage' : 324,
+        'OpGetKernelLocalSizeForSubgroupCount' : 325,
+        'OpGetKernelMaxNumSubgroups' : 326,
+        'OpTypeNamedBarrier' : 327,
+        'OpNamedBarrierInitialize' : 328,
+        'OpMemoryNamedBarrier' : 329,
+        'OpModuleProcessed' : 330,
+        'OpDecorateId' : 332,
+        'OpSubgroupBallotKHR' : 4421,
+        'OpSubgroupFirstInvocationKHR' : 4422,
+        'OpSubgroupAllKHR' : 4428,
+        'OpSubgroupAnyKHR' : 4429,
+        'OpSubgroupAllEqualKHR' : 4430,
+        'OpSubgroupReadInvocationKHR' : 4432,
+        'OpGroupIAddNonUniformAMD' : 5000,
+        'OpGroupFAddNonUniformAMD' : 5001,
+        'OpGroupFMinNonUniformAMD' : 5002,
+        'OpGroupUMinNonUniformAMD' : 5003,
+        'OpGroupSMinNonUniformAMD' : 5004,
+        'OpGroupFMaxNonUniformAMD' : 5005,
+        'OpGroupUMaxNonUniformAMD' : 5006,
+        'OpGroupSMaxNonUniformAMD' : 5007,
+        'OpFragmentMaskFetchAMD' : 5011,
+        'OpFragmentFetchAMD' : 5012,
+        'OpSubgroupShuffleINTEL' : 5571,
+        'OpSubgroupShuffleDownINTEL' : 5572,
+        'OpSubgroupShuffleUpINTEL' : 5573,
+        'OpSubgroupShuffleXorINTEL' : 5574,
+        'OpSubgroupBlockReadINTEL' : 5575,
+        'OpSubgroupBlockWriteINTEL' : 5576,
+        'OpSubgroupImageBlockReadINTEL' : 5577,
+        'OpSubgroupImageBlockWriteINTEL' : 5578,
+        'OpDecorateStringGOOGLE' : 5632,
+        'OpMemberDecorateStringGOOGLE' : 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.2/GLSL.std.450.h

@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.2/OpenCL.std.h

@@ -0,0 +1,210 @@
+/*
+** Copyright (c) 2015-2017 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+namespace OpenCLLIB {
+
+enum Entrypoints {
+
+    // Section 2.1: Math extended instructions
+    Acos = 0,
+    Acosh = 1,
+    Acospi = 2,
+    Asin = 3,
+    Asinh = 4,
+    Asinpi = 5,
+    Atan = 6,
+    Atan2 = 7,
+    Atanh = 8,
+    Atanpi = 9,
+    Atan2pi = 10,
+    Cbrt = 11,
+    Ceil = 12,
+    Copysign = 13,
+    Cos = 14,
+    Cosh = 15,
+    Cospi = 16,
+    Erfc = 17,
+    Erf = 18,
+    Exp = 19,
+    Exp2 = 20,
+    Exp10 = 21,
+    Expm1 = 22,
+    Fabs = 23,
+    Fdim = 24,
+    Floor = 25,
+    Fma = 26,
+    Fmax = 27,
+    Fmin = 28,
+    Fmod = 29,
+    Fract = 30, 
+    Frexp = 31,
+    Hypot = 32,
+    Ilogb = 33,
+    Ldexp = 34,
+    Lgamma = 35,
+    Lgamma_r = 36,
+    Log = 37,
+    Log2 = 38,
+    Log10 = 39,
+    Log1p = 40,
+    Logb = 41,
+    Mad = 42,
+    Maxmag = 43,
+    Minmag = 44,
+    Modf = 45,
+    Nan = 46,
+    Nextafter = 47,
+    Pow = 48,
+    Pown = 49,
+    Powr = 50,
+    Remainder = 51,
+    Remquo = 52,
+    Rint = 53,
+    Rootn = 54,
+    Round = 55,
+    Rsqrt = 56,
+    Sin = 57,
+    Sincos = 58,
+    Sinh = 59,
+    Sinpi = 60,
+    Sqrt = 61,
+    Tan = 62,
+    Tanh = 63,
+    Tanpi = 64,
+    Tgamma = 65,
+    Trunc = 66,
+    Half_cos = 67,
+    Half_divide = 68,
+    Half_exp = 69,
+    Half_exp2 = 70,
+    Half_exp10 = 71,
+    Half_log = 72,
+    Half_log2 = 73,
+    Half_log10 = 74,
+    Half_powr = 75,
+    Half_recip = 76,
+    Half_rsqrt = 77,
+    Half_sin = 78,
+    Half_sqrt = 79,
+    Half_tan = 80,
+    Native_cos = 81,
+    Native_divide = 82,
+    Native_exp = 83,
+    Native_exp2 = 84,
+    Native_exp10 = 85,
+    Native_log = 86,
+    Native_log2 = 87,
+    Native_log10 = 88,
+    Native_powr = 89,
+    Native_recip = 90,
+    Native_rsqrt = 91,
+    Native_sin = 92,
+    Native_sqrt = 93,
+    Native_tan = 94,
+    
+    // Section 2.2: Integer instructions
+    SAbs = 141,
+    SAbs_diff = 142,
+    SAdd_sat = 143,
+    UAdd_sat = 144,
+    SHadd = 145,
+    UHadd = 146,
+    SRhadd = 147,
+    URhadd = 148,
+    SClamp = 149,
+    UClamp = 150, 
+    Clz = 151,
+    Ctz = 152,    
+    SMad_hi = 153,
+    UMad_sat = 154,
+    SMad_sat = 155,
+    SMax = 156,
+    UMax = 157,
+    SMin = 158,
+    UMin = 159,
+    SMul_hi = 160,
+    Rotate = 161,
+    SSub_sat = 162,
+    USub_sat = 163,
+    U_Upsample = 164,
+    S_Upsample = 165,
+    Popcount = 166,
+    SMad24 = 167,
+    UMad24 = 168,
+    SMul24 = 169,
+    UMul24 = 170,
+    UAbs = 201,
+    UAbs_diff = 202,
+    UMul_hi = 203,
+    UMad_hi = 204,
+
+    // Section 2.3: Common instructions
+    FClamp = 95,
+    Degrees = 96,
+    FMax_common = 97,
+    FMin_common = 98, 
+    Mix = 99,
+    Radians = 100,
+    Step = 101,
+    Smoothstep = 102,
+    Sign = 103,
+
+    // Section 2.4: Geometric instructions
+    Cross = 104,
+    Distance = 105, 
+    Length = 106,
+    Normalize = 107,
+    Fast_distance = 108,
+    Fast_length = 109,
+    Fast_normalize = 110,
+
+    // Section 2.5: Relational instructions
+    Bitselect = 186,
+    Select = 187,
+
+    // Section 2.6: Vector Data Load and Store instructions
+    Vloadn = 171,
+    Vstoren = 172,
+    Vload_half = 173,
+    Vload_halfn = 174,
+    Vstore_half = 175,
+    Vstore_half_r = 176,
+    Vstore_halfn = 177,
+    Vstore_halfn_r = 178,
+    Vloada_halfn = 179,
+    Vstorea_halfn = 180,
+    Vstorea_halfn_r = 181,
+
+    // Section 2.7: Miscellaneous Vector instructions
+    Shuffle = 182,
+    Shuffle2 = 183,
+
+    // Section 2.8: Misc instructions 
+    Printf = 184,
+    Prefetch = 185,
+};
+
+} // end namespace OpenCLLIB

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.2/extinst.glsl.std.450.grammar.json

@@ -0,0 +1,642 @@
+{
+  "copyright" : [
+    "Copyright (c) 2014-2016 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "Round",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "RoundEven",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Trunc",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FAbs",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SAbs",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FSign",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SSign",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Floor",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ceil",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fract",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Radians",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'degrees'" }
+      ]
+    },
+    {
+      "opname" : "Degrees",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'radians'" }
+      ]
+    },
+    {
+      "opname" : "Sin",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cos",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tan",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asin",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acos",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y_over_x'" }
+      ]
+    },
+    {
+      "opname" : "Sinh",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cosh",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tanh",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asinh",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acosh",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atanh",
+      "opcode" : 24,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan2",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Pow",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Exp",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Exp2",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log2",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Sqrt",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "InverseSqrt",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Determinant",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "MatrixInverse",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Modf",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'i'" }
+      ]
+    },
+    {
+      "opname" : "ModfStruct",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FMin",
+      "opcode" : 37,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMin",
+      "opcode" : 38,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMin",
+      "opcode" : 39,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FMax",
+      "opcode" : 40,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMax",
+      "opcode" : 41,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMax",
+      "opcode" : 42,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FClamp",
+      "opcode" : 43,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "UClamp",
+      "opcode" : 44,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "SClamp",
+      "opcode" : 45,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "FMix",
+      "opcode" : 46,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "IMix",
+      "opcode" : 47,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "Step",
+      "opcode" : 48,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SmoothStep",
+      "opcode" : 49,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge0'" },
+        { "kind" : "IdRef", "name" : "'edge1'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fma",
+      "opcode" : 50,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'a'" },
+        { "kind" : "IdRef", "name" : "'b'" },
+        { "kind" : "IdRef", "name" : "'c'" }
+      ]
+    },
+    {
+      "opname" : "Frexp",
+      "opcode" : 51,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "FrexpStruct",
+      "opcode" : 52,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ldexp",
+      "opcode" : 53,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm4x8",
+      "opcode" : 54,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm4x8",
+      "opcode" : 55,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm2x16",
+      "opcode" : 56,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm2x16",
+      "opcode" : 57,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackHalf2x16",
+      "opcode" : 58,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackDouble2x32",
+      "opcode" : 59,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "UnpackSnorm2x16",
+      "opcode" : 60,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm2x16",
+      "opcode" : 61,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackHalf2x16",
+      "opcode" : 62,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "UnpackSnorm4x8",
+      "opcode" : 63,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm4x8",
+      "opcode" : 64,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackDouble2x32",
+      "opcode" : 65,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "Length",
+      "opcode" : 66,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Distance",
+      "opcode" : 67,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p0'" },
+        { "kind" : "IdRef", "name" : "'p1'" }
+      ]
+    },
+    {
+      "opname" : "Cross",
+      "opcode" : 68,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Normalize",
+      "opcode" : 69,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FaceForward",
+      "opcode" : 70,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'Nref'" }
+      ]
+    },
+    {
+      "opname" : "Reflect",
+      "opcode" : 71,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" }
+      ]
+    },
+    {
+      "opname" : "Refract",
+      "opcode" : 72,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'eta'" }
+      ]
+    },
+    {
+      "opname" : "FindILsb",
+      "opcode" : 73,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindSMsb",
+      "opcode" : 74,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindUMsb",
+      "opcode" : 75,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "InterpolateAtCentroid",
+      "opcode" : 76,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtSample",
+      "opcode" : 77,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'sample'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtOffset",
+      "opcode" : 78,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'offset'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "NMin",
+      "opcode" : 79,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NMax",
+      "opcode" : 80,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NClamp",
+      "opcode" : 81,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.2/spirv.lua

@@ -0,0 +1,977 @@
+-- Copyright (c) 2014-2018 The Khronos Group Inc.
+-- 
+-- Permission is hereby granted, free of charge, to any person obtaining a copy
+-- of this software and/or associated documentation files (the "Materials"),
+-- to deal in the Materials without restriction, including without limitation
+-- the rights to use, copy, modify, merge, publish, distribute, sublicense,
+-- and/or sell copies of the Materials, and to permit persons to whom the
+-- Materials are furnished to do so, subject to the following conditions:
+-- 
+-- The above copyright notice and this permission notice shall be included in
+-- all copies or substantial portions of the Materials.
+-- 
+-- MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+-- STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+-- HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+-- 
+-- THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+-- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+-- THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-- FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+-- IN THE MATERIALS.
+
+-- This header is automatically generated by the same tool that creates
+-- the Binary Section of the SPIR-V specification.
+
+-- Enumeration tokens for SPIR-V, in various styles:
+--   C, C++, C++11, JSON, Lua, Python
+-- 
+-- - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+-- - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+-- - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+-- - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+-- - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+-- 
+-- Some tokens act like mask values, which can be OR'd together,
+-- while others are mutually exclusive.  The mask-like ones have
+-- "Mask" in their name, and a parallel enum that has the shift
+-- amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    MagicNumber = 0x07230203,
+    Version = 0x00010200,
+    Revision = 2,
+    OpCodeMask = 0xffff,
+    WordCountShift = 16,
+
+    SourceLanguage = {
+        Unknown = 0,
+        ESSL = 1,
+        GLSL = 2,
+        OpenCL_C = 3,
+        OpenCL_CPP = 4,
+        HLSL = 5,
+    },
+
+    ExecutionModel = {
+        Vertex = 0,
+        TessellationControl = 1,
+        TessellationEvaluation = 2,
+        Geometry = 3,
+        Fragment = 4,
+        GLCompute = 5,
+        Kernel = 6,
+    },
+
+    AddressingModel = {
+        Logical = 0,
+        Physical32 = 1,
+        Physical64 = 2,
+    },
+
+    MemoryModel = {
+        Simple = 0,
+        GLSL450 = 1,
+        OpenCL = 2,
+    },
+
+    ExecutionMode = {
+        Invocations = 0,
+        SpacingEqual = 1,
+        SpacingFractionalEven = 2,
+        SpacingFractionalOdd = 3,
+        VertexOrderCw = 4,
+        VertexOrderCcw = 5,
+        PixelCenterInteger = 6,
+        OriginUpperLeft = 7,
+        OriginLowerLeft = 8,
+        EarlyFragmentTests = 9,
+        PointMode = 10,
+        Xfb = 11,
+        DepthReplacing = 12,
+        DepthGreater = 14,
+        DepthLess = 15,
+        DepthUnchanged = 16,
+        LocalSize = 17,
+        LocalSizeHint = 18,
+        InputPoints = 19,
+        InputLines = 20,
+        InputLinesAdjacency = 21,
+        Triangles = 22,
+        InputTrianglesAdjacency = 23,
+        Quads = 24,
+        Isolines = 25,
+        OutputVertices = 26,
+        OutputPoints = 27,
+        OutputLineStrip = 28,
+        OutputTriangleStrip = 29,
+        VecTypeHint = 30,
+        ContractionOff = 31,
+        Initializer = 33,
+        Finalizer = 34,
+        SubgroupSize = 35,
+        SubgroupsPerWorkgroup = 36,
+        SubgroupsPerWorkgroupId = 37,
+        LocalSizeId = 38,
+        LocalSizeHintId = 39,
+        PostDepthCoverage = 4446,
+        StencilRefReplacingEXT = 5027,
+    },
+
+    StorageClass = {
+        UniformConstant = 0,
+        Input = 1,
+        Uniform = 2,
+        Output = 3,
+        Workgroup = 4,
+        CrossWorkgroup = 5,
+        Private = 6,
+        Function = 7,
+        Generic = 8,
+        PushConstant = 9,
+        AtomicCounter = 10,
+        Image = 11,
+        StorageBuffer = 12,
+    },
+
+    Dim = {
+        Dim1D = 0,
+        Dim2D = 1,
+        Dim3D = 2,
+        Cube = 3,
+        Rect = 4,
+        Buffer = 5,
+        SubpassData = 6,
+    },
+
+    SamplerAddressingMode = {
+        None = 0,
+        ClampToEdge = 1,
+        Clamp = 2,
+        Repeat = 3,
+        RepeatMirrored = 4,
+    },
+
+    SamplerFilterMode = {
+        Nearest = 0,
+        Linear = 1,
+    },
+
+    ImageFormat = {
+        Unknown = 0,
+        Rgba32f = 1,
+        Rgba16f = 2,
+        R32f = 3,
+        Rgba8 = 4,
+        Rgba8Snorm = 5,
+        Rg32f = 6,
+        Rg16f = 7,
+        R11fG11fB10f = 8,
+        R16f = 9,
+        Rgba16 = 10,
+        Rgb10A2 = 11,
+        Rg16 = 12,
+        Rg8 = 13,
+        R16 = 14,
+        R8 = 15,
+        Rgba16Snorm = 16,
+        Rg16Snorm = 17,
+        Rg8Snorm = 18,
+        R16Snorm = 19,
+        R8Snorm = 20,
+        Rgba32i = 21,
+        Rgba16i = 22,
+        Rgba8i = 23,
+        R32i = 24,
+        Rg32i = 25,
+        Rg16i = 26,
+        Rg8i = 27,
+        R16i = 28,
+        R8i = 29,
+        Rgba32ui = 30,
+        Rgba16ui = 31,
+        Rgba8ui = 32,
+        R32ui = 33,
+        Rgb10a2ui = 34,
+        Rg32ui = 35,
+        Rg16ui = 36,
+        Rg8ui = 37,
+        R16ui = 38,
+        R8ui = 39,
+    },
+
+    ImageChannelOrder = {
+        R = 0,
+        A = 1,
+        RG = 2,
+        RA = 3,
+        RGB = 4,
+        RGBA = 5,
+        BGRA = 6,
+        ARGB = 7,
+        Intensity = 8,
+        Luminance = 9,
+        Rx = 10,
+        RGx = 11,
+        RGBx = 12,
+        Depth = 13,
+        DepthStencil = 14,
+        sRGB = 15,
+        sRGBx = 16,
+        sRGBA = 17,
+        sBGRA = 18,
+        ABGR = 19,
+    },
+
+    ImageChannelDataType = {
+        SnormInt8 = 0,
+        SnormInt16 = 1,
+        UnormInt8 = 2,
+        UnormInt16 = 3,
+        UnormShort565 = 4,
+        UnormShort555 = 5,
+        UnormInt101010 = 6,
+        SignedInt8 = 7,
+        SignedInt16 = 8,
+        SignedInt32 = 9,
+        UnsignedInt8 = 10,
+        UnsignedInt16 = 11,
+        UnsignedInt32 = 12,
+        HalfFloat = 13,
+        Float = 14,
+        UnormInt24 = 15,
+        UnormInt101010_2 = 16,
+    },
+
+    ImageOperandsShift = {
+        Bias = 0,
+        Lod = 1,
+        Grad = 2,
+        ConstOffset = 3,
+        Offset = 4,
+        ConstOffsets = 5,
+        Sample = 6,
+        MinLod = 7,
+    },
+
+    ImageOperandsMask = {
+        MaskNone = 0,
+        Bias = 0x00000001,
+        Lod = 0x00000002,
+        Grad = 0x00000004,
+        ConstOffset = 0x00000008,
+        Offset = 0x00000010,
+        ConstOffsets = 0x00000020,
+        Sample = 0x00000040,
+        MinLod = 0x00000080,
+    },
+
+    FPFastMathModeShift = {
+        NotNaN = 0,
+        NotInf = 1,
+        NSZ = 2,
+        AllowRecip = 3,
+        Fast = 4,
+    },
+
+    FPFastMathModeMask = {
+        MaskNone = 0,
+        NotNaN = 0x00000001,
+        NotInf = 0x00000002,
+        NSZ = 0x00000004,
+        AllowRecip = 0x00000008,
+        Fast = 0x00000010,
+    },
+
+    FPRoundingMode = {
+        RTE = 0,
+        RTZ = 1,
+        RTP = 2,
+        RTN = 3,
+    },
+
+    LinkageType = {
+        Export = 0,
+        Import = 1,
+    },
+
+    AccessQualifier = {
+        ReadOnly = 0,
+        WriteOnly = 1,
+        ReadWrite = 2,
+    },
+
+    FunctionParameterAttribute = {
+        Zext = 0,
+        Sext = 1,
+        ByVal = 2,
+        Sret = 3,
+        NoAlias = 4,
+        NoCapture = 5,
+        NoWrite = 6,
+        NoReadWrite = 7,
+    },
+
+    Decoration = {
+        RelaxedPrecision = 0,
+        SpecId = 1,
+        Block = 2,
+        BufferBlock = 3,
+        RowMajor = 4,
+        ColMajor = 5,
+        ArrayStride = 6,
+        MatrixStride = 7,
+        GLSLShared = 8,
+        GLSLPacked = 9,
+        CPacked = 10,
+        BuiltIn = 11,
+        NoPerspective = 13,
+        Flat = 14,
+        Patch = 15,
+        Centroid = 16,
+        Sample = 17,
+        Invariant = 18,
+        Restrict = 19,
+        Aliased = 20,
+        Volatile = 21,
+        Constant = 22,
+        Coherent = 23,
+        NonWritable = 24,
+        NonReadable = 25,
+        Uniform = 26,
+        SaturatedConversion = 28,
+        Stream = 29,
+        Location = 30,
+        Component = 31,
+        Index = 32,
+        Binding = 33,
+        DescriptorSet = 34,
+        Offset = 35,
+        XfbBuffer = 36,
+        XfbStride = 37,
+        FuncParamAttr = 38,
+        FPRoundingMode = 39,
+        FPFastMathMode = 40,
+        LinkageAttributes = 41,
+        NoContraction = 42,
+        InputAttachmentIndex = 43,
+        Alignment = 44,
+        MaxByteOffset = 45,
+        AlignmentId = 46,
+        MaxByteOffsetId = 47,
+        ExplicitInterpAMD = 4999,
+        OverrideCoverageNV = 5248,
+        PassthroughNV = 5250,
+        ViewportRelativeNV = 5252,
+        SecondaryViewportRelativeNV = 5256,
+        HlslCounterBufferGOOGLE = 5634,
+        HlslSemanticGOOGLE = 5635,
+    },
+
+    BuiltIn = {
+        Position = 0,
+        PointSize = 1,
+        ClipDistance = 3,
+        CullDistance = 4,
+        VertexId = 5,
+        InstanceId = 6,
+        PrimitiveId = 7,
+        InvocationId = 8,
+        Layer = 9,
+        ViewportIndex = 10,
+        TessLevelOuter = 11,
+        TessLevelInner = 12,
+        TessCoord = 13,
+        PatchVertices = 14,
+        FragCoord = 15,
+        PointCoord = 16,
+        FrontFacing = 17,
+        SampleId = 18,
+        SamplePosition = 19,
+        SampleMask = 20,
+        FragDepth = 22,
+        HelperInvocation = 23,
+        NumWorkgroups = 24,
+        WorkgroupSize = 25,
+        WorkgroupId = 26,
+        LocalInvocationId = 27,
+        GlobalInvocationId = 28,
+        LocalInvocationIndex = 29,
+        WorkDim = 30,
+        GlobalSize = 31,
+        EnqueuedWorkgroupSize = 32,
+        GlobalOffset = 33,
+        GlobalLinearId = 34,
+        SubgroupSize = 36,
+        SubgroupMaxSize = 37,
+        NumSubgroups = 38,
+        NumEnqueuedSubgroups = 39,
+        SubgroupId = 40,
+        SubgroupLocalInvocationId = 41,
+        VertexIndex = 42,
+        InstanceIndex = 43,
+        SubgroupEqMaskKHR = 4416,
+        SubgroupGeMaskKHR = 4417,
+        SubgroupGtMaskKHR = 4418,
+        SubgroupLeMaskKHR = 4419,
+        SubgroupLtMaskKHR = 4420,
+        BaseVertex = 4424,
+        BaseInstance = 4425,
+        DrawIndex = 4426,
+        DeviceIndex = 4438,
+        ViewIndex = 4440,
+        BaryCoordNoPerspAMD = 4992,
+        BaryCoordNoPerspCentroidAMD = 4993,
+        BaryCoordNoPerspSampleAMD = 4994,
+        BaryCoordSmoothAMD = 4995,
+        BaryCoordSmoothCentroidAMD = 4996,
+        BaryCoordSmoothSampleAMD = 4997,
+        BaryCoordPullModelAMD = 4998,
+        FragStencilRefEXT = 5014,
+        ViewportMaskNV = 5253,
+        SecondaryPositionNV = 5257,
+        SecondaryViewportMaskNV = 5258,
+        PositionPerViewNV = 5261,
+        ViewportMaskPerViewNV = 5262,
+    },
+
+    SelectionControlShift = {
+        Flatten = 0,
+        DontFlatten = 1,
+    },
+
+    SelectionControlMask = {
+        MaskNone = 0,
+        Flatten = 0x00000001,
+        DontFlatten = 0x00000002,
+    },
+
+    LoopControlShift = {
+        Unroll = 0,
+        DontUnroll = 1,
+        DependencyInfinite = 2,
+        DependencyLength = 3,
+    },
+
+    LoopControlMask = {
+        MaskNone = 0,
+        Unroll = 0x00000001,
+        DontUnroll = 0x00000002,
+        DependencyInfinite = 0x00000004,
+        DependencyLength = 0x00000008,
+    },
+
+    FunctionControlShift = {
+        Inline = 0,
+        DontInline = 1,
+        Pure = 2,
+        Const = 3,
+    },
+
+    FunctionControlMask = {
+        MaskNone = 0,
+        Inline = 0x00000001,
+        DontInline = 0x00000002,
+        Pure = 0x00000004,
+        Const = 0x00000008,
+    },
+
+    MemorySemanticsShift = {
+        Acquire = 1,
+        Release = 2,
+        AcquireRelease = 3,
+        SequentiallyConsistent = 4,
+        UniformMemory = 6,
+        SubgroupMemory = 7,
+        WorkgroupMemory = 8,
+        CrossWorkgroupMemory = 9,
+        AtomicCounterMemory = 10,
+        ImageMemory = 11,
+    },
+
+    MemorySemanticsMask = {
+        MaskNone = 0,
+        Acquire = 0x00000002,
+        Release = 0x00000004,
+        AcquireRelease = 0x00000008,
+        SequentiallyConsistent = 0x00000010,
+        UniformMemory = 0x00000040,
+        SubgroupMemory = 0x00000080,
+        WorkgroupMemory = 0x00000100,
+        CrossWorkgroupMemory = 0x00000200,
+        AtomicCounterMemory = 0x00000400,
+        ImageMemory = 0x00000800,
+    },
+
+    MemoryAccessShift = {
+        Volatile = 0,
+        Aligned = 1,
+        Nontemporal = 2,
+    },
+
+    MemoryAccessMask = {
+        MaskNone = 0,
+        Volatile = 0x00000001,
+        Aligned = 0x00000002,
+        Nontemporal = 0x00000004,
+    },
+
+    Scope = {
+        CrossDevice = 0,
+        Device = 1,
+        Workgroup = 2,
+        Subgroup = 3,
+        Invocation = 4,
+    },
+
+    GroupOperation = {
+        Reduce = 0,
+        InclusiveScan = 1,
+        ExclusiveScan = 2,
+    },
+
+    KernelEnqueueFlags = {
+        NoWait = 0,
+        WaitKernel = 1,
+        WaitWorkGroup = 2,
+    },
+
+    KernelProfilingInfoShift = {
+        CmdExecTime = 0,
+    },
+
+    KernelProfilingInfoMask = {
+        MaskNone = 0,
+        CmdExecTime = 0x00000001,
+    },
+
+    Capability = {
+        Matrix = 0,
+        Shader = 1,
+        Geometry = 2,
+        Tessellation = 3,
+        Addresses = 4,
+        Linkage = 5,
+        Kernel = 6,
+        Vector16 = 7,
+        Float16Buffer = 8,
+        Float16 = 9,
+        Float64 = 10,
+        Int64 = 11,
+        Int64Atomics = 12,
+        ImageBasic = 13,
+        ImageReadWrite = 14,
+        ImageMipmap = 15,
+        Pipes = 17,
+        Groups = 18,
+        DeviceEnqueue = 19,
+        LiteralSampler = 20,
+        AtomicStorage = 21,
+        Int16 = 22,
+        TessellationPointSize = 23,
+        GeometryPointSize = 24,
+        ImageGatherExtended = 25,
+        StorageImageMultisample = 27,
+        UniformBufferArrayDynamicIndexing = 28,
+        SampledImageArrayDynamicIndexing = 29,
+        StorageBufferArrayDynamicIndexing = 30,
+        StorageImageArrayDynamicIndexing = 31,
+        ClipDistance = 32,
+        CullDistance = 33,
+        ImageCubeArray = 34,
+        SampleRateShading = 35,
+        ImageRect = 36,
+        SampledRect = 37,
+        GenericPointer = 38,
+        Int8 = 39,
+        InputAttachment = 40,
+        SparseResidency = 41,
+        MinLod = 42,
+        Sampled1D = 43,
+        Image1D = 44,
+        SampledCubeArray = 45,
+        SampledBuffer = 46,
+        ImageBuffer = 47,
+        ImageMSArray = 48,
+        StorageImageExtendedFormats = 49,
+        ImageQuery = 50,
+        DerivativeControl = 51,
+        InterpolationFunction = 52,
+        TransformFeedback = 53,
+        GeometryStreams = 54,
+        StorageImageReadWithoutFormat = 55,
+        StorageImageWriteWithoutFormat = 56,
+        MultiViewport = 57,
+        SubgroupDispatch = 58,
+        NamedBarrier = 59,
+        PipeStorage = 60,
+        SubgroupBallotKHR = 4423,
+        DrawParameters = 4427,
+        SubgroupVoteKHR = 4431,
+        StorageBuffer16BitAccess = 4433,
+        StorageUniformBufferBlock16 = 4433,
+        StorageUniform16 = 4434,
+        UniformAndStorageBuffer16BitAccess = 4434,
+        StoragePushConstant16 = 4435,
+        StorageInputOutput16 = 4436,
+        DeviceGroup = 4437,
+        MultiView = 4439,
+        VariablePointersStorageBuffer = 4441,
+        VariablePointers = 4442,
+        AtomicStorageOps = 4445,
+        SampleMaskPostDepthCoverage = 4447,
+        ImageGatherBiasLodAMD = 5009,
+        FragmentMaskAMD = 5010,
+        StencilExportEXT = 5013,
+        ImageReadWriteLodAMD = 5015,
+        SampleMaskOverrideCoverageNV = 5249,
+        GeometryShaderPassthroughNV = 5251,
+        ShaderViewportIndexLayerEXT = 5254,
+        ShaderViewportIndexLayerNV = 5254,
+        ShaderViewportMaskNV = 5255,
+        ShaderStereoViewNV = 5259,
+        PerViewAttributesNV = 5260,
+        SubgroupShuffleINTEL = 5568,
+        SubgroupBufferBlockIOINTEL = 5569,
+        SubgroupImageBlockIOINTEL = 5570,
+    },
+
+    Op = {
+        OpNop = 0,
+        OpUndef = 1,
+        OpSourceContinued = 2,
+        OpSource = 3,
+        OpSourceExtension = 4,
+        OpName = 5,
+        OpMemberName = 6,
+        OpString = 7,
+        OpLine = 8,
+        OpExtension = 10,
+        OpExtInstImport = 11,
+        OpExtInst = 12,
+        OpMemoryModel = 14,
+        OpEntryPoint = 15,
+        OpExecutionMode = 16,
+        OpCapability = 17,
+        OpTypeVoid = 19,
+        OpTypeBool = 20,
+        OpTypeInt = 21,
+        OpTypeFloat = 22,
+        OpTypeVector = 23,
+        OpTypeMatrix = 24,
+        OpTypeImage = 25,
+        OpTypeSampler = 26,
+        OpTypeSampledImage = 27,
+        OpTypeArray = 28,
+        OpTypeRuntimeArray = 29,
+        OpTypeStruct = 30,
+        OpTypeOpaque = 31,
+        OpTypePointer = 32,
+        OpTypeFunction = 33,
+        OpTypeEvent = 34,
+        OpTypeDeviceEvent = 35,
+        OpTypeReserveId = 36,
+        OpTypeQueue = 37,
+        OpTypePipe = 38,
+        OpTypeForwardPointer = 39,
+        OpConstantTrue = 41,
+        OpConstantFalse = 42,
+        OpConstant = 43,
+        OpConstantComposite = 44,
+        OpConstantSampler = 45,
+        OpConstantNull = 46,
+        OpSpecConstantTrue = 48,
+        OpSpecConstantFalse = 49,
+        OpSpecConstant = 50,
+        OpSpecConstantComposite = 51,
+        OpSpecConstantOp = 52,
+        OpFunction = 54,
+        OpFunctionParameter = 55,
+        OpFunctionEnd = 56,
+        OpFunctionCall = 57,
+        OpVariable = 59,
+        OpImageTexelPointer = 60,
+        OpLoad = 61,
+        OpStore = 62,
+        OpCopyMemory = 63,
+        OpCopyMemorySized = 64,
+        OpAccessChain = 65,
+        OpInBoundsAccessChain = 66,
+        OpPtrAccessChain = 67,
+        OpArrayLength = 68,
+        OpGenericPtrMemSemantics = 69,
+        OpInBoundsPtrAccessChain = 70,
+        OpDecorate = 71,
+        OpMemberDecorate = 72,
+        OpDecorationGroup = 73,
+        OpGroupDecorate = 74,
+        OpGroupMemberDecorate = 75,
+        OpVectorExtractDynamic = 77,
+        OpVectorInsertDynamic = 78,
+        OpVectorShuffle = 79,
+        OpCompositeConstruct = 80,
+        OpCompositeExtract = 81,
+        OpCompositeInsert = 82,
+        OpCopyObject = 83,
+        OpTranspose = 84,
+        OpSampledImage = 86,
+        OpImageSampleImplicitLod = 87,
+        OpImageSampleExplicitLod = 88,
+        OpImageSampleDrefImplicitLod = 89,
+        OpImageSampleDrefExplicitLod = 90,
+        OpImageSampleProjImplicitLod = 91,
+        OpImageSampleProjExplicitLod = 92,
+        OpImageSampleProjDrefImplicitLod = 93,
+        OpImageSampleProjDrefExplicitLod = 94,
+        OpImageFetch = 95,
+        OpImageGather = 96,
+        OpImageDrefGather = 97,
+        OpImageRead = 98,
+        OpImageWrite = 99,
+        OpImage = 100,
+        OpImageQueryFormat = 101,
+        OpImageQueryOrder = 102,
+        OpImageQuerySizeLod = 103,
+        OpImageQuerySize = 104,
+        OpImageQueryLod = 105,
+        OpImageQueryLevels = 106,
+        OpImageQuerySamples = 107,
+        OpConvertFToU = 109,
+        OpConvertFToS = 110,
+        OpConvertSToF = 111,
+        OpConvertUToF = 112,
+        OpUConvert = 113,
+        OpSConvert = 114,
+        OpFConvert = 115,
+        OpQuantizeToF16 = 116,
+        OpConvertPtrToU = 117,
+        OpSatConvertSToU = 118,
+        OpSatConvertUToS = 119,
+        OpConvertUToPtr = 120,
+        OpPtrCastToGeneric = 121,
+        OpGenericCastToPtr = 122,
+        OpGenericCastToPtrExplicit = 123,
+        OpBitcast = 124,
+        OpSNegate = 126,
+        OpFNegate = 127,
+        OpIAdd = 128,
+        OpFAdd = 129,
+        OpISub = 130,
+        OpFSub = 131,
+        OpIMul = 132,
+        OpFMul = 133,
+        OpUDiv = 134,
+        OpSDiv = 135,
+        OpFDiv = 136,
+        OpUMod = 137,
+        OpSRem = 138,
+        OpSMod = 139,
+        OpFRem = 140,
+        OpFMod = 141,
+        OpVectorTimesScalar = 142,
+        OpMatrixTimesScalar = 143,
+        OpVectorTimesMatrix = 144,
+        OpMatrixTimesVector = 145,
+        OpMatrixTimesMatrix = 146,
+        OpOuterProduct = 147,
+        OpDot = 148,
+        OpIAddCarry = 149,
+        OpISubBorrow = 150,
+        OpUMulExtended = 151,
+        OpSMulExtended = 152,
+        OpAny = 154,
+        OpAll = 155,
+        OpIsNan = 156,
+        OpIsInf = 157,
+        OpIsFinite = 158,
+        OpIsNormal = 159,
+        OpSignBitSet = 160,
+        OpLessOrGreater = 161,
+        OpOrdered = 162,
+        OpUnordered = 163,
+        OpLogicalEqual = 164,
+        OpLogicalNotEqual = 165,
+        OpLogicalOr = 166,
+        OpLogicalAnd = 167,
+        OpLogicalNot = 168,
+        OpSelect = 169,
+        OpIEqual = 170,
+        OpINotEqual = 171,
+        OpUGreaterThan = 172,
+        OpSGreaterThan = 173,
+        OpUGreaterThanEqual = 174,
+        OpSGreaterThanEqual = 175,
+        OpULessThan = 176,
+        OpSLessThan = 177,
+        OpULessThanEqual = 178,
+        OpSLessThanEqual = 179,
+        OpFOrdEqual = 180,
+        OpFUnordEqual = 181,
+        OpFOrdNotEqual = 182,
+        OpFUnordNotEqual = 183,
+        OpFOrdLessThan = 184,
+        OpFUnordLessThan = 185,
+        OpFOrdGreaterThan = 186,
+        OpFUnordGreaterThan = 187,
+        OpFOrdLessThanEqual = 188,
+        OpFUnordLessThanEqual = 189,
+        OpFOrdGreaterThanEqual = 190,
+        OpFUnordGreaterThanEqual = 191,
+        OpShiftRightLogical = 194,
+        OpShiftRightArithmetic = 195,
+        OpShiftLeftLogical = 196,
+        OpBitwiseOr = 197,
+        OpBitwiseXor = 198,
+        OpBitwiseAnd = 199,
+        OpNot = 200,
+        OpBitFieldInsert = 201,
+        OpBitFieldSExtract = 202,
+        OpBitFieldUExtract = 203,
+        OpBitReverse = 204,
+        OpBitCount = 205,
+        OpDPdx = 207,
+        OpDPdy = 208,
+        OpFwidth = 209,
+        OpDPdxFine = 210,
+        OpDPdyFine = 211,
+        OpFwidthFine = 212,
+        OpDPdxCoarse = 213,
+        OpDPdyCoarse = 214,
+        OpFwidthCoarse = 215,
+        OpEmitVertex = 218,
+        OpEndPrimitive = 219,
+        OpEmitStreamVertex = 220,
+        OpEndStreamPrimitive = 221,
+        OpControlBarrier = 224,
+        OpMemoryBarrier = 225,
+        OpAtomicLoad = 227,
+        OpAtomicStore = 228,
+        OpAtomicExchange = 229,
+        OpAtomicCompareExchange = 230,
+        OpAtomicCompareExchangeWeak = 231,
+        OpAtomicIIncrement = 232,
+        OpAtomicIDecrement = 233,
+        OpAtomicIAdd = 234,
+        OpAtomicISub = 235,
+        OpAtomicSMin = 236,
+        OpAtomicUMin = 237,
+        OpAtomicSMax = 238,
+        OpAtomicUMax = 239,
+        OpAtomicAnd = 240,
+        OpAtomicOr = 241,
+        OpAtomicXor = 242,
+        OpPhi = 245,
+        OpLoopMerge = 246,
+        OpSelectionMerge = 247,
+        OpLabel = 248,
+        OpBranch = 249,
+        OpBranchConditional = 250,
+        OpSwitch = 251,
+        OpKill = 252,
+        OpReturn = 253,
+        OpReturnValue = 254,
+        OpUnreachable = 255,
+        OpLifetimeStart = 256,
+        OpLifetimeStop = 257,
+        OpGroupAsyncCopy = 259,
+        OpGroupWaitEvents = 260,
+        OpGroupAll = 261,
+        OpGroupAny = 262,
+        OpGroupBroadcast = 263,
+        OpGroupIAdd = 264,
+        OpGroupFAdd = 265,
+        OpGroupFMin = 266,
+        OpGroupUMin = 267,
+        OpGroupSMin = 268,
+        OpGroupFMax = 269,
+        OpGroupUMax = 270,
+        OpGroupSMax = 271,
+        OpReadPipe = 274,
+        OpWritePipe = 275,
+        OpReservedReadPipe = 276,
+        OpReservedWritePipe = 277,
+        OpReserveReadPipePackets = 278,
+        OpReserveWritePipePackets = 279,
+        OpCommitReadPipe = 280,
+        OpCommitWritePipe = 281,
+        OpIsValidReserveId = 282,
+        OpGetNumPipePackets = 283,
+        OpGetMaxPipePackets = 284,
+        OpGroupReserveReadPipePackets = 285,
+        OpGroupReserveWritePipePackets = 286,
+        OpGroupCommitReadPipe = 287,
+        OpGroupCommitWritePipe = 288,
+        OpEnqueueMarker = 291,
+        OpEnqueueKernel = 292,
+        OpGetKernelNDrangeSubGroupCount = 293,
+        OpGetKernelNDrangeMaxSubGroupSize = 294,
+        OpGetKernelWorkGroupSize = 295,
+        OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+        OpRetainEvent = 297,
+        OpReleaseEvent = 298,
+        OpCreateUserEvent = 299,
+        OpIsValidEvent = 300,
+        OpSetUserEventStatus = 301,
+        OpCaptureEventProfilingInfo = 302,
+        OpGetDefaultQueue = 303,
+        OpBuildNDRange = 304,
+        OpImageSparseSampleImplicitLod = 305,
+        OpImageSparseSampleExplicitLod = 306,
+        OpImageSparseSampleDrefImplicitLod = 307,
+        OpImageSparseSampleDrefExplicitLod = 308,
+        OpImageSparseSampleProjImplicitLod = 309,
+        OpImageSparseSampleProjExplicitLod = 310,
+        OpImageSparseSampleProjDrefImplicitLod = 311,
+        OpImageSparseSampleProjDrefExplicitLod = 312,
+        OpImageSparseFetch = 313,
+        OpImageSparseGather = 314,
+        OpImageSparseDrefGather = 315,
+        OpImageSparseTexelsResident = 316,
+        OpNoLine = 317,
+        OpAtomicFlagTestAndSet = 318,
+        OpAtomicFlagClear = 319,
+        OpImageSparseRead = 320,
+        OpSizeOf = 321,
+        OpTypePipeStorage = 322,
+        OpConstantPipeStorage = 323,
+        OpCreatePipeFromPipeStorage = 324,
+        OpGetKernelLocalSizeForSubgroupCount = 325,
+        OpGetKernelMaxNumSubgroups = 326,
+        OpTypeNamedBarrier = 327,
+        OpNamedBarrierInitialize = 328,
+        OpMemoryNamedBarrier = 329,
+        OpModuleProcessed = 330,
+        OpExecutionModeId = 331,
+        OpDecorateId = 332,
+        OpSubgroupBallotKHR = 4421,
+        OpSubgroupFirstInvocationKHR = 4422,
+        OpSubgroupAllKHR = 4428,
+        OpSubgroupAnyKHR = 4429,
+        OpSubgroupAllEqualKHR = 4430,
+        OpSubgroupReadInvocationKHR = 4432,
+        OpGroupIAddNonUniformAMD = 5000,
+        OpGroupFAddNonUniformAMD = 5001,
+        OpGroupFMinNonUniformAMD = 5002,
+        OpGroupUMinNonUniformAMD = 5003,
+        OpGroupSMinNonUniformAMD = 5004,
+        OpGroupFMaxNonUniformAMD = 5005,
+        OpGroupUMaxNonUniformAMD = 5006,
+        OpGroupSMaxNonUniformAMD = 5007,
+        OpFragmentMaskFetchAMD = 5011,
+        OpFragmentFetchAMD = 5012,
+        OpSubgroupShuffleINTEL = 5571,
+        OpSubgroupShuffleDownINTEL = 5572,
+        OpSubgroupShuffleUpINTEL = 5573,
+        OpSubgroupShuffleXorINTEL = 5574,
+        OpSubgroupBlockReadINTEL = 5575,
+        OpSubgroupBlockWriteINTEL = 5576,
+        OpSubgroupImageBlockReadINTEL = 5577,
+        OpSubgroupImageBlockWriteINTEL = 5578,
+        OpDecorateStringGOOGLE = 5632,
+        OpMemberDecorateStringGOOGLE = 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/1.2/spirv.py

@@ -0,0 +1,977 @@
+# Copyright (c) 2014-2018 The Khronos Group Inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and/or associated documentation files (the "Materials"),
+# to deal in the Materials without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Materials, and to permit persons to whom the
+# Materials are furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Materials.
+# 
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+# STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+# HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+# 
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+# IN THE MATERIALS.
+
+# This header is automatically generated by the same tool that creates
+# the Binary Section of the SPIR-V specification.
+
+# Enumeration tokens for SPIR-V, in various styles:
+#   C, C++, C++11, JSON, Lua, Python
+# 
+# - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+# - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+# - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+# - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+# - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+# 
+# Some tokens act like mask values, which can be OR'd together,
+# while others are mutually exclusive.  The mask-like ones have
+# "Mask" in their name, and a parallel enum that has the shift
+# amount (1 << x) for each corresponding enumerant.
+
+spv = {
+    'MagicNumber' : 0x07230203,
+    'Version' : 0x00010200,
+    'Revision' : 2,
+    'OpCodeMask' : 0xffff,
+    'WordCountShift' : 16,
+
+    'SourceLanguage' : {
+        'Unknown' : 0,
+        'ESSL' : 1,
+        'GLSL' : 2,
+        'OpenCL_C' : 3,
+        'OpenCL_CPP' : 4,
+        'HLSL' : 5,
+    },
+
+    'ExecutionModel' : {
+        'Vertex' : 0,
+        'TessellationControl' : 1,
+        'TessellationEvaluation' : 2,
+        'Geometry' : 3,
+        'Fragment' : 4,
+        'GLCompute' : 5,
+        'Kernel' : 6,
+    },
+
+    'AddressingModel' : {
+        'Logical' : 0,
+        'Physical32' : 1,
+        'Physical64' : 2,
+    },
+
+    'MemoryModel' : {
+        'Simple' : 0,
+        'GLSL450' : 1,
+        'OpenCL' : 2,
+    },
+
+    'ExecutionMode' : {
+        'Invocations' : 0,
+        'SpacingEqual' : 1,
+        'SpacingFractionalEven' : 2,
+        'SpacingFractionalOdd' : 3,
+        'VertexOrderCw' : 4,
+        'VertexOrderCcw' : 5,
+        'PixelCenterInteger' : 6,
+        'OriginUpperLeft' : 7,
+        'OriginLowerLeft' : 8,
+        'EarlyFragmentTests' : 9,
+        'PointMode' : 10,
+        'Xfb' : 11,
+        'DepthReplacing' : 12,
+        'DepthGreater' : 14,
+        'DepthLess' : 15,
+        'DepthUnchanged' : 16,
+        'LocalSize' : 17,
+        'LocalSizeHint' : 18,
+        'InputPoints' : 19,
+        'InputLines' : 20,
+        'InputLinesAdjacency' : 21,
+        'Triangles' : 22,
+        'InputTrianglesAdjacency' : 23,
+        'Quads' : 24,
+        'Isolines' : 25,
+        'OutputVertices' : 26,
+        'OutputPoints' : 27,
+        'OutputLineStrip' : 28,
+        'OutputTriangleStrip' : 29,
+        'VecTypeHint' : 30,
+        'ContractionOff' : 31,
+        'Initializer' : 33,
+        'Finalizer' : 34,
+        'SubgroupSize' : 35,
+        'SubgroupsPerWorkgroup' : 36,
+        'SubgroupsPerWorkgroupId' : 37,
+        'LocalSizeId' : 38,
+        'LocalSizeHintId' : 39,
+        'PostDepthCoverage' : 4446,
+        'StencilRefReplacingEXT' : 5027,
+    },
+
+    'StorageClass' : {
+        'UniformConstant' : 0,
+        'Input' : 1,
+        'Uniform' : 2,
+        'Output' : 3,
+        'Workgroup' : 4,
+        'CrossWorkgroup' : 5,
+        'Private' : 6,
+        'Function' : 7,
+        'Generic' : 8,
+        'PushConstant' : 9,
+        'AtomicCounter' : 10,
+        'Image' : 11,
+        'StorageBuffer' : 12,
+    },
+
+    'Dim' : {
+        'Dim1D' : 0,
+        'Dim2D' : 1,
+        'Dim3D' : 2,
+        'Cube' : 3,
+        'Rect' : 4,
+        'Buffer' : 5,
+        'SubpassData' : 6,
+    },
+
+    'SamplerAddressingMode' : {
+        'None' : 0,
+        'ClampToEdge' : 1,
+        'Clamp' : 2,
+        'Repeat' : 3,
+        'RepeatMirrored' : 4,
+    },
+
+    'SamplerFilterMode' : {
+        'Nearest' : 0,
+        'Linear' : 1,
+    },
+
+    'ImageFormat' : {
+        'Unknown' : 0,
+        'Rgba32f' : 1,
+        'Rgba16f' : 2,
+        'R32f' : 3,
+        'Rgba8' : 4,
+        'Rgba8Snorm' : 5,
+        'Rg32f' : 6,
+        'Rg16f' : 7,
+        'R11fG11fB10f' : 8,
+        'R16f' : 9,
+        'Rgba16' : 10,
+        'Rgb10A2' : 11,
+        'Rg16' : 12,
+        'Rg8' : 13,
+        'R16' : 14,
+        'R8' : 15,
+        'Rgba16Snorm' : 16,
+        'Rg16Snorm' : 17,
+        'Rg8Snorm' : 18,
+        'R16Snorm' : 19,
+        'R8Snorm' : 20,
+        'Rgba32i' : 21,
+        'Rgba16i' : 22,
+        'Rgba8i' : 23,
+        'R32i' : 24,
+        'Rg32i' : 25,
+        'Rg16i' : 26,
+        'Rg8i' : 27,
+        'R16i' : 28,
+        'R8i' : 29,
+        'Rgba32ui' : 30,
+        'Rgba16ui' : 31,
+        'Rgba8ui' : 32,
+        'R32ui' : 33,
+        'Rgb10a2ui' : 34,
+        'Rg32ui' : 35,
+        'Rg16ui' : 36,
+        'Rg8ui' : 37,
+        'R16ui' : 38,
+        'R8ui' : 39,
+    },
+
+    'ImageChannelOrder' : {
+        'R' : 0,
+        'A' : 1,
+        'RG' : 2,
+        'RA' : 3,
+        'RGB' : 4,
+        'RGBA' : 5,
+        'BGRA' : 6,
+        'ARGB' : 7,
+        'Intensity' : 8,
+        'Luminance' : 9,
+        'Rx' : 10,
+        'RGx' : 11,
+        'RGBx' : 12,
+        'Depth' : 13,
+        'DepthStencil' : 14,
+        'sRGB' : 15,
+        'sRGBx' : 16,
+        'sRGBA' : 17,
+        'sBGRA' : 18,
+        'ABGR' : 19,
+    },
+
+    'ImageChannelDataType' : {
+        'SnormInt8' : 0,
+        'SnormInt16' : 1,
+        'UnormInt8' : 2,
+        'UnormInt16' : 3,
+        'UnormShort565' : 4,
+        'UnormShort555' : 5,
+        'UnormInt101010' : 6,
+        'SignedInt8' : 7,
+        'SignedInt16' : 8,
+        'SignedInt32' : 9,
+        'UnsignedInt8' : 10,
+        'UnsignedInt16' : 11,
+        'UnsignedInt32' : 12,
+        'HalfFloat' : 13,
+        'Float' : 14,
+        'UnormInt24' : 15,
+        'UnormInt101010_2' : 16,
+    },
+
+    'ImageOperandsShift' : {
+        'Bias' : 0,
+        'Lod' : 1,
+        'Grad' : 2,
+        'ConstOffset' : 3,
+        'Offset' : 4,
+        'ConstOffsets' : 5,
+        'Sample' : 6,
+        'MinLod' : 7,
+    },
+
+    'ImageOperandsMask' : {
+        'MaskNone' : 0,
+        'Bias' : 0x00000001,
+        'Lod' : 0x00000002,
+        'Grad' : 0x00000004,
+        'ConstOffset' : 0x00000008,
+        'Offset' : 0x00000010,
+        'ConstOffsets' : 0x00000020,
+        'Sample' : 0x00000040,
+        'MinLod' : 0x00000080,
+    },
+
+    'FPFastMathModeShift' : {
+        'NotNaN' : 0,
+        'NotInf' : 1,
+        'NSZ' : 2,
+        'AllowRecip' : 3,
+        'Fast' : 4,
+    },
+
+    'FPFastMathModeMask' : {
+        'MaskNone' : 0,
+        'NotNaN' : 0x00000001,
+        'NotInf' : 0x00000002,
+        'NSZ' : 0x00000004,
+        'AllowRecip' : 0x00000008,
+        'Fast' : 0x00000010,
+    },
+
+    'FPRoundingMode' : {
+        'RTE' : 0,
+        'RTZ' : 1,
+        'RTP' : 2,
+        'RTN' : 3,
+    },
+
+    'LinkageType' : {
+        'Export' : 0,
+        'Import' : 1,
+    },
+
+    'AccessQualifier' : {
+        'ReadOnly' : 0,
+        'WriteOnly' : 1,
+        'ReadWrite' : 2,
+    },
+
+    'FunctionParameterAttribute' : {
+        'Zext' : 0,
+        'Sext' : 1,
+        'ByVal' : 2,
+        'Sret' : 3,
+        'NoAlias' : 4,
+        'NoCapture' : 5,
+        'NoWrite' : 6,
+        'NoReadWrite' : 7,
+    },
+
+    'Decoration' : {
+        'RelaxedPrecision' : 0,
+        'SpecId' : 1,
+        'Block' : 2,
+        'BufferBlock' : 3,
+        'RowMajor' : 4,
+        'ColMajor' : 5,
+        'ArrayStride' : 6,
+        'MatrixStride' : 7,
+        'GLSLShared' : 8,
+        'GLSLPacked' : 9,
+        'CPacked' : 10,
+        'BuiltIn' : 11,
+        'NoPerspective' : 13,
+        'Flat' : 14,
+        'Patch' : 15,
+        'Centroid' : 16,
+        'Sample' : 17,
+        'Invariant' : 18,
+        'Restrict' : 19,
+        'Aliased' : 20,
+        'Volatile' : 21,
+        'Constant' : 22,
+        'Coherent' : 23,
+        'NonWritable' : 24,
+        'NonReadable' : 25,
+        'Uniform' : 26,
+        'SaturatedConversion' : 28,
+        'Stream' : 29,
+        'Location' : 30,
+        'Component' : 31,
+        'Index' : 32,
+        'Binding' : 33,
+        'DescriptorSet' : 34,
+        'Offset' : 35,
+        'XfbBuffer' : 36,
+        'XfbStride' : 37,
+        'FuncParamAttr' : 38,
+        'FPRoundingMode' : 39,
+        'FPFastMathMode' : 40,
+        'LinkageAttributes' : 41,
+        'NoContraction' : 42,
+        'InputAttachmentIndex' : 43,
+        'Alignment' : 44,
+        'MaxByteOffset' : 45,
+        'AlignmentId' : 46,
+        'MaxByteOffsetId' : 47,
+        'ExplicitInterpAMD' : 4999,
+        'OverrideCoverageNV' : 5248,
+        'PassthroughNV' : 5250,
+        'ViewportRelativeNV' : 5252,
+        'SecondaryViewportRelativeNV' : 5256,
+        'HlslCounterBufferGOOGLE' : 5634,
+        'HlslSemanticGOOGLE' : 5635,
+    },
+
+    'BuiltIn' : {
+        'Position' : 0,
+        'PointSize' : 1,
+        'ClipDistance' : 3,
+        'CullDistance' : 4,
+        'VertexId' : 5,
+        'InstanceId' : 6,
+        'PrimitiveId' : 7,
+        'InvocationId' : 8,
+        'Layer' : 9,
+        'ViewportIndex' : 10,
+        'TessLevelOuter' : 11,
+        'TessLevelInner' : 12,
+        'TessCoord' : 13,
+        'PatchVertices' : 14,
+        'FragCoord' : 15,
+        'PointCoord' : 16,
+        'FrontFacing' : 17,
+        'SampleId' : 18,
+        'SamplePosition' : 19,
+        'SampleMask' : 20,
+        'FragDepth' : 22,
+        'HelperInvocation' : 23,
+        'NumWorkgroups' : 24,
+        'WorkgroupSize' : 25,
+        'WorkgroupId' : 26,
+        'LocalInvocationId' : 27,
+        'GlobalInvocationId' : 28,
+        'LocalInvocationIndex' : 29,
+        'WorkDim' : 30,
+        'GlobalSize' : 31,
+        'EnqueuedWorkgroupSize' : 32,
+        'GlobalOffset' : 33,
+        'GlobalLinearId' : 34,
+        'SubgroupSize' : 36,
+        'SubgroupMaxSize' : 37,
+        'NumSubgroups' : 38,
+        'NumEnqueuedSubgroups' : 39,
+        'SubgroupId' : 40,
+        'SubgroupLocalInvocationId' : 41,
+        'VertexIndex' : 42,
+        'InstanceIndex' : 43,
+        'SubgroupEqMaskKHR' : 4416,
+        'SubgroupGeMaskKHR' : 4417,
+        'SubgroupGtMaskKHR' : 4418,
+        'SubgroupLeMaskKHR' : 4419,
+        'SubgroupLtMaskKHR' : 4420,
+        'BaseVertex' : 4424,
+        'BaseInstance' : 4425,
+        'DrawIndex' : 4426,
+        'DeviceIndex' : 4438,
+        'ViewIndex' : 4440,
+        'BaryCoordNoPerspAMD' : 4992,
+        'BaryCoordNoPerspCentroidAMD' : 4993,
+        'BaryCoordNoPerspSampleAMD' : 4994,
+        'BaryCoordSmoothAMD' : 4995,
+        'BaryCoordSmoothCentroidAMD' : 4996,
+        'BaryCoordSmoothSampleAMD' : 4997,
+        'BaryCoordPullModelAMD' : 4998,
+        'FragStencilRefEXT' : 5014,
+        'ViewportMaskNV' : 5253,
+        'SecondaryPositionNV' : 5257,
+        'SecondaryViewportMaskNV' : 5258,
+        'PositionPerViewNV' : 5261,
+        'ViewportMaskPerViewNV' : 5262,
+    },
+
+    'SelectionControlShift' : {
+        'Flatten' : 0,
+        'DontFlatten' : 1,
+    },
+
+    'SelectionControlMask' : {
+        'MaskNone' : 0,
+        'Flatten' : 0x00000001,
+        'DontFlatten' : 0x00000002,
+    },
+
+    'LoopControlShift' : {
+        'Unroll' : 0,
+        'DontUnroll' : 1,
+        'DependencyInfinite' : 2,
+        'DependencyLength' : 3,
+    },
+
+    'LoopControlMask' : {
+        'MaskNone' : 0,
+        'Unroll' : 0x00000001,
+        'DontUnroll' : 0x00000002,
+        'DependencyInfinite' : 0x00000004,
+        'DependencyLength' : 0x00000008,
+    },
+
+    'FunctionControlShift' : {
+        'Inline' : 0,
+        'DontInline' : 1,
+        'Pure' : 2,
+        'Const' : 3,
+    },
+
+    'FunctionControlMask' : {
+        'MaskNone' : 0,
+        'Inline' : 0x00000001,
+        'DontInline' : 0x00000002,
+        'Pure' : 0x00000004,
+        'Const' : 0x00000008,
+    },
+
+    'MemorySemanticsShift' : {
+        'Acquire' : 1,
+        'Release' : 2,
+        'AcquireRelease' : 3,
+        'SequentiallyConsistent' : 4,
+        'UniformMemory' : 6,
+        'SubgroupMemory' : 7,
+        'WorkgroupMemory' : 8,
+        'CrossWorkgroupMemory' : 9,
+        'AtomicCounterMemory' : 10,
+        'ImageMemory' : 11,
+    },
+
+    'MemorySemanticsMask' : {
+        'MaskNone' : 0,
+        'Acquire' : 0x00000002,
+        'Release' : 0x00000004,
+        'AcquireRelease' : 0x00000008,
+        'SequentiallyConsistent' : 0x00000010,
+        'UniformMemory' : 0x00000040,
+        'SubgroupMemory' : 0x00000080,
+        'WorkgroupMemory' : 0x00000100,
+        'CrossWorkgroupMemory' : 0x00000200,
+        'AtomicCounterMemory' : 0x00000400,
+        'ImageMemory' : 0x00000800,
+    },
+
+    'MemoryAccessShift' : {
+        'Volatile' : 0,
+        'Aligned' : 1,
+        'Nontemporal' : 2,
+    },
+
+    'MemoryAccessMask' : {
+        'MaskNone' : 0,
+        'Volatile' : 0x00000001,
+        'Aligned' : 0x00000002,
+        'Nontemporal' : 0x00000004,
+    },
+
+    'Scope' : {
+        'CrossDevice' : 0,
+        'Device' : 1,
+        'Workgroup' : 2,
+        'Subgroup' : 3,
+        'Invocation' : 4,
+    },
+
+    'GroupOperation' : {
+        'Reduce' : 0,
+        'InclusiveScan' : 1,
+        'ExclusiveScan' : 2,
+    },
+
+    'KernelEnqueueFlags' : {
+        'NoWait' : 0,
+        'WaitKernel' : 1,
+        'WaitWorkGroup' : 2,
+    },
+
+    'KernelProfilingInfoShift' : {
+        'CmdExecTime' : 0,
+    },
+
+    'KernelProfilingInfoMask' : {
+        'MaskNone' : 0,
+        'CmdExecTime' : 0x00000001,
+    },
+
+    'Capability' : {
+        'Matrix' : 0,
+        'Shader' : 1,
+        'Geometry' : 2,
+        'Tessellation' : 3,
+        'Addresses' : 4,
+        'Linkage' : 5,
+        'Kernel' : 6,
+        'Vector16' : 7,
+        'Float16Buffer' : 8,
+        'Float16' : 9,
+        'Float64' : 10,
+        'Int64' : 11,
+        'Int64Atomics' : 12,
+        'ImageBasic' : 13,
+        'ImageReadWrite' : 14,
+        'ImageMipmap' : 15,
+        'Pipes' : 17,
+        'Groups' : 18,
+        'DeviceEnqueue' : 19,
+        'LiteralSampler' : 20,
+        'AtomicStorage' : 21,
+        'Int16' : 22,
+        'TessellationPointSize' : 23,
+        'GeometryPointSize' : 24,
+        'ImageGatherExtended' : 25,
+        'StorageImageMultisample' : 27,
+        'UniformBufferArrayDynamicIndexing' : 28,
+        'SampledImageArrayDynamicIndexing' : 29,
+        'StorageBufferArrayDynamicIndexing' : 30,
+        'StorageImageArrayDynamicIndexing' : 31,
+        'ClipDistance' : 32,
+        'CullDistance' : 33,
+        'ImageCubeArray' : 34,
+        'SampleRateShading' : 35,
+        'ImageRect' : 36,
+        'SampledRect' : 37,
+        'GenericPointer' : 38,
+        'Int8' : 39,
+        'InputAttachment' : 40,
+        'SparseResidency' : 41,
+        'MinLod' : 42,
+        'Sampled1D' : 43,
+        'Image1D' : 44,
+        'SampledCubeArray' : 45,
+        'SampledBuffer' : 46,
+        'ImageBuffer' : 47,
+        'ImageMSArray' : 48,
+        'StorageImageExtendedFormats' : 49,
+        'ImageQuery' : 50,
+        'DerivativeControl' : 51,
+        'InterpolationFunction' : 52,
+        'TransformFeedback' : 53,
+        'GeometryStreams' : 54,
+        'StorageImageReadWithoutFormat' : 55,
+        'StorageImageWriteWithoutFormat' : 56,
+        'MultiViewport' : 57,
+        'SubgroupDispatch' : 58,
+        'NamedBarrier' : 59,
+        'PipeStorage' : 60,
+        'SubgroupBallotKHR' : 4423,
+        'DrawParameters' : 4427,
+        'SubgroupVoteKHR' : 4431,
+        'StorageBuffer16BitAccess' : 4433,
+        'StorageUniformBufferBlock16' : 4433,
+        'StorageUniform16' : 4434,
+        'UniformAndStorageBuffer16BitAccess' : 4434,
+        'StoragePushConstant16' : 4435,
+        'StorageInputOutput16' : 4436,
+        'DeviceGroup' : 4437,
+        'MultiView' : 4439,
+        'VariablePointersStorageBuffer' : 4441,
+        'VariablePointers' : 4442,
+        'AtomicStorageOps' : 4445,
+        'SampleMaskPostDepthCoverage' : 4447,
+        'ImageGatherBiasLodAMD' : 5009,
+        'FragmentMaskAMD' : 5010,
+        'StencilExportEXT' : 5013,
+        'ImageReadWriteLodAMD' : 5015,
+        'SampleMaskOverrideCoverageNV' : 5249,
+        'GeometryShaderPassthroughNV' : 5251,
+        'ShaderViewportIndexLayerEXT' : 5254,
+        'ShaderViewportIndexLayerNV' : 5254,
+        'ShaderViewportMaskNV' : 5255,
+        'ShaderStereoViewNV' : 5259,
+        'PerViewAttributesNV' : 5260,
+        'SubgroupShuffleINTEL' : 5568,
+        'SubgroupBufferBlockIOINTEL' : 5569,
+        'SubgroupImageBlockIOINTEL' : 5570,
+    },
+
+    'Op' : {
+        'OpNop' : 0,
+        'OpUndef' : 1,
+        'OpSourceContinued' : 2,
+        'OpSource' : 3,
+        'OpSourceExtension' : 4,
+        'OpName' : 5,
+        'OpMemberName' : 6,
+        'OpString' : 7,
+        'OpLine' : 8,
+        'OpExtension' : 10,
+        'OpExtInstImport' : 11,
+        'OpExtInst' : 12,
+        'OpMemoryModel' : 14,
+        'OpEntryPoint' : 15,
+        'OpExecutionMode' : 16,
+        'OpCapability' : 17,
+        'OpTypeVoid' : 19,
+        'OpTypeBool' : 20,
+        'OpTypeInt' : 21,
+        'OpTypeFloat' : 22,
+        'OpTypeVector' : 23,
+        'OpTypeMatrix' : 24,
+        'OpTypeImage' : 25,
+        'OpTypeSampler' : 26,
+        'OpTypeSampledImage' : 27,
+        'OpTypeArray' : 28,
+        'OpTypeRuntimeArray' : 29,
+        'OpTypeStruct' : 30,
+        'OpTypeOpaque' : 31,
+        'OpTypePointer' : 32,
+        'OpTypeFunction' : 33,
+        'OpTypeEvent' : 34,
+        'OpTypeDeviceEvent' : 35,
+        'OpTypeReserveId' : 36,
+        'OpTypeQueue' : 37,
+        'OpTypePipe' : 38,
+        'OpTypeForwardPointer' : 39,
+        'OpConstantTrue' : 41,
+        'OpConstantFalse' : 42,
+        'OpConstant' : 43,
+        'OpConstantComposite' : 44,
+        'OpConstantSampler' : 45,
+        'OpConstantNull' : 46,
+        'OpSpecConstantTrue' : 48,
+        'OpSpecConstantFalse' : 49,
+        'OpSpecConstant' : 50,
+        'OpSpecConstantComposite' : 51,
+        'OpSpecConstantOp' : 52,
+        'OpFunction' : 54,
+        'OpFunctionParameter' : 55,
+        'OpFunctionEnd' : 56,
+        'OpFunctionCall' : 57,
+        'OpVariable' : 59,
+        'OpImageTexelPointer' : 60,
+        'OpLoad' : 61,
+        'OpStore' : 62,
+        'OpCopyMemory' : 63,
+        'OpCopyMemorySized' : 64,
+        'OpAccessChain' : 65,
+        'OpInBoundsAccessChain' : 66,
+        'OpPtrAccessChain' : 67,
+        'OpArrayLength' : 68,
+        'OpGenericPtrMemSemantics' : 69,
+        'OpInBoundsPtrAccessChain' : 70,
+        'OpDecorate' : 71,
+        'OpMemberDecorate' : 72,
+        'OpDecorationGroup' : 73,
+        'OpGroupDecorate' : 74,
+        'OpGroupMemberDecorate' : 75,
+        'OpVectorExtractDynamic' : 77,
+        'OpVectorInsertDynamic' : 78,
+        'OpVectorShuffle' : 79,
+        'OpCompositeConstruct' : 80,
+        'OpCompositeExtract' : 81,
+        'OpCompositeInsert' : 82,
+        'OpCopyObject' : 83,
+        'OpTranspose' : 84,
+        'OpSampledImage' : 86,
+        'OpImageSampleImplicitLod' : 87,
+        'OpImageSampleExplicitLod' : 88,
+        'OpImageSampleDrefImplicitLod' : 89,
+        'OpImageSampleDrefExplicitLod' : 90,
+        'OpImageSampleProjImplicitLod' : 91,
+        'OpImageSampleProjExplicitLod' : 92,
+        'OpImageSampleProjDrefImplicitLod' : 93,
+        'OpImageSampleProjDrefExplicitLod' : 94,
+        'OpImageFetch' : 95,
+        'OpImageGather' : 96,
+        'OpImageDrefGather' : 97,
+        'OpImageRead' : 98,
+        'OpImageWrite' : 99,
+        'OpImage' : 100,
+        'OpImageQueryFormat' : 101,
+        'OpImageQueryOrder' : 102,
+        'OpImageQuerySizeLod' : 103,
+        'OpImageQuerySize' : 104,
+        'OpImageQueryLod' : 105,
+        'OpImageQueryLevels' : 106,
+        'OpImageQuerySamples' : 107,
+        'OpConvertFToU' : 109,
+        'OpConvertFToS' : 110,
+        'OpConvertSToF' : 111,
+        'OpConvertUToF' : 112,
+        'OpUConvert' : 113,
+        'OpSConvert' : 114,
+        'OpFConvert' : 115,
+        'OpQuantizeToF16' : 116,
+        'OpConvertPtrToU' : 117,
+        'OpSatConvertSToU' : 118,
+        'OpSatConvertUToS' : 119,
+        'OpConvertUToPtr' : 120,
+        'OpPtrCastToGeneric' : 121,
+        'OpGenericCastToPtr' : 122,
+        'OpGenericCastToPtrExplicit' : 123,
+        'OpBitcast' : 124,
+        'OpSNegate' : 126,
+        'OpFNegate' : 127,
+        'OpIAdd' : 128,
+        'OpFAdd' : 129,
+        'OpISub' : 130,
+        'OpFSub' : 131,
+        'OpIMul' : 132,
+        'OpFMul' : 133,
+        'OpUDiv' : 134,
+        'OpSDiv' : 135,
+        'OpFDiv' : 136,
+        'OpUMod' : 137,
+        'OpSRem' : 138,
+        'OpSMod' : 139,
+        'OpFRem' : 140,
+        'OpFMod' : 141,
+        'OpVectorTimesScalar' : 142,
+        'OpMatrixTimesScalar' : 143,
+        'OpVectorTimesMatrix' : 144,
+        'OpMatrixTimesVector' : 145,
+        'OpMatrixTimesMatrix' : 146,
+        'OpOuterProduct' : 147,
+        'OpDot' : 148,
+        'OpIAddCarry' : 149,
+        'OpISubBorrow' : 150,
+        'OpUMulExtended' : 151,
+        'OpSMulExtended' : 152,
+        'OpAny' : 154,
+        'OpAll' : 155,
+        'OpIsNan' : 156,
+        'OpIsInf' : 157,
+        'OpIsFinite' : 158,
+        'OpIsNormal' : 159,
+        'OpSignBitSet' : 160,
+        'OpLessOrGreater' : 161,
+        'OpOrdered' : 162,
+        'OpUnordered' : 163,
+        'OpLogicalEqual' : 164,
+        'OpLogicalNotEqual' : 165,
+        'OpLogicalOr' : 166,
+        'OpLogicalAnd' : 167,
+        'OpLogicalNot' : 168,
+        'OpSelect' : 169,
+        'OpIEqual' : 170,
+        'OpINotEqual' : 171,
+        'OpUGreaterThan' : 172,
+        'OpSGreaterThan' : 173,
+        'OpUGreaterThanEqual' : 174,
+        'OpSGreaterThanEqual' : 175,
+        'OpULessThan' : 176,
+        'OpSLessThan' : 177,
+        'OpULessThanEqual' : 178,
+        'OpSLessThanEqual' : 179,
+        'OpFOrdEqual' : 180,
+        'OpFUnordEqual' : 181,
+        'OpFOrdNotEqual' : 182,
+        'OpFUnordNotEqual' : 183,
+        'OpFOrdLessThan' : 184,
+        'OpFUnordLessThan' : 185,
+        'OpFOrdGreaterThan' : 186,
+        'OpFUnordGreaterThan' : 187,
+        'OpFOrdLessThanEqual' : 188,
+        'OpFUnordLessThanEqual' : 189,
+        'OpFOrdGreaterThanEqual' : 190,
+        'OpFUnordGreaterThanEqual' : 191,
+        'OpShiftRightLogical' : 194,
+        'OpShiftRightArithmetic' : 195,
+        'OpShiftLeftLogical' : 196,
+        'OpBitwiseOr' : 197,
+        'OpBitwiseXor' : 198,
+        'OpBitwiseAnd' : 199,
+        'OpNot' : 200,
+        'OpBitFieldInsert' : 201,
+        'OpBitFieldSExtract' : 202,
+        'OpBitFieldUExtract' : 203,
+        'OpBitReverse' : 204,
+        'OpBitCount' : 205,
+        'OpDPdx' : 207,
+        'OpDPdy' : 208,
+        'OpFwidth' : 209,
+        'OpDPdxFine' : 210,
+        'OpDPdyFine' : 211,
+        'OpFwidthFine' : 212,
+        'OpDPdxCoarse' : 213,
+        'OpDPdyCoarse' : 214,
+        'OpFwidthCoarse' : 215,
+        'OpEmitVertex' : 218,
+        'OpEndPrimitive' : 219,
+        'OpEmitStreamVertex' : 220,
+        'OpEndStreamPrimitive' : 221,
+        'OpControlBarrier' : 224,
+        'OpMemoryBarrier' : 225,
+        'OpAtomicLoad' : 227,
+        'OpAtomicStore' : 228,
+        'OpAtomicExchange' : 229,
+        'OpAtomicCompareExchange' : 230,
+        'OpAtomicCompareExchangeWeak' : 231,
+        'OpAtomicIIncrement' : 232,
+        'OpAtomicIDecrement' : 233,
+        'OpAtomicIAdd' : 234,
+        'OpAtomicISub' : 235,
+        'OpAtomicSMin' : 236,
+        'OpAtomicUMin' : 237,
+        'OpAtomicSMax' : 238,
+        'OpAtomicUMax' : 239,
+        'OpAtomicAnd' : 240,
+        'OpAtomicOr' : 241,
+        'OpAtomicXor' : 242,
+        'OpPhi' : 245,
+        'OpLoopMerge' : 246,
+        'OpSelectionMerge' : 247,
+        'OpLabel' : 248,
+        'OpBranch' : 249,
+        'OpBranchConditional' : 250,
+        'OpSwitch' : 251,
+        'OpKill' : 252,
+        'OpReturn' : 253,
+        'OpReturnValue' : 254,
+        'OpUnreachable' : 255,
+        'OpLifetimeStart' : 256,
+        'OpLifetimeStop' : 257,
+        'OpGroupAsyncCopy' : 259,
+        'OpGroupWaitEvents' : 260,
+        'OpGroupAll' : 261,
+        'OpGroupAny' : 262,
+        'OpGroupBroadcast' : 263,
+        'OpGroupIAdd' : 264,
+        'OpGroupFAdd' : 265,
+        'OpGroupFMin' : 266,
+        'OpGroupUMin' : 267,
+        'OpGroupSMin' : 268,
+        'OpGroupFMax' : 269,
+        'OpGroupUMax' : 270,
+        'OpGroupSMax' : 271,
+        'OpReadPipe' : 274,
+        'OpWritePipe' : 275,
+        'OpReservedReadPipe' : 276,
+        'OpReservedWritePipe' : 277,
+        'OpReserveReadPipePackets' : 278,
+        'OpReserveWritePipePackets' : 279,
+        'OpCommitReadPipe' : 280,
+        'OpCommitWritePipe' : 281,
+        'OpIsValidReserveId' : 282,
+        'OpGetNumPipePackets' : 283,
+        'OpGetMaxPipePackets' : 284,
+        'OpGroupReserveReadPipePackets' : 285,
+        'OpGroupReserveWritePipePackets' : 286,
+        'OpGroupCommitReadPipe' : 287,
+        'OpGroupCommitWritePipe' : 288,
+        'OpEnqueueMarker' : 291,
+        'OpEnqueueKernel' : 292,
+        'OpGetKernelNDrangeSubGroupCount' : 293,
+        'OpGetKernelNDrangeMaxSubGroupSize' : 294,
+        'OpGetKernelWorkGroupSize' : 295,
+        'OpGetKernelPreferredWorkGroupSizeMultiple' : 296,
+        'OpRetainEvent' : 297,
+        'OpReleaseEvent' : 298,
+        'OpCreateUserEvent' : 299,
+        'OpIsValidEvent' : 300,
+        'OpSetUserEventStatus' : 301,
+        'OpCaptureEventProfilingInfo' : 302,
+        'OpGetDefaultQueue' : 303,
+        'OpBuildNDRange' : 304,
+        'OpImageSparseSampleImplicitLod' : 305,
+        'OpImageSparseSampleExplicitLod' : 306,
+        'OpImageSparseSampleDrefImplicitLod' : 307,
+        'OpImageSparseSampleDrefExplicitLod' : 308,
+        'OpImageSparseSampleProjImplicitLod' : 309,
+        'OpImageSparseSampleProjExplicitLod' : 310,
+        'OpImageSparseSampleProjDrefImplicitLod' : 311,
+        'OpImageSparseSampleProjDrefExplicitLod' : 312,
+        'OpImageSparseFetch' : 313,
+        'OpImageSparseGather' : 314,
+        'OpImageSparseDrefGather' : 315,
+        'OpImageSparseTexelsResident' : 316,
+        'OpNoLine' : 317,
+        'OpAtomicFlagTestAndSet' : 318,
+        'OpAtomicFlagClear' : 319,
+        'OpImageSparseRead' : 320,
+        'OpSizeOf' : 321,
+        'OpTypePipeStorage' : 322,
+        'OpConstantPipeStorage' : 323,
+        'OpCreatePipeFromPipeStorage' : 324,
+        'OpGetKernelLocalSizeForSubgroupCount' : 325,
+        'OpGetKernelMaxNumSubgroups' : 326,
+        'OpTypeNamedBarrier' : 327,
+        'OpNamedBarrierInitialize' : 328,
+        'OpMemoryNamedBarrier' : 329,
+        'OpModuleProcessed' : 330,
+        'OpExecutionModeId' : 331,
+        'OpDecorateId' : 332,
+        'OpSubgroupBallotKHR' : 4421,
+        'OpSubgroupFirstInvocationKHR' : 4422,
+        'OpSubgroupAllKHR' : 4428,
+        'OpSubgroupAnyKHR' : 4429,
+        'OpSubgroupAllEqualKHR' : 4430,
+        'OpSubgroupReadInvocationKHR' : 4432,
+        'OpGroupIAddNonUniformAMD' : 5000,
+        'OpGroupFAddNonUniformAMD' : 5001,
+        'OpGroupFMinNonUniformAMD' : 5002,
+        'OpGroupUMinNonUniformAMD' : 5003,
+        'OpGroupSMinNonUniformAMD' : 5004,
+        'OpGroupFMaxNonUniformAMD' : 5005,
+        'OpGroupUMaxNonUniformAMD' : 5006,
+        'OpGroupSMaxNonUniformAMD' : 5007,
+        'OpFragmentMaskFetchAMD' : 5011,
+        'OpFragmentFetchAMD' : 5012,
+        'OpSubgroupShuffleINTEL' : 5571,
+        'OpSubgroupShuffleDownINTEL' : 5572,
+        'OpSubgroupShuffleUpINTEL' : 5573,
+        'OpSubgroupShuffleXorINTEL' : 5574,
+        'OpSubgroupBlockReadINTEL' : 5575,
+        'OpSubgroupBlockWriteINTEL' : 5576,
+        'OpSubgroupImageBlockReadINTEL' : 5577,
+        'OpSubgroupImageBlockWriteINTEL' : 5578,
+        'OpDecorateStringGOOGLE' : 5632,
+        'OpMemberDecorateStringGOOGLE' : 5633,
+    },
+
+}
+

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/spir-v.xml

@@ -0,0 +1,300 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<registry>
+    <!--
+    Copyright (c) 2015-2024 The Khronos Group Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and/or associated documentation files (the
+    "Materials"), to deal in the Materials without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Materials, and to
+    permit persons to whom the Materials are furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Materials.
+
+    THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+    -->
+    <!--
+    This file, spir-v.xml, is the SPIR-V Tool ID, opcode and enumerant registry.
+    The canonical version of the registry, together with related schema and
+    documentation, can be found in the Khronos Registry at
+    include/spirv/spir-v.xml in the master branch at
+    https://github.com/KhronosGroup/SPIRV-Headers
+    -->
+
+    <!-- SECTION: SPIR-V Tool ID Definitions  -->
+
+    <!-- A SPIR-V Generator Magic Number is a 32 bit word: The high order 16
+         bits are a tool ID, which should be unique across all SPIR-V
+         generators. The low order 16 bits are reserved for use as a tool
+         version number, or any other purpose the tool supplier chooses.
+         Only the tool IDs are reserved with Khronos.
+
+         Add new tool ID reservations contiguously with the first available
+         number (the "start" attribute of the <unused> tag below), and
+         modify that <unused> tag accordingly. Please add a vendor/tool
+         supplier name in a 'vendor="name"' attribute; a tool name in a
+         'tool="name"' attribute; and a contact person/address in a
+         'comment' attribute. Remember that this value is the high 16 bits
+         of a 32-bit word.
+
+         Note: a single vendor/tool supplier may have multiple tool IDs
+         reserved for different SPIR-V generators -->
+
+    <ids type="vendor" start="0" end="0xFFFF" comment="SPIR-V Tool IDs">
+        <id value="0"   vendor="Khronos"    comment="Reserved by Khronos"/>
+        <id value="1"   vendor="LunarG"     comment="Contact TBD"/>
+        <id value="2"   vendor="Valve"      comment="Contact TBD"/>
+        <id value="3"   vendor="Codeplay"   comment="Contact Victor Lomuller, victor@codeplay.com"/>
+        <id value="4"   vendor="NVIDIA"     comment="Contact Kerch Holt, kholt@nvidia.com"/>
+        <id value="5"   vendor="ARM"        comment="Contact Kevin Petit, kevin.petit@arm.com"/>
+        <id value="6"   vendor="Khronos" tool="LLVM/SPIR-V Translator" comment="Contact Yaxun (Sam) Liu, yaxun.liu@amd.com"/>
+        <id value="7"   vendor="Khronos" tool="SPIR-V Tools Assembler" comment="Contact David Neto, dneto@google.com"/>
+        <id value="8"   vendor="Khronos" tool="Glslang Reference Front End" comment="Contact John Kessenich, johnkessenich@google.com"/>
+        <id value="9"   vendor="Qualcomm"   comment="Contact weifengz@qti.qualcomm.com"/>
+        <id value="10"  vendor="AMD"        comment="Contact Daniel Rakos, daniel.rakos@amd.com"/>
+        <id value="11"  vendor="Intel"      comment="Contact Alexey, alexey.bader@intel.com"/>
+        <id value="12"  vendor="Imagination" comment="Contact Stephen Clarke, stephen.clarke@imgtec.com"/>
+        <id value="13"  vendor="Google" tool="Shaderc over Glslang" comment="Contact David Neto, dneto@google.com"/>
+        <id value="14"  vendor="Google" tool="spiregg" comment="Contact Steven Perron, stevenperron@google.com"/>
+        <id value="15"  vendor="Google" tool="rspirv" comment="Contact Lei Zhang, antiagainst@gmail.com"/>
+        <id value="16"  vendor="X-LEGEND"   tool="Mesa-IR/SPIR-V Translator" comment="Contact Metora Wang, github:metora/MesaGLSLCompiler"/>
+        <id value="17"  vendor="Khronos" tool="SPIR-V Tools Linker" comment="Contact David Neto, dneto@google.com"/>
+        <id value="18"  vendor="Wine" tool="VKD3D Shader Compiler" comment="Contact wine-devel@winehq.org"/>
+        <id value="19"  vendor="Tellusim" tool="Clay Shader Compiler" comment="Contact info@tellusim.com"/>
+        <id value="20"  vendor="W3C WebGPU Group" tool="WHLSL Shader Translator" comment="https://github.com/gpuweb/WHLSL"/>
+        <id value="21"  vendor="Google" tool="Clspv" comment="Contact David Neto, dneto@google.com"/>
+        <id value="22"  vendor="LLVM" tool="MLIR SPIR-V Serializer" comment="Contact Jakub Kuderski, jakub.kuderski@amd.com, https://mlir.llvm.org/docs/Dialects/SPIR-V/"/>
+        <id value="23"  vendor="Google" tool="Tint Compiler" comment="Contact David Neto, dneto@google.com"/>
+        <id value="24"  vendor="Google" tool="ANGLE Shader Compiler" comment="Contact Shahbaz Youssefi, syoussefi@google.com"/>
+        <id value="25"  vendor="Netease Games" tool="Messiah Shader Compiler" comment="Contact Yuwen Wu, atyuwen@gmail.com"/>
+        <id value="26"  vendor="Xenia" tool="Xenia Emulator Microcode Translator" comment="Contact Vitaliy Kuzmin, triang3l@yandex.ru, https://github.com/xenia-project/xenia"/>
+        <id value="27"  vendor="Embark Studios" tool="Rust GPU Compiler Backend" comment="https://github.com/embarkstudios/rust-gpu"/>
+        <id value="28"  vendor="gfx-rs community" tool="Naga" comment="https://github.com/gfx-rs/naga"/>
+        <id value="29"  vendor="Mikkosoft Productions" tool="MSP Shader Compiler" comment="Contact Mikko Rasa, tdb@tdb.fi"/>
+        <id value="30"  vendor="SpvGenTwo community" tool="SpvGenTwo SPIR-V IR Tools" comment="https://github.com/rAzoR8/SpvGenTwo"/>
+        <id value="31"  vendor="Google" tool="Skia SkSL" comment="Contact Ethan Nicholas, ethannicholas@google.com"/>
+        <id value="32"  vendor="TornadoVM" tool="Beehive SPIRV Toolkit" comment="https://github.com/beehive-lab/beehive-spirv-toolkit"/>
+        <id value="33"  vendor="DragonJoker" tool="ShaderWriter" comment="Contact Sylvain Doremus, https://github.com/DragonJoker/ShaderWriter"/>
+        <id value="34"  vendor="Rayan Hatout" tool="SPIRVSmith" comment="Contact Rayan Hatout rayan.hatout@gmail.com, Repo https://github.com/rayanht/SPIRVSmith"/>
+        <id value="35"  vendor="Saarland University" tool="Shady" comment="Contact Hugo Devillers devillers@uni-saarland.de, Repo https://github.com/Hugobros3/shady"/>
+        <id value="36"  vendor="Taichi Graphics" tool="Taichi" comment="Contact Rendong Liang rendongliang@taichi.graphics, Repo https://github.com/taichi-dev/taichi"/>
+        <id value="37"  vendor="heroseh" tool="Hero C Compiler" comment="https://github.com/heroseh/hcc"/>
+        <id value="38"  vendor="Meta" tool="SparkSL" comment="Contact Dunfan Lu, dunfanlu@meta.com, https://sparkar.facebook.com/ar-studio/learn/sparksl/sparksl-overview"/>
+        <id value="39"  vendor="SirLynix" tool="Nazara ShaderLang Compiler" comment="Contact Jérôme Leclercq, https://github.com/NazaraEngine/ShaderLang"/>
+        <id value="40"  vendor="NVIDIA" tool="Slang Compiler" comment="Contact Theresa Foley, tfoley@nvidia.com, https://github.com/shader-slang/slang/"/>
+        <id value="41"  vendor="Zig Software Foundation" tool="Zig Compiler" comment="Contact Robin Voetter, https://github.com/Snektron"/>
+        <id value="42"  vendor="Rendong Liang" tool="spq" comment="Contact Rendong Liang, admin@penguinliong.moe, https://github.com/PENGUINLIONG/spq-rs"/>
+        <id value="43"  vendor="LLVM" tool="LLVM SPIR-V Backend" comment="Contact Michal Paszkowski, michal.paszkowski@intel.com, https://github.com/llvm/llvm-project/tree/main/llvm/lib/Target/SPIRV"/>
+        <id value="44"  vendor="Robert Konrad" tool="Kongruent" comment="Contact Robert Konrad, https://github.com/Kode/Kongruent"/>
+        <unused start="45" end="0xFFFF" comment="Tool ID range reservable for future use by vendors"/>
+    </ids>
+
+    <!-- SECTION: SPIR-V Opcodes and Enumerants -->
+
+    <!-- Vendors reserve new ranges of:
+           - opcode enumerants in the "opcode" list below, and
+           - non-opcode enumerants in the non-opcodes "enumerant" list below.
+         Both are reserved by contiguous blocks of 64, preceding the given
+         "Future use" blocks.
+
+         SPIR-V background:
+           - SPIR-V currently has well over 30 enums, including the opcode enum
+           - each enum has its own name space, allowing reuse of enumerants
+           - SPIR-V restricts opcode enumerants to 16 bits
+           - all other enums use 32-bit enumerants
+
+         Reservation rules:
+           - opcode reservations ("opcode") are only valid for opcodes
+           - non-opcode reservations ("enumerant") are not valid for opcodes
+           - reservations in the enumerant list are valid for all non-opcode enums
+           - it is simpler to use each non-opcode enumerant for only one purpose
+             but this is left to the discretion of the vendor
+           - all enumerants in a range should be used before allocating a new range
+             (several extensions can use enumerants from the same range)
+
+         Each vendor determines the use of enumerants in the ranges they
+         reserve. Vendors are not required to disclose those uses.  If the use
+         of an enumerant is included in an extension that is adopted by a Khronos
+         extension or specification, then that enumerant's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+
+         -->
+
+    <!-- Begin reservations of opcode enumerants -->
+    <ids type="opcode" start="0" end="4095" vendor="Khronos" comment="Reserved opcodes, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="opcode" start="4096" end="4159" vendor="Mesa" comment="Contact TBD"/>
+    <ids type="opcode" start="4160" end="4415" vendor="ARM" comment="Contact kevin.petit@arm.com"/>
+    <ids type="opcode" start="4416" end="4479" vendor="Khronos" comment="SPV_ARB_shader_ballot - contact Neil Henning, neil.henning@amd.com"/>
+    <ids type="opcode" start="4480" end="4991" vendor="Qualcomm" comment="Contact weifengz@qti.qualcomm.com"/>
+    <ids type="opcode" start="4992" end="5247" vendor="AMD"/>
+    <ids type="opcode" start="5248" end="5503" vendor="NVIDIA"/>
+    <ids type="opcode" start="5504" end="5567" vendor="Imagination"/>
+    <ids type="opcode" start="5568" end="5631" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="opcode" start="5632" end="5695" vendor="Google" comment="Contact dneto@google.com"/>
+    <ids type="opcode" start="5696" end="5823" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="opcode" start="5824" end="5951" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="opcode" start="5952" end="6015" vendor="Codeplay" comment="Contact victor@codeplay.com"/>
+    <ids type="opcode" start="6016" end="6079" vendor="Khronos" comment="Contact @tobski"/>
+    <ids type="opcode" start="6080" end="6143" vendor="Intel" comment="Contact mariusz.merecki@intel.com"/>
+    <ids type="opcode" start="6144" end="6271" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="opcode" start="6272" end="6399" vendor="Huawei" comment="Contact wanghuilong2@xunweitech.com"/>
+    <ids type="opcode" start="6400" end="6463" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="opcode" start="6464" end="6527" vendor="N/A" comment="Blank range to keep alignment with non-opcodes"/>
+    <ids type="opcode" start="6528" end="6591" vendor="Codeplay" comment="Contact duncan.brawley@codeplay.com"/>
+    <ids type="opcode" start="6592" end="6655" vendor="Saarland University" comment="Contact devillers@cg.uni-saarland.de"/>
+    <ids type="opcode" start="6656" end="6719" vendor="Meta" comment="Contact dunfanlu@meta.com"/>
+    <!-- Opcode enumerants to reserve for future use. To get a block, allocate
+         multiples of 64 starting at the lowest available point in this
+         block and add a corresponding <ids> tag immediately above. Make
+         sure to fill in the vendor attribute, and preferably add a contact
+         person/address in a comment attribute. -->
+    <!-- Example new block: <ids type="opcode" start="XXXX" end="XXXX+64n-1" vendor="Add vendor" comment="Contact TBD"/> -->
+    <ids type="opcode" start="6720" end="65535" comment="Opcode range reservable for future use by vendors"/>
+    <!-- End reservations of opcodes -->
+
+
+    <!-- Begin reservations of non-opcode enumerants -->
+    <ids type="enumerant" start="0" end="4095" vendor="Khronos" comment="Reserved enumerants, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="enumerant" start="4096" end="4159" vendor="Mesa" comment="Contact TBD"/>
+    <ids type="enumerant" start="4160" end="4415" vendor="ARM" comment="Contact kevin.petit@arm.com"/>
+    <ids type="enumerant" start="4416" end="4479" vendor="Khronos" comment="SPV_ARB_shader_ballot - contact Neil Henning, neil.henning@amd.com"/>
+    <ids type="enumerant" start="4480" end="4991" vendor="Qualcomm" comment="Contact weifengz@qti.qualcomm.com"/>
+    <ids type="enumerant" start="4992" end="5247" vendor="AMD"/>
+    <ids type="enumerant" start="5248" end="5503" vendor="NVIDIA"/>
+    <ids type="enumerant" start="5504" end="5567" vendor="Imagination"/>
+    <ids type="enumerant" start="5568" end="5631" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="enumerant" start="5632" end="5695" vendor="Google" comment="Contact dneto@google.com"/>
+    <ids type="enumerant" start="5696" end="5823" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="enumerant" start="5824" end="5951" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="enumerant" start="5952" end="6015" vendor="Codeplay" comment="Contact victor@codeplay.com"/>
+    <ids type="enumerant" start="6016" end="6079" vendor="Khronos" comment="Contact @tobski"/>
+    <ids type="enumerant" start="6080" end="6143" vendor="Intel" comment="Contact mariusz.merecki@intel.com"/>
+    <ids type="enumerant" start="6144" end="6271" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="enumerant" start="6272" end="6399" vendor="Huawei" comment="Contact wanghuilong2@xunweitech.com"/>
+    <ids type="enumerant" start="6400" end="6463" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="enumerant" start="6464" end="6527" vendor="Mikkosoft Productions" comment="Contact Mikko Rasa, tdb@tdb.fi"/>
+    <ids type="enumerant" start="6528" end="6591" vendor="Codeplay" comment="Contact duncan.brawley@codeplay.com"/>
+    <ids type="enumerant" start="6592" end="6655" vendor="Saarland University" comment="Contact devillers@cg.uni-saarland.de"/>
+    <ids type="enumerant" start="6656" end="6719" vendor="Meta" comment="Contact dunfanlu@meta.com"/>
+    <!-- Enumerants to reserve for future use. To get a block, allocate
+         multiples of 64 starting at the lowest available point in this
+         block and add a corresponding <ids> tag immediately above. Make
+         sure to fill in the vendor attribute, and preferably add a contact
+         person/address in a comment attribute. -->
+    <!-- Example new block: <ids type="enumerant" start="XXXX" end="XXXX+64n-1" vendor="Add vendor" comment="Contact TBD"/> -->
+    <ids type="enumerant" start="6720" end="4294967295" comment="Enumerant range reservable for future use by vendors"/>
+    <!-- End reservations of enumerants -->
+
+
+    <!-- SECTION: SPIR-V Loop Control Bit Reservations -->
+    <!-- Reserve ranges of bits in the loop control bitfield.
+
+         Each vendor determines the use of values in their own ranges.
+         Vendors are not required to disclose those uses.  If the use of a
+         value is included in an extension that is adopted by a Khronos
+         extension or specification, then that value's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+
+         The SPIR Working Group strongly recommends:
+         - Each value is used for only one purpose.
+         - All values in a range should be used before allocating a new range.
+         -->
+
+    <!-- Reserved loop control bits -->
+    <ids type="LoopControl" start="0" end="15" vendor="Khronos" comment="Reserved LoopControl bits, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="LoopControl" start="16" end="27" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="LoopControl" start="28" end="30" comment="Unreserved bits reservable for use by vendors"/>
+    <ids type="LoopControl" start="31" end="31" vendor="Khronos" comment="Reserved LoopControl bit, not available to vendors"/>
+
+
+    <!-- SECTION: SPIR-V Function Control Bit Reservations -->
+    <!-- Reserve ranges of bits in the function control bitfield.
+
+         Each vendor determines the use of values in their own ranges.
+         Vendors are not required to disclose those uses.  If the use of a
+         value is included in an extension that is adopted by a Khronos
+         extension or specification, then that value's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+
+         The SPIR Working Group strongly recommends:
+         - Each value is used for only one purpose.
+         - All values in a range should be used before allocating a new range.
+         -->
+
+    <!-- Reserved function control bits -->
+    <ids type="FunctionControl" start="0" end="15" vendor="Khronos" comment="Reserved FunctionControl bits, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="FunctionControl" start="16" end="16" vendor="Intel" comment="Contact ben.ashbaugh@intel.com"/>
+    <ids type="FunctionControl" start="17" end="30" comment="Unreserved bits reservable for use by vendors"/>
+    <ids type="FunctionControl" start="31" end="31" vendor="Khronos" comment="Reserved FunctionControl bit, not available to vendors"/>
+
+
+    <!-- SECTION: SPIR-V FP Fast Math Mode Bit Reservations -->
+    <!-- Reserve ranges of bits in the "FP Fast Math Mode" bitfield.
+         Each vendor determines the use of values in their own ranges.
+         Vendors are not required to disclose those uses.  If the use of a
+         value is included in an extension that is adopted by a Khronos
+         extension or specification, then that value's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+         The SPIR Working Group strongly recommends:
+         - Each value is used for only one purpose.
+         - All values in a range should be used before allocating a new range.
+         -->
+
+    <!-- Reserved FP fast math mode bits -->
+    <ids type="FPFastMathMode" start="0" end="15" vendor="Khronos" comment="Reserved FPFastMathMode bits, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="FPFastMathMode" start="16" end="17" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="FPFastMathMode" start="18" end="18" vendor="khronos" comment="Reserved FPFastMathMode bit, not available to vendors - see SPV_KHR_float_controls2"/>
+    <ids type="FPFastMathMode" start="19" end="31" comment="Unreserved bits reservable for use by vendors"/>
+
+
+    <!-- SECTION: SPIR-V Memory Operand Bit Reservations -->
+    <!-- Reserve ranges of bits in the memory operands bitfield.
+
+         Each vendor determines the use of values in their own ranges.
+         Vendors are not required to disclose those uses.  If the use of a
+         value is included in an extension that is adopted by a Khronos
+         extension or specification, then that value's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+
+         The SPIR Working Group strongly recommends:
+         - Each value is used for only one purpose.
+         - All values in a range should be used before allocating a new range.
+         -->
+
+    <!-- Reserved memory operand bits -->
+    <ids type="MemoryOperand" start="0" end="15" vendor="Khronos" comment="Reserved MemoryOperand bits, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="MemoryOperand" start="16" end="18" vendor="Intel" comment="Contact michael.kinsner@intel.com"/>
+    <ids type="MemoryOperand" start="19" end="22" vendor="Arm" comment="Contact kevin.petit@arm.com"/>
+    <ids type="MemoryOperand" start="23" end="30" comment="Unreserved bits reservable for use by vendors"/>
+    <ids type="MemoryOperand" start="31" end="31" vendor="Khronos" comment="Reserved MemoryOperand bit, not available to vendors"/>
+
+    <!-- SECTION: SPIR-V Image Operand Bit Reservations -->
+    <!-- Reserve ranges of bits in the image operands bitfield.
+
+         Each vendor determines the use of values in their own ranges.
+         Vendors are not required to disclose those uses.  If the use of a
+         value is included in an extension that is adopted by a Khronos
+         extension or specification, then that value's use may be permanently
+         fixed as if originally reserved in a Khronos range.
+
+         The SPIR Working Group strongly recommends:
+         - Each value is used for only one purpose.
+         - All values in a range should be used before allocating a new range.
+         -->
+
+    <!-- Reserved image operand bits -->
+    <ids type="ImageOperand" start="0" end="15" vendor="Khronos" comment="Reserved ImageOperand bits, not available to vendors - see the SPIR-V Specification"/>
+    <ids type="ImageOperand" start="16" end="16" vendor="Nvidia" comment="Contact pmistry@nvidia.com"/>
+    <ids type="ImageOperand" start="17" end="30" comment="Unreserved bits reservable for use by vendors"/>
+    <ids type="ImageOperand" start="31" end="31" vendor="Khronos" comment="Reserved ImageOperand bit, not available to vendors"/>
+
+</registry>

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/AMD_gcn_shader.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_AMD_gcn_shader_H_
+#define SPIRV_UNIFIED1_AMD_gcn_shader_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    AMD_gcn_shaderRevision = 2,
+    AMD_gcn_shaderRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum AMD_gcn_shaderInstructions {
+    AMD_gcn_shaderCubeFaceIndexAMD = 1,
+    AMD_gcn_shaderCubeFaceCoordAMD = 2,
+    AMD_gcn_shaderTimeAMD = 3,
+    AMD_gcn_shaderInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_AMD_gcn_shader_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/AMD_shader_ballot.h

@@ -0,0 +1,53 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_AMD_shader_ballot_H_
+#define SPIRV_UNIFIED1_AMD_shader_ballot_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    AMD_shader_ballotRevision = 5,
+    AMD_shader_ballotRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum AMD_shader_ballotInstructions {
+    AMD_shader_ballotSwizzleInvocationsAMD = 1,
+    AMD_shader_ballotSwizzleInvocationsMaskedAMD = 2,
+    AMD_shader_ballotWriteInvocationAMD = 3,
+    AMD_shader_ballotMbcntAMD = 4,
+    AMD_shader_ballotInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_AMD_shader_ballot_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/AMD_shader_explicit_vertex_parameter.h

@@ -0,0 +1,50 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_AMD_shader_explicit_vertex_parameter_H_
+#define SPIRV_UNIFIED1_AMD_shader_explicit_vertex_parameter_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    AMD_shader_explicit_vertex_parameterRevision = 4,
+    AMD_shader_explicit_vertex_parameterRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum AMD_shader_explicit_vertex_parameterInstructions {
+    AMD_shader_explicit_vertex_parameterInterpolateAtVertexAMD = 1,
+    AMD_shader_explicit_vertex_parameterInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_AMD_shader_explicit_vertex_parameter_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/AMD_shader_trinary_minmax.h

@@ -0,0 +1,58 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_AMD_shader_trinary_minmax_H_
+#define SPIRV_UNIFIED1_AMD_shader_trinary_minmax_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    AMD_shader_trinary_minmaxRevision = 4,
+    AMD_shader_trinary_minmaxRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum AMD_shader_trinary_minmaxInstructions {
+    AMD_shader_trinary_minmaxFMin3AMD = 1,
+    AMD_shader_trinary_minmaxUMin3AMD = 2,
+    AMD_shader_trinary_minmaxSMin3AMD = 3,
+    AMD_shader_trinary_minmaxFMax3AMD = 4,
+    AMD_shader_trinary_minmaxUMax3AMD = 5,
+    AMD_shader_trinary_minmaxSMax3AMD = 6,
+    AMD_shader_trinary_minmaxFMid3AMD = 7,
+    AMD_shader_trinary_minmaxUMid3AMD = 8,
+    AMD_shader_trinary_minmaxSMid3AMD = 9,
+    AMD_shader_trinary_minmaxInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_AMD_shader_trinary_minmax_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/DebugInfo.h

@@ -0,0 +1,144 @@
+// Copyright (c) 2017-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+#ifndef SPIRV_UNIFIED1_DebugInfo_H_
+#define SPIRV_UNIFIED1_DebugInfo_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    DebugInfoVersion = 100,
+    DebugInfoVersion_BitWidthPadding = 0x7fffffff
+};
+enum {
+    DebugInfoRevision = 1,
+    DebugInfoRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum DebugInfoInstructions {
+    DebugInfoDebugInfoNone = 0,
+    DebugInfoDebugCompilationUnit = 1,
+    DebugInfoDebugTypeBasic = 2,
+    DebugInfoDebugTypePointer = 3,
+    DebugInfoDebugTypeQualifier = 4,
+    DebugInfoDebugTypeArray = 5,
+    DebugInfoDebugTypeVector = 6,
+    DebugInfoDebugTypedef = 7,
+    DebugInfoDebugTypeFunction = 8,
+    DebugInfoDebugTypeEnum = 9,
+    DebugInfoDebugTypeComposite = 10,
+    DebugInfoDebugTypeMember = 11,
+    DebugInfoDebugTypeInheritance = 12,
+    DebugInfoDebugTypePtrToMember = 13,
+    DebugInfoDebugTypeTemplate = 14,
+    DebugInfoDebugTypeTemplateParameter = 15,
+    DebugInfoDebugTypeTemplateTemplateParameter = 16,
+    DebugInfoDebugTypeTemplateParameterPack = 17,
+    DebugInfoDebugGlobalVariable = 18,
+    DebugInfoDebugFunctionDeclaration = 19,
+    DebugInfoDebugFunction = 20,
+    DebugInfoDebugLexicalBlock = 21,
+    DebugInfoDebugLexicalBlockDiscriminator = 22,
+    DebugInfoDebugScope = 23,
+    DebugInfoDebugNoScope = 24,
+    DebugInfoDebugInlinedAt = 25,
+    DebugInfoDebugLocalVariable = 26,
+    DebugInfoDebugInlinedVariable = 27,
+    DebugInfoDebugDeclare = 28,
+    DebugInfoDebugValue = 29,
+    DebugInfoDebugOperation = 30,
+    DebugInfoDebugExpression = 31,
+    DebugInfoDebugMacroDef = 32,
+    DebugInfoDebugMacroUndef = 33,
+    DebugInfoInstructionsMax = 0x7fffffff
+};
+
+
+enum DebugInfoDebugInfoFlags {
+    DebugInfoNone = 0x0000,
+    DebugInfoFlagIsProtected = 0x01,
+    DebugInfoFlagIsPrivate = 0x02,
+    DebugInfoFlagIsPublic = 0x03,
+    DebugInfoFlagIsLocal = 0x04,
+    DebugInfoFlagIsDefinition = 0x08,
+    DebugInfoFlagFwdDecl = 0x10,
+    DebugInfoFlagArtificial = 0x20,
+    DebugInfoFlagExplicit = 0x40,
+    DebugInfoFlagPrototyped = 0x80,
+    DebugInfoFlagObjectPointer = 0x100,
+    DebugInfoFlagStaticMember = 0x200,
+    DebugInfoFlagIndirectVariable = 0x400,
+    DebugInfoFlagLValueReference = 0x800,
+    DebugInfoFlagRValueReference = 0x1000,
+    DebugInfoFlagIsOptimized = 0x2000,
+    DebugInfoDebugInfoFlagsMax = 0x7fffffff
+};
+
+enum DebugInfoDebugBaseTypeAttributeEncoding {
+    DebugInfoUnspecified = 0,
+    DebugInfoAddress = 1,
+    DebugInfoBoolean = 2,
+    DebugInfoFloat = 4,
+    DebugInfoSigned = 5,
+    DebugInfoSignedChar = 6,
+    DebugInfoUnsigned = 7,
+    DebugInfoUnsignedChar = 8,
+    DebugInfoDebugBaseTypeAttributeEncodingMax = 0x7fffffff
+};
+
+enum DebugInfoDebugCompositeType {
+    DebugInfoClass = 0,
+    DebugInfoStructure = 1,
+    DebugInfoUnion = 2,
+    DebugInfoDebugCompositeTypeMax = 0x7fffffff
+};
+
+enum DebugInfoDebugTypeQualifier {
+    DebugInfoConstType = 0,
+    DebugInfoVolatileType = 1,
+    DebugInfoRestrictType = 2,
+    DebugInfoDebugTypeQualifierMax = 0x7fffffff
+};
+
+enum DebugInfoDebugOperation {
+    DebugInfoDeref = 0,
+    DebugInfoPlus = 1,
+    DebugInfoMinus = 2,
+    DebugInfoPlusUconst = 3,
+    DebugInfoBitPiece = 4,
+    DebugInfoSwap = 5,
+    DebugInfoXderef = 6,
+    DebugInfoStackValue = 7,
+    DebugInfoConstu = 8,
+    DebugInfoDebugOperationMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_DebugInfo_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/GLSL.std.450.h

@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 2014-2024 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLstd450_H
+#define GLSLstd450_H
+
+static const int GLSLstd450Version = 100;
+static const int GLSLstd450Revision = 3;
+
+enum GLSLstd450 {
+    GLSLstd450Bad = 0,              // Don't use
+
+    GLSLstd450Round = 1,
+    GLSLstd450RoundEven = 2,
+    GLSLstd450Trunc = 3,
+    GLSLstd450FAbs = 4,
+    GLSLstd450SAbs = 5,
+    GLSLstd450FSign = 6,
+    GLSLstd450SSign = 7,
+    GLSLstd450Floor = 8,
+    GLSLstd450Ceil = 9,
+    GLSLstd450Fract = 10,
+
+    GLSLstd450Radians = 11,
+    GLSLstd450Degrees = 12,
+    GLSLstd450Sin = 13,
+    GLSLstd450Cos = 14,
+    GLSLstd450Tan = 15,
+    GLSLstd450Asin = 16,
+    GLSLstd450Acos = 17,
+    GLSLstd450Atan = 18,
+    GLSLstd450Sinh = 19,
+    GLSLstd450Cosh = 20,
+    GLSLstd450Tanh = 21,
+    GLSLstd450Asinh = 22,
+    GLSLstd450Acosh = 23,
+    GLSLstd450Atanh = 24,
+    GLSLstd450Atan2 = 25,
+
+    GLSLstd450Pow = 26,
+    GLSLstd450Exp = 27,
+    GLSLstd450Log = 28,
+    GLSLstd450Exp2 = 29,
+    GLSLstd450Log2 = 30,
+    GLSLstd450Sqrt = 31,
+    GLSLstd450InverseSqrt = 32,
+
+    GLSLstd450Determinant = 33,
+    GLSLstd450MatrixInverse = 34,
+
+    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
+    GLSLstd450ModfStruct = 36,      // no OpVariable operand
+    GLSLstd450FMin = 37,
+    GLSLstd450UMin = 38,
+    GLSLstd450SMin = 39,
+    GLSLstd450FMax = 40,
+    GLSLstd450UMax = 41,
+    GLSLstd450SMax = 42,
+    GLSLstd450FClamp = 43,
+    GLSLstd450UClamp = 44,
+    GLSLstd450SClamp = 45,
+    GLSLstd450FMix = 46,
+    GLSLstd450IMix = 47,            // Reserved
+    GLSLstd450Step = 48,
+    GLSLstd450SmoothStep = 49,
+
+    GLSLstd450Fma = 50,
+    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
+    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
+    GLSLstd450Ldexp = 53,
+
+    GLSLstd450PackSnorm4x8 = 54,
+    GLSLstd450PackUnorm4x8 = 55,
+    GLSLstd450PackSnorm2x16 = 56,
+    GLSLstd450PackUnorm2x16 = 57,
+    GLSLstd450PackHalf2x16 = 58,
+    GLSLstd450PackDouble2x32 = 59,
+    GLSLstd450UnpackSnorm2x16 = 60,
+    GLSLstd450UnpackUnorm2x16 = 61,
+    GLSLstd450UnpackHalf2x16 = 62,
+    GLSLstd450UnpackSnorm4x8 = 63,
+    GLSLstd450UnpackUnorm4x8 = 64,
+    GLSLstd450UnpackDouble2x32 = 65,
+
+    GLSLstd450Length = 66,
+    GLSLstd450Distance = 67,
+    GLSLstd450Cross = 68,
+    GLSLstd450Normalize = 69,
+    GLSLstd450FaceForward = 70,
+    GLSLstd450Reflect = 71,
+    GLSLstd450Refract = 72,
+
+    GLSLstd450FindILsb = 73,
+    GLSLstd450FindSMsb = 74,
+    GLSLstd450FindUMsb = 75,
+
+    GLSLstd450InterpolateAtCentroid = 76,
+    GLSLstd450InterpolateAtSample = 77,
+    GLSLstd450InterpolateAtOffset = 78,
+
+    GLSLstd450NMin = 79,
+    GLSLstd450NMax = 80,
+    GLSLstd450NClamp = 81,
+
+    GLSLstd450Count
+};
+
+#endif  // #ifndef GLSLstd450_H

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/NonSemanticClspvReflection.h

@@ -0,0 +1,97 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_NonSemanticClspvReflection_H_
+#define SPIRV_UNIFIED1_NonSemanticClspvReflection_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticClspvReflectionRevision = 6,
+    NonSemanticClspvReflectionRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticClspvReflectionInstructions {
+    NonSemanticClspvReflectionKernel = 1,
+    NonSemanticClspvReflectionArgumentInfo = 2,
+    NonSemanticClspvReflectionArgumentStorageBuffer = 3,
+    NonSemanticClspvReflectionArgumentUniform = 4,
+    NonSemanticClspvReflectionArgumentPodStorageBuffer = 5,
+    NonSemanticClspvReflectionArgumentPodUniform = 6,
+    NonSemanticClspvReflectionArgumentPodPushConstant = 7,
+    NonSemanticClspvReflectionArgumentSampledImage = 8,
+    NonSemanticClspvReflectionArgumentStorageImage = 9,
+    NonSemanticClspvReflectionArgumentSampler = 10,
+    NonSemanticClspvReflectionArgumentWorkgroup = 11,
+    NonSemanticClspvReflectionSpecConstantWorkgroupSize = 12,
+    NonSemanticClspvReflectionSpecConstantGlobalOffset = 13,
+    NonSemanticClspvReflectionSpecConstantWorkDim = 14,
+    NonSemanticClspvReflectionPushConstantGlobalOffset = 15,
+    NonSemanticClspvReflectionPushConstantEnqueuedLocalSize = 16,
+    NonSemanticClspvReflectionPushConstantGlobalSize = 17,
+    NonSemanticClspvReflectionPushConstantRegionOffset = 18,
+    NonSemanticClspvReflectionPushConstantNumWorkgroups = 19,
+    NonSemanticClspvReflectionPushConstantRegionGroupOffset = 20,
+    NonSemanticClspvReflectionConstantDataStorageBuffer = 21,
+    NonSemanticClspvReflectionConstantDataUniform = 22,
+    NonSemanticClspvReflectionLiteralSampler = 23,
+    NonSemanticClspvReflectionPropertyRequiredWorkgroupSize = 24,
+    NonSemanticClspvReflectionSpecConstantSubgroupMaxSize = 25,
+    NonSemanticClspvReflectionArgumentPointerPushConstant = 26,
+    NonSemanticClspvReflectionArgumentPointerUniform = 27,
+    NonSemanticClspvReflectionProgramScopeVariablesStorageBuffer = 28,
+    NonSemanticClspvReflectionProgramScopeVariablePointerRelocation = 29,
+    NonSemanticClspvReflectionImageArgumentInfoChannelOrderPushConstant = 30,
+    NonSemanticClspvReflectionImageArgumentInfoChannelDataTypePushConstant = 31,
+    NonSemanticClspvReflectionImageArgumentInfoChannelOrderUniform = 32,
+    NonSemanticClspvReflectionImageArgumentInfoChannelDataTypeUniform = 33,
+    NonSemanticClspvReflectionArgumentStorageTexelBuffer = 34,
+    NonSemanticClspvReflectionArgumentUniformTexelBuffer = 35,
+    NonSemanticClspvReflectionConstantDataPointerPushConstant = 36,
+    NonSemanticClspvReflectionProgramScopeVariablePointerPushConstant = 37,
+    NonSemanticClspvReflectionPrintfInfo = 38,
+    NonSemanticClspvReflectionPrintfBufferStorageBuffer = 39,
+    NonSemanticClspvReflectionPrintfBufferPointerPushConstant = 40,
+    NonSemanticClspvReflectionNormalizedSamplerMaskPushConstant = 41,
+    NonSemanticClspvReflectionInstructionsMax = 0x7fffffff
+};
+
+
+enum NonSemanticClspvReflectionKernelPropertyFlags {
+    NonSemanticClspvReflectionNone = 0x0,
+    NonSemanticClspvReflectionMayUsePrintf = 0x1,
+    NonSemanticClspvReflectionKernelPropertyFlagsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticClspvReflection_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/NonSemanticDebugBreak.h

@@ -0,0 +1,50 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_NonSemanticDebugBreak_H_
+#define SPIRV_UNIFIED1_NonSemanticDebugBreak_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticDebugBreakRevision = 1,
+    NonSemanticDebugBreakRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticDebugBreakInstructions {
+    NonSemanticDebugBreakDebugBreak = 1,
+    NonSemanticDebugBreakInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticDebugBreak_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/NonSemanticDebugPrintf.h

@@ -0,0 +1,50 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
+#define SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticDebugPrintfRevision = 1,
+    NonSemanticDebugPrintfRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticDebugPrintfInstructions {
+    NonSemanticDebugPrintfDebugPrintf = 1,
+    NonSemanticDebugPrintfInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/NonSemanticShaderDebugInfo100.h

@@ -0,0 +1,171 @@
+// Copyright (c) 2018-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+#ifndef SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+#define SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticShaderDebugInfo100Version = 100,
+    NonSemanticShaderDebugInfo100Version_BitWidthPadding = 0x7fffffff
+};
+enum {
+    NonSemanticShaderDebugInfo100Revision = 6,
+    NonSemanticShaderDebugInfo100Revision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100Instructions {
+    NonSemanticShaderDebugInfo100DebugInfoNone = 0,
+    NonSemanticShaderDebugInfo100DebugCompilationUnit = 1,
+    NonSemanticShaderDebugInfo100DebugTypeBasic = 2,
+    NonSemanticShaderDebugInfo100DebugTypePointer = 3,
+    NonSemanticShaderDebugInfo100DebugTypeQualifier = 4,
+    NonSemanticShaderDebugInfo100DebugTypeArray = 5,
+    NonSemanticShaderDebugInfo100DebugTypeVector = 6,
+    NonSemanticShaderDebugInfo100DebugTypedef = 7,
+    NonSemanticShaderDebugInfo100DebugTypeFunction = 8,
+    NonSemanticShaderDebugInfo100DebugTypeEnum = 9,
+    NonSemanticShaderDebugInfo100DebugTypeComposite = 10,
+    NonSemanticShaderDebugInfo100DebugTypeMember = 11,
+    NonSemanticShaderDebugInfo100DebugTypeInheritance = 12,
+    NonSemanticShaderDebugInfo100DebugTypePtrToMember = 13,
+    NonSemanticShaderDebugInfo100DebugTypeTemplate = 14,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateParameter = 15,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter = 16,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack = 17,
+    NonSemanticShaderDebugInfo100DebugGlobalVariable = 18,
+    NonSemanticShaderDebugInfo100DebugFunctionDeclaration = 19,
+    NonSemanticShaderDebugInfo100DebugFunction = 20,
+    NonSemanticShaderDebugInfo100DebugLexicalBlock = 21,
+    NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator = 22,
+    NonSemanticShaderDebugInfo100DebugScope = 23,
+    NonSemanticShaderDebugInfo100DebugNoScope = 24,
+    NonSemanticShaderDebugInfo100DebugInlinedAt = 25,
+    NonSemanticShaderDebugInfo100DebugLocalVariable = 26,
+    NonSemanticShaderDebugInfo100DebugInlinedVariable = 27,
+    NonSemanticShaderDebugInfo100DebugDeclare = 28,
+    NonSemanticShaderDebugInfo100DebugValue = 29,
+    NonSemanticShaderDebugInfo100DebugOperation = 30,
+    NonSemanticShaderDebugInfo100DebugExpression = 31,
+    NonSemanticShaderDebugInfo100DebugMacroDef = 32,
+    NonSemanticShaderDebugInfo100DebugMacroUndef = 33,
+    NonSemanticShaderDebugInfo100DebugImportedEntity = 34,
+    NonSemanticShaderDebugInfo100DebugSource = 35,
+    NonSemanticShaderDebugInfo100DebugFunctionDefinition = 101,
+    NonSemanticShaderDebugInfo100DebugSourceContinued = 102,
+    NonSemanticShaderDebugInfo100DebugLine = 103,
+    NonSemanticShaderDebugInfo100DebugNoLine = 104,
+    NonSemanticShaderDebugInfo100DebugBuildIdentifier = 105,
+    NonSemanticShaderDebugInfo100DebugStoragePath = 106,
+    NonSemanticShaderDebugInfo100DebugEntryPoint = 107,
+    NonSemanticShaderDebugInfo100DebugTypeMatrix = 108,
+    NonSemanticShaderDebugInfo100InstructionsMax = 0x7fffffff
+};
+
+
+enum NonSemanticShaderDebugInfo100DebugInfoFlags {
+    NonSemanticShaderDebugInfo100None = 0x0000,
+    NonSemanticShaderDebugInfo100FlagIsProtected = 0x01,
+    NonSemanticShaderDebugInfo100FlagIsPrivate = 0x02,
+    NonSemanticShaderDebugInfo100FlagIsPublic = 0x03,
+    NonSemanticShaderDebugInfo100FlagIsLocal = 0x04,
+    NonSemanticShaderDebugInfo100FlagIsDefinition = 0x08,
+    NonSemanticShaderDebugInfo100FlagFwdDecl = 0x10,
+    NonSemanticShaderDebugInfo100FlagArtificial = 0x20,
+    NonSemanticShaderDebugInfo100FlagExplicit = 0x40,
+    NonSemanticShaderDebugInfo100FlagPrototyped = 0x80,
+    NonSemanticShaderDebugInfo100FlagObjectPointer = 0x100,
+    NonSemanticShaderDebugInfo100FlagStaticMember = 0x200,
+    NonSemanticShaderDebugInfo100FlagIndirectVariable = 0x400,
+    NonSemanticShaderDebugInfo100FlagLValueReference = 0x800,
+    NonSemanticShaderDebugInfo100FlagRValueReference = 0x1000,
+    NonSemanticShaderDebugInfo100FlagIsOptimized = 0x2000,
+    NonSemanticShaderDebugInfo100FlagIsEnumClass = 0x4000,
+    NonSemanticShaderDebugInfo100FlagTypePassByValue = 0x8000,
+    NonSemanticShaderDebugInfo100FlagTypePassByReference = 0x10000,
+    NonSemanticShaderDebugInfo100FlagUnknownPhysicalLayout = 0x20000,
+    NonSemanticShaderDebugInfo100DebugInfoFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100BuildIdentifierFlags {
+    NonSemanticShaderDebugInfo100IdentifierPossibleDuplicates = 0x01,
+    NonSemanticShaderDebugInfo100BuildIdentifierFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncoding {
+    NonSemanticShaderDebugInfo100Unspecified = 0,
+    NonSemanticShaderDebugInfo100Address = 1,
+    NonSemanticShaderDebugInfo100Boolean = 2,
+    NonSemanticShaderDebugInfo100Float = 3,
+    NonSemanticShaderDebugInfo100Signed = 4,
+    NonSemanticShaderDebugInfo100SignedChar = 5,
+    NonSemanticShaderDebugInfo100Unsigned = 6,
+    NonSemanticShaderDebugInfo100UnsignedChar = 7,
+    NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncodingMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugCompositeType {
+    NonSemanticShaderDebugInfo100Class = 0,
+    NonSemanticShaderDebugInfo100Structure = 1,
+    NonSemanticShaderDebugInfo100Union = 2,
+    NonSemanticShaderDebugInfo100DebugCompositeTypeMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugTypeQualifier {
+    NonSemanticShaderDebugInfo100ConstType = 0,
+    NonSemanticShaderDebugInfo100VolatileType = 1,
+    NonSemanticShaderDebugInfo100RestrictType = 2,
+    NonSemanticShaderDebugInfo100AtomicType = 3,
+    NonSemanticShaderDebugInfo100DebugTypeQualifierMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugOperation {
+    NonSemanticShaderDebugInfo100Deref = 0,
+    NonSemanticShaderDebugInfo100Plus = 1,
+    NonSemanticShaderDebugInfo100Minus = 2,
+    NonSemanticShaderDebugInfo100PlusUconst = 3,
+    NonSemanticShaderDebugInfo100BitPiece = 4,
+    NonSemanticShaderDebugInfo100Swap = 5,
+    NonSemanticShaderDebugInfo100Xderef = 6,
+    NonSemanticShaderDebugInfo100StackValue = 7,
+    NonSemanticShaderDebugInfo100Constu = 8,
+    NonSemanticShaderDebugInfo100Fragment = 9,
+    NonSemanticShaderDebugInfo100DebugOperationMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugImportedEntity {
+    NonSemanticShaderDebugInfo100ImportedModule = 0,
+    NonSemanticShaderDebugInfo100ImportedDeclaration = 1,
+    NonSemanticShaderDebugInfo100DebugImportedEntityMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/NonSemanticVkspReflection.h

@@ -0,0 +1,57 @@
+// Copyright (c) 2020-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+// 
+
+#ifndef SPIRV_UNIFIED1_NonSemanticVkspReflection_H_
+#define SPIRV_UNIFIED1_NonSemanticVkspReflection_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticVkspReflectionRevision = 3,
+    NonSemanticVkspReflectionRevision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticVkspReflectionInstructions {
+    NonSemanticVkspReflectionConfiguration = 1,
+    NonSemanticVkspReflectionStartCounter = 2,
+    NonSemanticVkspReflectionStopCounter = 3,
+    NonSemanticVkspReflectionPushConstants = 4,
+    NonSemanticVkspReflectionSpecializationMapEntry = 5,
+    NonSemanticVkspReflectionDescriptorSetBuffer = 6,
+    NonSemanticVkspReflectionDescriptorSetImage = 7,
+    NonSemanticVkspReflectionDescriptorSetSampler = 8,
+    NonSemanticVkspReflectionInstructionsMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticVkspReflection_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/OpenCL.std.h

@@ -0,0 +1,401 @@
+/*
+** Copyright (c) 2015-2024 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef OPENCLstd_H
+#define OPENCLstd_H
+
+#ifdef __cplusplus
+namespace OpenCLLIB {
+
+enum Entrypoints {
+
+    // Section 2.1: Math extended instructions
+    Acos = 0,
+    Acosh = 1,
+    Acospi = 2,
+    Asin = 3,
+    Asinh = 4,
+    Asinpi = 5,
+    Atan = 6,
+    Atan2 = 7,
+    Atanh = 8,
+    Atanpi = 9,
+    Atan2pi = 10,
+    Cbrt = 11,
+    Ceil = 12,
+    Copysign = 13,
+    Cos = 14,
+    Cosh = 15,
+    Cospi = 16,
+    Erfc = 17,
+    Erf = 18,
+    Exp = 19,
+    Exp2 = 20,
+    Exp10 = 21,
+    Expm1 = 22,
+    Fabs = 23,
+    Fdim = 24,
+    Floor = 25,
+    Fma = 26,
+    Fmax = 27,
+    Fmin = 28,
+    Fmod = 29,
+    Fract = 30, 
+    Frexp = 31,
+    Hypot = 32,
+    Ilogb = 33,
+    Ldexp = 34,
+    Lgamma = 35,
+    Lgamma_r = 36,
+    Log = 37,
+    Log2 = 38,
+    Log10 = 39,
+    Log1p = 40,
+    Logb = 41,
+    Mad = 42,
+    Maxmag = 43,
+    Minmag = 44,
+    Modf = 45,
+    Nan = 46,
+    Nextafter = 47,
+    Pow = 48,
+    Pown = 49,
+    Powr = 50,
+    Remainder = 51,
+    Remquo = 52,
+    Rint = 53,
+    Rootn = 54,
+    Round = 55,
+    Rsqrt = 56,
+    Sin = 57,
+    Sincos = 58,
+    Sinh = 59,
+    Sinpi = 60,
+    Sqrt = 61,
+    Tan = 62,
+    Tanh = 63,
+    Tanpi = 64,
+    Tgamma = 65,
+    Trunc = 66,
+    Half_cos = 67,
+    Half_divide = 68,
+    Half_exp = 69,
+    Half_exp2 = 70,
+    Half_exp10 = 71,
+    Half_log = 72,
+    Half_log2 = 73,
+    Half_log10 = 74,
+    Half_powr = 75,
+    Half_recip = 76,
+    Half_rsqrt = 77,
+    Half_sin = 78,
+    Half_sqrt = 79,
+    Half_tan = 80,
+    Native_cos = 81,
+    Native_divide = 82,
+    Native_exp = 83,
+    Native_exp2 = 84,
+    Native_exp10 = 85,
+    Native_log = 86,
+    Native_log2 = 87,
+    Native_log10 = 88,
+    Native_powr = 89,
+    Native_recip = 90,
+    Native_rsqrt = 91,
+    Native_sin = 92,
+    Native_sqrt = 93,
+    Native_tan = 94,
+    
+    // Section 2.2: Integer instructions
+    SAbs = 141,
+    SAbs_diff = 142,
+    SAdd_sat = 143,
+    UAdd_sat = 144,
+    SHadd = 145,
+    UHadd = 146,
+    SRhadd = 147,
+    URhadd = 148,
+    SClamp = 149,
+    UClamp = 150, 
+    Clz = 151,
+    Ctz = 152,    
+    SMad_hi = 153,
+    UMad_sat = 154,
+    SMad_sat = 155,
+    SMax = 156,
+    UMax = 157,
+    SMin = 158,
+    UMin = 159,
+    SMul_hi = 160,
+    Rotate = 161,
+    SSub_sat = 162,
+    USub_sat = 163,
+    U_Upsample = 164,
+    S_Upsample = 165,
+    Popcount = 166,
+    SMad24 = 167,
+    UMad24 = 168,
+    SMul24 = 169,
+    UMul24 = 170,
+    UAbs = 201,
+    UAbs_diff = 202,
+    UMul_hi = 203,
+    UMad_hi = 204,
+
+    // Section 2.3: Common instructions
+    FClamp = 95,
+    Degrees = 96,
+    FMax_common = 97,
+    FMin_common = 98, 
+    Mix = 99,
+    Radians = 100,
+    Step = 101,
+    Smoothstep = 102,
+    Sign = 103,
+
+    // Section 2.4: Geometric instructions
+    Cross = 104,
+    Distance = 105, 
+    Length = 106,
+    Normalize = 107,
+    Fast_distance = 108,
+    Fast_length = 109,
+    Fast_normalize = 110,
+
+    // Section 2.5: Relational instructions
+    Bitselect = 186,
+    Select = 187,
+
+    // Section 2.6: Vector Data Load and Store instructions
+    Vloadn = 171,
+    Vstoren = 172,
+    Vload_half = 173,
+    Vload_halfn = 174,
+    Vstore_half = 175,
+    Vstore_half_r = 176,
+    Vstore_halfn = 177,
+    Vstore_halfn_r = 178,
+    Vloada_halfn = 179,
+    Vstorea_halfn = 180,
+    Vstorea_halfn_r = 181,
+
+    // Section 2.7: Miscellaneous Vector instructions
+    Shuffle = 182,
+    Shuffle2 = 183,
+
+    // Section 2.8: Misc instructions 
+    Printf = 184,
+    Prefetch = 185,
+};
+
+} // end namespace OpenCLLIB
+
+#else
+
+enum OpenCLstd_Entrypoints {
+
+    // Section 2.1: Math extended instructions
+    OpenCLstd_Acos = 0,
+    OpenCLstd_Acosh = 1,
+    OpenCLstd_Acospi = 2,
+    OpenCLstd_Asin = 3,
+    OpenCLstd_Asinh = 4,
+    OpenCLstd_Asinpi = 5,
+    OpenCLstd_Atan = 6,
+    OpenCLstd_Atan2 = 7,
+    OpenCLstd_Atanh = 8,
+    OpenCLstd_Atanpi = 9,
+    OpenCLstd_Atan2pi = 10,
+    OpenCLstd_Cbrt = 11,
+    OpenCLstd_Ceil = 12,
+    OpenCLstd_Copysign = 13,
+    OpenCLstd_Cos = 14,
+    OpenCLstd_Cosh = 15,
+    OpenCLstd_Cospi = 16,
+    OpenCLstd_Erfc = 17,
+    OpenCLstd_Erf = 18,
+    OpenCLstd_Exp = 19,
+    OpenCLstd_Exp2 = 20,
+    OpenCLstd_Exp10 = 21,
+    OpenCLstd_Expm1 = 22,
+    OpenCLstd_Fabs = 23,
+    OpenCLstd_Fdim = 24,
+    OpenCLstd_Floor = 25,
+    OpenCLstd_Fma = 26,
+    OpenCLstd_Fmax = 27,
+    OpenCLstd_Fmin = 28,
+    OpenCLstd_Fmod = 29,
+    OpenCLstd_Fract = 30, 
+    OpenCLstd_Frexp = 31,
+    OpenCLstd_Hypot = 32,
+    OpenCLstd_Ilogb = 33,
+    OpenCLstd_Ldexp = 34,
+    OpenCLstd_Lgamma = 35,
+    OpenCLstd_Lgamma_r = 36,
+    OpenCLstd_Log = 37,
+    OpenCLstd_Log2 = 38,
+    OpenCLstd_Log10 = 39,
+    OpenCLstd_Log1p = 40,
+    OpenCLstd_Logb = 41,
+    OpenCLstd_Mad = 42,
+    OpenCLstd_Maxmag = 43,
+    OpenCLstd_Minmag = 44,
+    OpenCLstd_Modf = 45,
+    OpenCLstd_Nan = 46,
+    OpenCLstd_Nextafter = 47,
+    OpenCLstd_Pow = 48,
+    OpenCLstd_Pown = 49,
+    OpenCLstd_Powr = 50,
+    OpenCLstd_Remainder = 51,
+    OpenCLstd_Remquo = 52,
+    OpenCLstd_Rint = 53,
+    OpenCLstd_Rootn = 54,
+    OpenCLstd_Round = 55,
+    OpenCLstd_Rsqrt = 56,
+    OpenCLstd_Sin = 57,
+    OpenCLstd_Sincos = 58,
+    OpenCLstd_Sinh = 59,
+    OpenCLstd_Sinpi = 60,
+    OpenCLstd_Sqrt = 61,
+    OpenCLstd_Tan = 62,
+    OpenCLstd_Tanh = 63,
+    OpenCLstd_Tanpi = 64,
+    OpenCLstd_Tgamma = 65,
+    OpenCLstd_Trunc = 66,
+    OpenCLstd_Half_cos = 67,
+    OpenCLstd_Half_divide = 68,
+    OpenCLstd_Half_exp = 69,
+    OpenCLstd_Half_exp2 = 70,
+    OpenCLstd_Half_exp10 = 71,
+    OpenCLstd_Half_log = 72,
+    OpenCLstd_Half_log2 = 73,
+    OpenCLstd_Half_log10 = 74,
+    OpenCLstd_Half_powr = 75,
+    OpenCLstd_Half_recip = 76,
+    OpenCLstd_Half_rsqrt = 77,
+    OpenCLstd_Half_sin = 78,
+    OpenCLstd_Half_sqrt = 79,
+    OpenCLstd_Half_tan = 80,
+    OpenCLstd_Native_cos = 81,
+    OpenCLstd_Native_divide = 82,
+    OpenCLstd_Native_exp = 83,
+    OpenCLstd_Native_exp2 = 84,
+    OpenCLstd_Native_exp10 = 85,
+    OpenCLstd_Native_log = 86,
+    OpenCLstd_Native_log2 = 87,
+    OpenCLstd_Native_log10 = 88,
+    OpenCLstd_Native_powr = 89,
+    OpenCLstd_Native_recip = 90,
+    OpenCLstd_Native_rsqrt = 91,
+    OpenCLstd_Native_sin = 92,
+    OpenCLstd_Native_sqrt = 93,
+    OpenCLstd_Native_tan = 94,
+    
+    // Section 2.2: Integer instructions
+    OpenCLstd_SAbs = 141,
+    OpenCLstd_SAbs_diff = 142,
+    OpenCLstd_SAdd_sat = 143,
+    OpenCLstd_UAdd_sat = 144,
+    OpenCLstd_SHadd = 145,
+    OpenCLstd_UHadd = 146,
+    OpenCLstd_SRhadd = 147,
+    OpenCLstd_URhadd = 148,
+    OpenCLstd_SClamp = 149,
+    OpenCLstd_UClamp = 150, 
+    OpenCLstd_Clz = 151,
+    OpenCLstd_Ctz = 152,    
+    OpenCLstd_SMad_hi = 153,
+    OpenCLstd_UMad_sat = 154,
+    OpenCLstd_SMad_sat = 155,
+    OpenCLstd_SMax = 156,
+    OpenCLstd_UMax = 157,
+    OpenCLstd_SMin = 158,
+    OpenCLstd_UMin = 159,
+    OpenCLstd_SMul_hi = 160,
+    OpenCLstd_Rotate = 161,
+    OpenCLstd_SSub_sat = 162,
+    OpenCLstd_USub_sat = 163,
+    OpenCLstd_U_Upsample = 164,
+    OpenCLstd_S_Upsample = 165,
+    OpenCLstd_Popcount = 166,
+    OpenCLstd_SMad24 = 167,
+    OpenCLstd_UMad24 = 168,
+    OpenCLstd_SMul24 = 169,
+    OpenCLstd_UMul24 = 170,
+    OpenCLstd_UAbs = 201,
+    OpenCLstd_UAbs_diff = 202,
+    OpenCLstd_UMul_hi = 203,
+    OpenCLstd_UMad_hi = 204,
+
+    // Section 2.3: Common instructions
+    OpenCLstd_FClamp = 95,
+    OpenCLstd_Degrees = 96,
+    OpenCLstd_FMax_common = 97,
+    OpenCLstd_FMin_common = 98, 
+    OpenCLstd_Mix = 99,
+    OpenCLstd_Radians = 100,
+    OpenCLstd_Step = 101,
+    OpenCLstd_Smoothstep = 102,
+    OpenCLstd_Sign = 103,
+
+    // Section 2.4: Geometric instructions
+    OpenCLstd_Cross = 104,
+    OpenCLstd_Distance = 105, 
+    OpenCLstd_Length = 106,
+    OpenCLstd_Normalize = 107,
+    OpenCLstd_Fast_distance = 108,
+    OpenCLstd_Fast_length = 109,
+    OpenCLstd_Fast_normalize = 110,
+
+    // Section 2.5: Relational instructions
+    OpenCLstd_Bitselect = 186,
+    OpenCLstd_Select = 187,
+
+    // Section 2.6: Vector Data Load and Store instructions
+    OpenCLstd_Vloadn = 171,
+    OpenCLstd_Vstoren = 172,
+    OpenCLstd_Vload_half = 173,
+    OpenCLstd_Vload_halfn = 174,
+    OpenCLstd_Vstore_half = 175,
+    OpenCLstd_Vstore_half_r = 176,
+    OpenCLstd_Vstore_halfn = 177,
+    OpenCLstd_Vstore_halfn_r = 178,
+    OpenCLstd_Vloada_halfn = 179,
+    OpenCLstd_Vstorea_halfn = 180,
+    OpenCLstd_Vstorea_halfn_r = 181,
+
+    // Section 2.7: Miscellaneous Vector instructions
+    OpenCLstd_Shuffle = 182,
+    OpenCLstd_Shuffle2 = 183,
+
+    // Section 2.8: Misc instructions 
+    OpenCLstd_Printf = 184,
+    OpenCLstd_Prefetch = 185,
+};
+
+#endif
+
+#endif  // #ifndef OPENCLstd_H

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/OpenCLDebugInfo100.h

@@ -0,0 +1,158 @@
+// Copyright (c) 2018-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+#ifndef SPIRV_UNIFIED1_OpenCLDebugInfo100_H_
+#define SPIRV_UNIFIED1_OpenCLDebugInfo100_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    OpenCLDebugInfo100Version = 200,
+    OpenCLDebugInfo100Version_BitWidthPadding = 0x7fffffff
+};
+enum {
+    OpenCLDebugInfo100Revision = 2,
+    OpenCLDebugInfo100Revision_BitWidthPadding = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100Instructions {
+    OpenCLDebugInfo100DebugInfoNone = 0,
+    OpenCLDebugInfo100DebugCompilationUnit = 1,
+    OpenCLDebugInfo100DebugTypeBasic = 2,
+    OpenCLDebugInfo100DebugTypePointer = 3,
+    OpenCLDebugInfo100DebugTypeQualifier = 4,
+    OpenCLDebugInfo100DebugTypeArray = 5,
+    OpenCLDebugInfo100DebugTypeVector = 6,
+    OpenCLDebugInfo100DebugTypedef = 7,
+    OpenCLDebugInfo100DebugTypeFunction = 8,
+    OpenCLDebugInfo100DebugTypeEnum = 9,
+    OpenCLDebugInfo100DebugTypeComposite = 10,
+    OpenCLDebugInfo100DebugTypeMember = 11,
+    OpenCLDebugInfo100DebugTypeInheritance = 12,
+    OpenCLDebugInfo100DebugTypePtrToMember = 13,
+    OpenCLDebugInfo100DebugTypeTemplate = 14,
+    OpenCLDebugInfo100DebugTypeTemplateParameter = 15,
+    OpenCLDebugInfo100DebugTypeTemplateTemplateParameter = 16,
+    OpenCLDebugInfo100DebugTypeTemplateParameterPack = 17,
+    OpenCLDebugInfo100DebugGlobalVariable = 18,
+    OpenCLDebugInfo100DebugFunctionDeclaration = 19,
+    OpenCLDebugInfo100DebugFunction = 20,
+    OpenCLDebugInfo100DebugLexicalBlock = 21,
+    OpenCLDebugInfo100DebugLexicalBlockDiscriminator = 22,
+    OpenCLDebugInfo100DebugScope = 23,
+    OpenCLDebugInfo100DebugNoScope = 24,
+    OpenCLDebugInfo100DebugInlinedAt = 25,
+    OpenCLDebugInfo100DebugLocalVariable = 26,
+    OpenCLDebugInfo100DebugInlinedVariable = 27,
+    OpenCLDebugInfo100DebugDeclare = 28,
+    OpenCLDebugInfo100DebugValue = 29,
+    OpenCLDebugInfo100DebugOperation = 30,
+    OpenCLDebugInfo100DebugExpression = 31,
+    OpenCLDebugInfo100DebugMacroDef = 32,
+    OpenCLDebugInfo100DebugMacroUndef = 33,
+    OpenCLDebugInfo100DebugImportedEntity = 34,
+    OpenCLDebugInfo100DebugSource = 35,
+    OpenCLDebugInfo100DebugModuleINTEL = 36,
+    OpenCLDebugInfo100InstructionsMax = 0x7fffffff
+};
+
+
+enum OpenCLDebugInfo100DebugInfoFlags {
+    OpenCLDebugInfo100None = 0x0000,
+    OpenCLDebugInfo100FlagIsProtected = 0x01,
+    OpenCLDebugInfo100FlagIsPrivate = 0x02,
+    OpenCLDebugInfo100FlagIsPublic = 0x03,
+    OpenCLDebugInfo100FlagIsLocal = 0x04,
+    OpenCLDebugInfo100FlagIsDefinition = 0x08,
+    OpenCLDebugInfo100FlagFwdDecl = 0x10,
+    OpenCLDebugInfo100FlagArtificial = 0x20,
+    OpenCLDebugInfo100FlagExplicit = 0x40,
+    OpenCLDebugInfo100FlagPrototyped = 0x80,
+    OpenCLDebugInfo100FlagObjectPointer = 0x100,
+    OpenCLDebugInfo100FlagStaticMember = 0x200,
+    OpenCLDebugInfo100FlagIndirectVariable = 0x400,
+    OpenCLDebugInfo100FlagLValueReference = 0x800,
+    OpenCLDebugInfo100FlagRValueReference = 0x1000,
+    OpenCLDebugInfo100FlagIsOptimized = 0x2000,
+    OpenCLDebugInfo100FlagIsEnumClass = 0x4000,
+    OpenCLDebugInfo100FlagTypePassByValue = 0x8000,
+    OpenCLDebugInfo100FlagTypePassByReference = 0x10000,
+    OpenCLDebugInfo100DebugInfoFlagsMax = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100DebugBaseTypeAttributeEncoding {
+    OpenCLDebugInfo100Unspecified = 0,
+    OpenCLDebugInfo100Address = 1,
+    OpenCLDebugInfo100Boolean = 2,
+    OpenCLDebugInfo100Float = 3,
+    OpenCLDebugInfo100Signed = 4,
+    OpenCLDebugInfo100SignedChar = 5,
+    OpenCLDebugInfo100Unsigned = 6,
+    OpenCLDebugInfo100UnsignedChar = 7,
+    OpenCLDebugInfo100DebugBaseTypeAttributeEncodingMax = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100DebugCompositeType {
+    OpenCLDebugInfo100Class = 0,
+    OpenCLDebugInfo100Structure = 1,
+    OpenCLDebugInfo100Union = 2,
+    OpenCLDebugInfo100DebugCompositeTypeMax = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100DebugTypeQualifier {
+    OpenCLDebugInfo100ConstType = 0,
+    OpenCLDebugInfo100VolatileType = 1,
+    OpenCLDebugInfo100RestrictType = 2,
+    OpenCLDebugInfo100AtomicType = 3,
+    OpenCLDebugInfo100DebugTypeQualifierMax = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100DebugOperation {
+    OpenCLDebugInfo100Deref = 0,
+    OpenCLDebugInfo100Plus = 1,
+    OpenCLDebugInfo100Minus = 2,
+    OpenCLDebugInfo100PlusUconst = 3,
+    OpenCLDebugInfo100BitPiece = 4,
+    OpenCLDebugInfo100Swap = 5,
+    OpenCLDebugInfo100Xderef = 6,
+    OpenCLDebugInfo100StackValue = 7,
+    OpenCLDebugInfo100Constu = 8,
+    OpenCLDebugInfo100Fragment = 9,
+    OpenCLDebugInfo100DebugOperationMax = 0x7fffffff
+};
+
+enum OpenCLDebugInfo100DebugImportedEntity {
+    OpenCLDebugInfo100ImportedModule = 0,
+    OpenCLDebugInfo100ImportedDeclaration = 1,
+    OpenCLDebugInfo100DebugImportedEntityMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_OpenCLDebugInfo100_H_

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.debuginfo.grammar.json

@@ -0,0 +1,572 @@
+{
+  "copyright" : [
+    "Copyright (c) 2017-2024 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 1,
+  "instructions" : [
+    {
+      "opname" : "DebugInfoNone",
+      "opcode" : 0
+    },
+    {
+      "opname" : "DebugCompilationUnit",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Version'" },
+        { "kind" : "LiteralInteger", "name" : "'DWARF Version'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeBasic",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugBaseTypeAttributeEncoding", "name" : "'Encoding'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePointer",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "StorageClass", "name" : "'Storage Class'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Literal Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeQualifier",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "DebugTypeQualifier", "name" : "'Type Qualifier'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeArray",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Component Counts'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeVector",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "LiteralInteger", "name" : "'Component Count'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypedef",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeFunction",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Return Type'" },
+        { "kind" : "IdRef", "name" : "'Paramter Types'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeEnum",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Underlying Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "PairIdRefIdRef", "name" : "'Value, Name, Value, Name, ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeComposite",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "DebugCompositeType", "name" : "'Tag'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Members'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeMember",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeInheritance",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Child'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePtrToMember",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Member Type'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplate",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Target'" },
+        { "kind" : "IdRef", "name" : "'Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameter",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Actual Type'" },
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateTemplateParameter",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Template Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameterPack",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Template Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugGlobalVariable",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Static Member Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugFunctionDeclaration",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugFunction",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "LiteralInteger", "name" : "'Scope Line'" },
+        { "kind" : "IdRef", "name" : "'Function'" },
+        { "kind" : "IdRef", "name" : "'Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlock",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Name'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlockDiscriminator",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "LiteralInteger", "name" : "'Discriminator'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugScope",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined At'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugNoScope",
+      "opcode" : 24
+    },
+    {
+      "opname" : "DebugInlinedAt",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLocalVariable",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "LiteralInteger", "name" : "'Arg Number'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugInlinedVariable",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Inlined'" }
+      ]
+    },
+    {
+      "opname" : "DebugDeclare",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Local Variable'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Expression'" }
+      ]
+    },
+    {
+      "opname" : "DebugValue",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Expression'" },
+        { "kind" : "IdRef", "name" : "'Indexes'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugOperation",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "DebugOperation", "name" : "'OpCode'" },
+        { "kind" : "LiteralInteger", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugExpression",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroDef",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroUndef",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Macro'" }
+      ]
+    }
+  ],
+  "operand_kinds" : [
+    {
+      "category" : "BitEnum",
+      "kind" : "DebugInfoFlags",
+      "enumerants" : [
+        {
+          "enumerant" : "None",
+          "value" : "0x0000"
+        },
+        {
+          "enumerant" : "FlagIsProtected",
+          "value" : "0x01"
+        },
+        {
+          "enumerant" : "FlagIsPrivate",
+          "value" : "0x02"
+        },
+        {
+          "enumerant" : "FlagIsPublic",
+          "value" : "0x03"
+        },
+        {
+          "enumerant" : "FlagIsLocal",
+          "value" : "0x04"
+        },
+        {
+          "enumerant" : "FlagIsDefinition",
+          "value" : "0x08"
+        },
+        {
+          "enumerant" : "FlagFwdDecl",
+          "value" : "0x10"
+        },
+        {
+          "enumerant" : "FlagArtificial",
+          "value" : "0x20"
+        },
+        {
+          "enumerant" : "FlagExplicit",
+          "value" : "0x40"
+        },
+        {
+          "enumerant" : "FlagPrototyped",
+          "value" : "0x80"
+        },
+        {
+          "enumerant" : "FlagObjectPointer",
+          "value" : "0x100"
+        },
+        {
+          "enumerant" : "FlagStaticMember",
+          "value" : "0x200"
+        },
+        {
+          "enumerant" : "FlagIndirectVariable",
+          "value" : "0x400"
+        },
+        {
+          "enumerant" : "FlagLValueReference",
+          "value" : "0x800"
+        },
+        {
+          "enumerant" : "FlagRValueReference",
+          "value" : "0x1000"
+        },
+        {
+          "enumerant" : "FlagIsOptimized",
+          "value" : "0x2000"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugBaseTypeAttributeEncoding",
+      "enumerants" : [
+        {
+          "enumerant" : "Unspecified",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Address",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Boolean",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "Float",
+          "value" : "4"
+        },
+        {
+          "enumerant" : "Signed",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "SignedChar",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "Unsigned",
+          "value" : "7"
+        },
+        {
+          "enumerant" : "UnsignedChar",
+          "value" : "8"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugCompositeType",
+      "enumerants" : [
+        {
+          "enumerant" : "Class",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Structure",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Union",
+          "value" : "2"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugTypeQualifier",
+      "enumerants" : [
+        {
+          "enumerant" : "ConstType",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "VolatileType",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "RestrictType",
+          "value" : "2"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugOperation",
+      "enumerants" : [
+        {
+          "enumerant" : "Deref",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Plus",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Minus",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "PlusUconst",
+          "value" : "3",
+          "parameters" : [
+             { "kind" : "LiteralInteger" }
+          ]
+        },
+        {
+          "enumerant" : "BitPiece",
+          "value" : "4",
+          "parameters" : [
+             { "kind" : "LiteralInteger" },
+             { "kind" : "LiteralInteger" }
+          ]
+        },
+        {
+          "enumerant" : "Swap",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "Xderef",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "StackValue",
+          "value" : "7"
+        },
+        {
+          "enumerant" : "Constu",
+          "value" : "8",
+          "parameters" : [
+             { "kind" : "LiteralInteger" }
+          ]
+        }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.glsl.std.450.grammar.json

@@ -0,0 +1,642 @@
+{
+  "copyright" : [
+    "Copyright (c) 2014-2024 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "Round",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "RoundEven",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Trunc",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FAbs",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SAbs",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FSign",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SSign",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Floor",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ceil",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fract",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Radians",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'degrees'" }
+      ]
+    },
+    {
+      "opname" : "Degrees",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'radians'" }
+      ]
+    },
+    {
+      "opname" : "Sin",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cos",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tan",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asin",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acos",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y_over_x'" }
+      ]
+    },
+    {
+      "opname" : "Sinh",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Cosh",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Tanh",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Asinh",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Acosh",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atanh",
+      "opcode" : 24,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Atan2",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Pow",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Exp",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Exp2",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Log2",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Sqrt",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "InverseSqrt",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Determinant",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "MatrixInverse",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Modf",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'i'" }
+      ]
+    },
+    {
+      "opname" : "ModfStruct",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FMin",
+      "opcode" : 37,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMin",
+      "opcode" : 38,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMin",
+      "opcode" : 39,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FMax",
+      "opcode" : 40,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "UMax",
+      "opcode" : 41,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "SMax",
+      "opcode" : 42,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "FClamp",
+      "opcode" : 43,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "UClamp",
+      "opcode" : 44,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "SClamp",
+      "opcode" : 45,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    },
+    {
+      "opname" : "FMix",
+      "opcode" : 46,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "IMix",
+      "opcode" : 47,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'a'" }
+      ]
+    },
+    {
+      "opname" : "Step",
+      "opcode" : 48,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "SmoothStep",
+      "opcode" : 49,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'edge0'" },
+        { "kind" : "IdRef", "name" : "'edge1'" },
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Fma",
+      "opcode" : 50,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'a'" },
+        { "kind" : "IdRef", "name" : "'b'" },
+        { "kind" : "IdRef", "name" : "'c'" }
+      ]
+    },
+    {
+      "opname" : "Frexp",
+      "opcode" : 51,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "FrexpStruct",
+      "opcode" : 52,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Ldexp",
+      "opcode" : 53,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'exp'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm4x8",
+      "opcode" : 54,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm4x8",
+      "opcode" : 55,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackSnorm2x16",
+      "opcode" : 56,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackUnorm2x16",
+      "opcode" : 57,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackHalf2x16",
+      "opcode" : 58,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "PackDouble2x32",
+      "opcode" : 59,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "UnpackSnorm2x16",
+      "opcode" : 60,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm2x16",
+      "opcode" : 61,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackHalf2x16",
+      "opcode" : 62,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ]
+    },
+    {
+      "opname" : "UnpackSnorm4x8",
+      "opcode" : 63,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackUnorm4x8",
+      "opcode" : 64,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p'" }
+      ]
+    },
+    {
+      "opname" : "UnpackDouble2x32",
+      "opcode" : 65,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'v'" }
+      ],
+      "capabilities" : [ "Float64" ]
+    },
+    {
+      "opname" : "Length",
+      "opcode" : 66,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "Distance",
+      "opcode" : 67,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'p0'" },
+        { "kind" : "IdRef", "name" : "'p1'" }
+      ]
+    },
+    {
+      "opname" : "Cross",
+      "opcode" : 68,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "Normalize",
+      "opcode" : 69,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" }
+      ]
+    },
+    {
+      "opname" : "FaceForward",
+      "opcode" : 70,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'Nref'" }
+      ]
+    },
+    {
+      "opname" : "Reflect",
+      "opcode" : 71,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" }
+      ]
+    },
+    {
+      "opname" : "Refract",
+      "opcode" : 72,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'I'" },
+        { "kind" : "IdRef", "name" : "'N'" },
+        { "kind" : "IdRef", "name" : "'eta'" }
+      ]
+    },
+    {
+      "opname" : "FindILsb",
+      "opcode" : 73,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindSMsb",
+      "opcode" : 74,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "FindUMsb",
+      "opcode" : 75,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Value'" }
+      ]
+    },
+    {
+      "opname" : "InterpolateAtCentroid",
+      "opcode" : 76,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtSample",
+      "opcode" : 77,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'sample'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "InterpolateAtOffset",
+      "opcode" : 78,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'offset'" }
+      ],
+      "capabilities" : [ "InterpolationFunction" ]
+    },
+    {
+      "opname" : "NMin",
+      "opcode" : 79,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NMax",
+      "opcode" : 80,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" }
+      ]
+    },
+    {
+      "opname" : "NClamp",
+      "opcode" : 81,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'minVal'" },
+        { "kind" : "IdRef", "name" : "'maxVal'" }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.nonsemantic.clspvreflection.grammar.json

@@ -0,0 +1,426 @@
+{
+  "revision" : 6,
+  "instructions" : [
+    {
+      "opname" : "Kernel",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Name" },
+        { "kind" : "IdRef", "name" : "NumArguments", "quantifier" : "?" },
+        { "kind" : "IdRef", "name" : "Flags", "quantifier" : "?"  },
+        { "kind" : "IdRef", "name" : "Attributes", "quantifier" : "?"  }
+      ]
+    },
+    {
+      "opname" : "ArgumentInfo",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Name" },
+        { "kind" : "IdRef", "name" : "Type Name", "quantifier" : "?" },
+        { "kind" : "IdRef", "name" : "Address Qualifier", "quantifier" : "?" },
+        { "kind" : "IdRef", "name" : "Access Qualifier", "quantifier" : "?" },
+        { "kind" : "IdRef", "name" : "Type Qualifier", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentStorageBuffer",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentUniform",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentPodStorageBuffer",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentPodUniform",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentPodPushConstant",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentSampledImage",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentStorageImage",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentSampler",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentWorkgroup",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "SpecId" },
+        { "kind" : "IdRef", "name" : "ElemSize" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "SpecConstantWorkgroupSize",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "X" },
+        { "kind" : "IdRef", "name" : "Y" },
+        { "kind" : "IdRef", "name" : "Z" }
+      ]
+    },
+    {
+      "opname" : "SpecConstantGlobalOffset",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "X" },
+        { "kind" : "IdRef", "name" : "Y" },
+        { "kind" : "IdRef", "name" : "Z" }
+      ]
+    },
+    {
+      "opname" : "SpecConstantWorkDim",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Dim" }
+      ]
+    },
+    {
+      "opname" : "PushConstantGlobalOffset",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "PushConstantEnqueuedLocalSize",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "PushConstantGlobalSize",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "PushConstantRegionOffset",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "PushConstantNumWorkgroups",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "PushConstantRegionGroupOffset",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ConstantDataStorageBuffer",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Data" }
+      ]
+    },
+    {
+      "opname" : "ConstantDataUniform",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Data" }
+      ]
+    },
+    {
+      "opname" : "LiteralSampler",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Mask" }
+      ]
+    },
+    {
+      "opname" : "PropertyRequiredWorkgroupSize",
+      "opcode" : 24,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "X" },
+        { "kind" : "IdRef", "name" : "Y" },
+        { "kind" : "IdRef", "name" : "Z" }
+      ]
+    },
+    {
+      "opname" : "SpecConstantSubgroupMaxSize",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ArgumentPointerPushConstant",
+      "opcode" : 26,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentPointerUniform",
+      "opcode" : 27,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ProgramScopeVariablesStorageBuffer",
+      "opcode" : 28,
+      "operands": [
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Data" }
+      ]
+    },
+    {
+      "opname" : "ProgramScopeVariablePointerRelocation",
+      "opcode" : 29,
+      "operands": [
+        { "kind" : "IdRef", "name" : "ObjectOffset" },
+        { "kind" : "IdRef", "name" : "PointerOffset" },
+        { "kind" : "IdRef", "name" : "PointerSize" }
+      ]
+    },
+    {
+      "opname" : "ImageArgumentInfoChannelOrderPushConstant",
+      "opcode" : 30,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ImageArgumentInfoChannelDataTypePushConstant",
+      "opcode" : 31,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ImageArgumentInfoChannelOrderUniform",
+      "opcode" : 32,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ImageArgumentInfoChannelDataTypeUniform",
+      "opcode" : 33,
+      "operands": [
+        { "kind" : "IdRef", "name" : "Kernel" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "Offset" },
+        { "kind" : "IdRef", "name" : "Size" }
+      ]
+    },
+    {
+      "opname" : "ArgumentStorageTexelBuffer",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ArgumentUniformTexelBuffer",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Decl" },
+        { "kind" : "IdRef", "name" : "Ordinal" },
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "ArgInfo", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "ConstantDataPointerPushConstant",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset"},
+        { "kind" : "IdRef", "name" : "Size"},
+        { "kind" : "IdRef", "name" : "Data" }
+      ]
+    },
+    {
+      "opname" : "ProgramScopeVariablePointerPushConstant",
+      "opcode" : 37,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "Offset"},
+        { "kind" : "IdRef", "name" : "Size"},
+        { "kind" : "IdRef", "name" : "Data" }
+      ]
+    },
+    {
+      "opname" : "PrintfInfo",
+      "opcode" : 38,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "PrintfID" },
+        { "kind" : "IdRef", "name" : "FormatString" },
+        { "kind" : "IdRef", "quantifier" : "*", "name" : "ArgumentSizes"}
+      ]
+    },
+    {
+      "opname" : "PrintfBufferStorageBuffer",
+      "opcode" : 39,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "DescriptorSet" },
+        { "kind" : "IdRef", "name" : "Binding" },
+        { "kind" : "IdRef", "name" : "BufferSize"}
+      ]
+    },
+    {
+    "opname" : "PrintfBufferPointerPushConstant",
+    "opcode" : 40,
+    "operands" : [
+      { "kind" : "IdRef", "name" : "Offset" },
+      { "kind" : "IdRef", "name" : "Size"},
+      { "kind" : "IdRef", "name" : "BufferSize"}
+      ]
+    },
+    {
+    "opname" : "NormalizedSamplerMaskPushConstant",
+    "opcode" : 41,
+    "operands" : [
+      { "kind" : "IdRef", "name" : "Kernel" },
+      { "kind" : "IdRef", "name" : "Ordinal" },
+      { "kind" : "IdRef", "name" : "Offset" },
+      { "kind" : "IdRef", "name" : "Size" }
+      ]
+    }
+  ],
+  "operand_kinds" : [
+    {
+      "category" : "BitEnum",
+      "kind" : "KernelPropertyFlags",
+      "enumerants" : [
+        {
+          "enumerant" : "None",
+          "value" : "0x0"
+        },
+        {
+          "enumerant" : "MayUsePrintf",
+          "value" : "0x1"
+        }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.nonsemantic.debugbreak.grammar.json

@@ -0,0 +1,9 @@
+{
+  "revision" : 1,
+  "instructions" : [
+    {
+      "opname" : "DebugBreak",
+      "opcode" : 1
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.nonsemantic.debugprintf.grammar.json

@@ -0,0 +1,13 @@
+{
+  "revision" : 1,
+  "instructions" : [
+    {
+      "opname" : "DebugPrintf",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef",        "name" : "'Format'" },
+        { "kind" : "IdRef",        "quantifier" : "*" }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.nonsemantic.shader.debuginfo.100.grammar.json

@@ -0,0 +1,713 @@
+{
+  "copyright" : [
+    "Copyright (c) 2018-2024 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 100,
+  "revision" : 6,
+  "instructions" : [
+    {
+      "opname" : "DebugInfoNone",
+      "opcode" : 0
+    },
+    {
+      "opname" : "DebugCompilationUnit",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Version'" },
+        { "kind" : "IdRef", "name" : "'DWARF Version'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Language'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeBasic",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "IdRef", "name" : "'Encoding'" },
+        { "kind" : "IdRef", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePointer",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Storage Class'" },
+        { "kind" : "IdRef", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeQualifier",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Type Qualifier'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeArray",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Component Counts'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeVector",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Component Count'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypedef",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeFunction",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Return Type'" },
+        { "kind" : "IdRef", "name" : "'Parameter Types'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeEnum",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Underlying Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "PairIdRefIdRef", "name" : "'Value, Name, Value, Name, ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeComposite",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Tag'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Members'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeMember",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeInheritance",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "IdRef", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePtrToMember",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Member Type'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplate",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Target'" },
+        { "kind" : "IdRef", "name" : "'Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameter",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Actual Type'" },
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateTemplateParameter",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Template Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameterPack",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Template Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugGlobalVariable",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Static Member Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugFunctionDeclaration",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugFunction",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Scope Line'" },
+        { "kind" : "IdRef", "name" : "'Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlock",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Name'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlockDiscriminator",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Discriminator'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugScope",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined At'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugNoScope",
+      "opcode" : 24
+    },
+    {
+      "opname" : "DebugInlinedAt",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLocalVariable",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Arg Number'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugInlinedVariable",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Inlined'" }
+      ]
+    },
+    {
+      "opname" : "DebugDeclare",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Local Variable'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Expression'" },
+        { "kind" : "IdRef", "name" : "'Indexes'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugValue",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Local Variable'" },
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Expression'" },
+        { "kind" : "IdRef", "name" : "'Indexes'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugOperation",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'OpCode'" },
+        { "kind" : "IdRef", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugExpression",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroDef",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroUndef",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Macro'" }
+      ]
+    },
+    {
+      "opname" : "DebugImportedEntity",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Tag'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Entity'" },
+        { "kind" : "IdRef", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugSource",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'File'" },
+        { "kind" : "IdRef", "name" : "'Text'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugFunctionDefinition",
+      "opcode" : 101,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Function'" },
+        { "kind" : "IdRef", "name" : "'Definition'" }
+      ]
+    },
+    {
+      "opname" : "DebugSourceContinued",
+      "opcode" : 102,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Text'" }
+      ]
+    },
+    {
+      "opname" : "DebugLine",
+      "opcode" : 103,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Line Start'" },
+        { "kind" : "IdRef", "name" : "'Line End'" },
+        { "kind" : "IdRef", "name" : "'Column Start'" },
+        { "kind" : "IdRef", "name" : "'Column End'" }
+      ]
+    },
+    {
+      "opname" : "DebugNoLine",
+      "opcode" : 104
+    },
+    {
+      "opname" : "DebugBuildIdentifier",
+      "opcode" : 105,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Identifier'" },
+        { "kind" : "IdRef", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugStoragePath",
+      "opcode" : 106,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Path'" }
+      ]
+    },
+    {
+      "opname" : "DebugEntryPoint",
+      "opcode" : 107,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Entry Point'" },
+        { "kind" : "IdRef", "name" : "'Compilation Unit'" },
+        { "kind" : "IdRef", "name" : "'Compiler Signature'" },
+        { "kind" : "IdRef", "name" : "'Command-line Arguments'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeMatrix",
+      "opcode" : 108,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Vector Type'" },
+        { "kind" : "IdRef", "name" : "'Vector Count'" },
+        { "kind" : "IdRef", "name" : "'Column Major'" }
+      ]
+    }
+  ],
+  "operand_kinds" : [
+    {
+      "category" : "BitEnum",
+      "kind" : "DebugInfoFlags",
+      "enumerants" : [
+        {
+          "enumerant" : "None",
+          "value" : "0x0000"
+        },
+        {
+          "enumerant" : "FlagIsProtected",
+          "value" : "0x01"
+        },
+        {
+          "enumerant" : "FlagIsPrivate",
+          "value" : "0x02"
+        },
+        {
+          "enumerant" : "FlagIsPublic",
+          "value" : "0x03"
+        },
+        {
+          "enumerant" : "FlagIsLocal",
+          "value" : "0x04"
+        },
+        {
+          "enumerant" : "FlagIsDefinition",
+          "value" : "0x08"
+        },
+        {
+          "enumerant" : "FlagFwdDecl",
+          "value" : "0x10"
+        },
+        {
+          "enumerant" : "FlagArtificial",
+          "value" : "0x20"
+        },
+        {
+          "enumerant" : "FlagExplicit",
+          "value" : "0x40"
+        },
+        {
+          "enumerant" : "FlagPrototyped",
+          "value" : "0x80"
+        },
+        {
+          "enumerant" : "FlagObjectPointer",
+          "value" : "0x100"
+        },
+        {
+          "enumerant" : "FlagStaticMember",
+          "value" : "0x200"
+        },
+        {
+          "enumerant" : "FlagIndirectVariable",
+          "value" : "0x400"
+        },
+        {
+          "enumerant" : "FlagLValueReference",
+          "value" : "0x800"
+        },
+        {
+          "enumerant" : "FlagRValueReference",
+          "value" : "0x1000"
+        },
+        {
+          "enumerant" : "FlagIsOptimized",
+          "value" : "0x2000"
+        },
+        {
+          "enumerant" : "FlagIsEnumClass",
+          "value" : "0x4000"
+        },
+        {
+          "enumerant" : "FlagTypePassByValue",
+          "value" : "0x8000"
+        },
+        {
+          "enumerant" : "FlagTypePassByReference",
+          "value" : "0x10000"
+        },
+        {
+          "enumerant" : "FlagUnknownPhysicalLayout",
+          "value" : "0x20000"
+        }
+      ]
+    },
+    {
+      "category" : "BitEnum",
+      "kind" : "BuildIdentifierFlags",
+      "enumerants" : [
+        {
+          "enumerant" : "IdentifierPossibleDuplicates",
+          "value" : "0x01"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugBaseTypeAttributeEncoding",
+      "enumerants" : [
+        {
+          "enumerant" : "Unspecified",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Address",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Boolean",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "Float",
+          "value" : "3"
+        },
+        {
+          "enumerant" : "Signed",
+          "value" : "4"
+        },
+        {
+          "enumerant" : "SignedChar",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "Unsigned",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "UnsignedChar",
+          "value" : "7"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugCompositeType",
+      "enumerants" : [
+        {
+          "enumerant" : "Class",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Structure",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Union",
+          "value" : "2"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugTypeQualifier",
+      "enumerants" : [
+        {
+          "enumerant" : "ConstType",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "VolatileType",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "RestrictType",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "AtomicType",
+          "value" : "3"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugOperation",
+      "enumerants" : [
+        {
+          "enumerant" : "Deref",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Plus",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Minus",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "PlusUconst",
+          "value" : "3",
+          "parameters" : [
+             { "kind" : "IdRef" }
+          ]
+        },
+        {
+          "enumerant" : "BitPiece",
+          "value" : "4",
+          "parameters" : [
+             { "kind" : "IdRef" },
+             { "kind" : "IdRef" }
+          ]
+        },
+        {
+          "enumerant" : "Swap",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "Xderef",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "StackValue",
+          "value" : "7"
+        },
+        {
+          "enumerant" : "Constu",
+          "value" : "8",
+          "parameters" : [
+             { "kind" : "IdRef" }
+          ]
+        },
+        {
+          "enumerant" : "Fragment",
+          "value" : "9",
+          "parameters" : [
+             { "kind" : "IdRef" },
+             { "kind" : "IdRef" }
+          ]
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugImportedEntity",
+      "enumerants" : [
+        {
+          "enumerant" : "ImportedModule",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "ImportedDeclaration",
+          "value" : "1"
+        }
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json

@@ -0,0 +1,138 @@
+{
+  "revision" : 3,
+  "instructions" : [
+    {
+      "opname" : "Configuration",
+      "opcode" : 1,
+      "operands" : [
+        {"kind" : "LiteralString", "name" : "enabledExtensionNames" },
+        {"kind" : "LiteralInteger", "name" : "specializationInfoDataSize" },
+        {"kind" : "LiteralString", "name" : "specializationInfoData" },
+        {"kind" : "LiteralString", "name" : "shaderName" },
+        {"kind" : "LiteralString", "name" : "EntryPoint" },
+        {"kind" : "LiteralInteger", "name" : "groupCountX" },
+        {"kind" : "LiteralInteger", "name" : "groupCountY" },
+        {"kind" : "LiteralInteger", "name" : "groupCountZ" },
+        {"kind" : "LiteralInteger", "name" : "dispatchId" }
+      ]
+    },
+    {
+      "opname" : "StartCounter",
+      "opcode" : 2,
+      "operands" : [
+        {"kind" : "LiteralString", "name" : "name" }
+      ]
+    },
+    {
+      "opname" : "StopCounter",
+      "opcode" : 3,
+      "operands" : [
+        {"kind" : "IdRef", "name" : "counter" }
+      ]
+    },
+    {
+      "opname" : "PushConstants",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "offset" },
+        { "kind" : "LiteralInteger", "name" : "size" },
+        { "kind" : "LiteralString", "name" : "pValues" },
+        { "kind" : "LiteralInteger", "name" : "stageFlags" }
+      ]
+    },
+    {
+      "opname" : "SpecializationMapEntry",
+      "opcode" : 5,
+      "operands" : [
+        {"kind" : "LiteralInteger", "name" : "constantID" },
+        {"kind" : "LiteralInteger", "name" : "offset" },
+        {"kind" : "LiteralInteger", "name" : "size" }
+      ]
+    },
+    {
+      "opname" : "DescriptorSetBuffer",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "LiteralInteger", "name" : "flags" },
+        { "kind" : "LiteralInteger", "name" : "queueFamilyIndexCount" },
+        { "kind" : "LiteralInteger", "name" : "sharingMode" },
+        { "kind" : "LiteralInteger", "name" : "size" },
+        { "kind" : "LiteralInteger", "name" : "usage" },
+        { "kind" : "LiteralInteger", "name" : "range" },
+        { "kind" : "LiteralInteger", "name" : "offset" },
+        { "kind" : "LiteralInteger", "name" : "memorySize" },
+        { "kind" : "LiteralInteger", "name" : "memoryType" },
+        { "kind" : "LiteralInteger", "name" : "bindOffset" },
+        { "kind" : "LiteralInteger", "name" : "viewFlags" },
+        { "kind" : "LiteralInteger", "name" : "viewFormat" }
+      ]
+    },
+    {
+      "opname" : "DescriptorSetImage",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "LiteralInteger", "name" : "imageLayout"},
+        { "kind" : "LiteralInteger", "name" : "imageFlags"},
+        { "kind" : "LiteralInteger", "name" : "imageType"},
+        { "kind" : "LiteralInteger", "name" : "imageformat"},
+        { "kind" : "LiteralInteger", "name" : "width"},
+        { "kind" : "LiteralInteger", "name" : "height"},
+        { "kind" : "LiteralInteger", "name" : "depth"},
+        { "kind" : "LiteralInteger", "name" : "mipLevels"},
+        { "kind" : "LiteralInteger", "name" : "arrayLayers"},
+        { "kind" : "LiteralInteger", "name" : "samples"},
+        { "kind" : "LiteralInteger", "name" : "tiling"},
+        { "kind" : "LiteralInteger", "name" : "usage"},
+        { "kind" : "LiteralInteger", "name" : "sharingMode"},
+        { "kind" : "LiteralInteger", "name" : "queueFamilyIndexCount"},
+        { "kind" : "LiteralInteger", "name" : "initialLayout"},
+        { "kind" : "LiteralInteger", "name" : "aspectMask"},
+        { "kind" : "LiteralInteger", "name" : "baseMipLevel"},
+        { "kind" : "LiteralInteger", "name" : "levelCount"},
+        { "kind" : "LiteralInteger", "name" : "baseArrayLayer"},
+        { "kind" : "LiteralInteger", "name" : "layerCount"},
+        { "kind" : "LiteralInteger", "name" : "viewFlags"},
+        { "kind" : "LiteralInteger", "name" : "viewType"},
+        { "kind" : "LiteralInteger", "name" : "viewFormat"},
+        { "kind" : "LiteralInteger", "name" : "component_a"},
+        { "kind" : "LiteralInteger", "name" : "component_b"},
+        { "kind" : "LiteralInteger", "name" : "component_g"},
+        { "kind" : "LiteralInteger", "name" : "component_r"},
+        { "kind" : "LiteralInteger", "name" : "memorySize" },
+        { "kind" : "LiteralInteger", "name" : "memoryType" },
+        { "kind" : "LiteralInteger", "name" : "bindOffset"}
+      ]
+    },
+    {
+      "opname" : "DescriptorSetSampler",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "LiteralInteger", "name" : "flags"},
+        { "kind" : "LiteralInteger", "name" : "magFilter"},
+        { "kind" : "LiteralInteger", "name" : "minFilter"},
+        { "kind" : "LiteralInteger", "name" : "mipmapMode"},
+        { "kind" : "LiteralInteger", "name" : "addressModeU"},
+        { "kind" : "LiteralInteger", "name" : "addressModeV"},
+        { "kind" : "LiteralInteger", "name" : "addressModeW"},
+        { "kind" : "LiteralFloat", "name" : "mipLodBias"},
+        { "kind" : "LiteralInteger", "name" : "anisotropyEnable"},
+        { "kind" : "LiteralFloat", "name" : "maxAnisotropy"},
+        { "kind" : "LiteralInteger", "name" : "compareEnable"},
+        { "kind" : "LiteralInteger", "name" : "compareOp"},
+        { "kind" : "LiteralFloat", "name" : "minLod"},
+        { "kind" : "LiteralFloat", "name" : "maxLod"},
+        { "kind" : "LiteralInteger", "name" : "borderColor"},
+        { "kind" : "LiteralInteger", "name" : "unnormalizedCoordinates"}
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.opencl.debuginfo.100.grammar.json

@@ -0,0 +1,651 @@
+{
+  "copyright" : [
+    "Copyright (c) 2018-2024 The Khronos Group Inc.",
+    "",
+    "Permission is hereby granted, free of charge, to any person obtaining a copy",
+    "of this software and/or associated documentation files (the \"Materials\"),",
+    "to deal in the Materials without restriction, including without limitation",
+    "the rights to use, copy, modify, merge, publish, distribute, sublicense,",
+    "and/or sell copies of the Materials, and to permit persons to whom the",
+    "Materials are furnished to do so, subject to the following conditions:",
+    "",
+    "The above copyright notice and this permission notice shall be included in",
+    "all copies or substantial portions of the Materials.",
+    "",
+    "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS",
+    "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND",
+    "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ",
+    "",
+    "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+    "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL",
+    "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING",
+    "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS",
+    "IN THE MATERIALS."
+  ],
+  "version" : 200,
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "DebugInfoNone",
+      "opcode" : 0
+    },
+    {
+      "opname" : "DebugCompilationUnit",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "'Version'" },
+        { "kind" : "LiteralInteger", "name" : "'DWARF Version'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "SourceLanguage", "name" : "'Language'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeBasic",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugBaseTypeAttributeEncoding", "name" : "'Encoding'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePointer",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "StorageClass", "name" : "'Storage Class'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeQualifier",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "DebugTypeQualifier", "name" : "'Type Qualifier'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeArray",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Component Counts'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeVector",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "LiteralInteger", "name" : "'Component Count'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypedef",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Base Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeFunction",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Return Type'" },
+        { "kind" : "IdRef", "name" : "'Parameter Types'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeEnum",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Underlying Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "PairIdRefIdRef", "name" : "'Value, Name, Value, Name, ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeComposite",
+      "opcode" : 10,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "DebugCompositeType", "name" : "'Tag'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Members'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeMember",
+      "opcode" : 11,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeInheritance",
+      "opcode" : 12,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Child'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Offset'" },
+        { "kind" : "IdRef", "name" : "'Size'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypePtrToMember",
+      "opcode" : 13,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Member Type'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplate",
+      "opcode" : 14,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Target'" },
+        { "kind" : "IdRef", "name" : "'Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameter",
+      "opcode" : 15,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Actual Type'" },
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateTemplateParameter",
+      "opcode" : 16,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Template Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" }
+      ]
+    },
+    {
+      "opname" : "DebugTypeTemplateParameterPack",
+      "opcode" : 17,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Template Parameters'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugGlobalVariable",
+      "opcode" : 18,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "IdRef", "name" : "'Static Member Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugFunctionDeclaration",
+      "opcode" : 19,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" }
+      ]
+    },
+    {
+      "opname" : "DebugFunction",
+      "opcode" : 20,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Linkage Name'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "LiteralInteger", "name" : "'Scope Line'" },
+        { "kind" : "IdRef", "name" : "'Function'" },
+        { "kind" : "IdRef", "name" : "'Declaration'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlock",
+      "opcode" : 21,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "IdRef", "name" : "'Name'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLexicalBlockDiscriminator",
+      "opcode" : 22,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Discriminator'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugScope",
+      "opcode" : 23,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined At'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugNoScope",
+      "opcode" : 24
+    },
+    {
+      "opname" : "DebugInlinedAt",
+      "opcode" : 25,
+      "operands" : [
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Scope'" },
+        { "kind" : "IdRef", "name" : "'Inlined'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugLocalVariable",
+      "opcode" : 26,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Type'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "DebugInfoFlags", "name" : "'Flags'" },
+        { "kind" : "LiteralInteger", "name" : "'Arg Number'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugInlinedVariable",
+      "opcode" : 27,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Inlined'" }
+      ]
+    },
+    {
+      "opname" : "DebugDeclare",
+      "opcode" : 28,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Local Variable'" },
+        { "kind" : "IdRef", "name" : "'Variable'" },
+        { "kind" : "IdRef", "name" : "'Expression'" }
+      ]
+    },
+    {
+      "opname" : "DebugValue",
+      "opcode" : 29,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Local Variable'" },
+        { "kind" : "IdRef", "name" : "'Value'" },
+        { "kind" : "IdRef", "name" : "'Expression'" },
+        { "kind" : "IdRef", "name" : "'Indexes'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugOperation",
+      "opcode" : 30,
+      "operands" : [
+        { "kind" : "DebugOperation", "name" : "'OpCode'" },
+        { "kind" : "LiteralInteger", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugExpression",
+      "opcode" : 31,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Operands ...'", "quantifier" : "*" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroDef",
+      "opcode" : 32,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Value'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugMacroUndef",
+      "opcode" : 33,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'Macro'" }
+      ]
+    },
+    {
+      "opname" : "DebugImportedEntity",
+      "opcode" : 34,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "DebugImportedEntity", "name" : "'Tag'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Entity'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "LiteralInteger", "name" : "'Column'" },
+        { "kind" : "IdRef", "name" : "'Parent'" }
+      ]
+    },
+    {
+      "opname" : "DebugSource",
+      "opcode" : 35,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'File'" },
+        { "kind" : "IdRef", "name" : "'Text'", "quantifier" : "?" }
+      ]
+    },
+    {
+      "opname" : "DebugModuleINTEL",
+      "opcode" : 36,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'Name'" },
+        { "kind" : "IdRef", "name" : "'Source'" },
+        { "kind" : "IdRef", "name" : "'Parent'" },
+        { "kind" : "LiteralInteger", "name" : "'Line'" },
+        { "kind" : "IdRef", "name" : "'ConfigurationMacros'" },
+        { "kind" : "IdRef", "name" : "'IncludePath'" },
+        { "kind" : "IdRef", "name" : "'APINotesFile'" },
+        { "kind" : "LiteralInteger", "name" : "'IsDeclaration'" }
+      ],
+      "capability" : "DebugInfoModuleINTEL"
+    }
+  ],
+  "operand_kinds" : [
+    {
+      "category" : "BitEnum",
+      "kind" : "DebugInfoFlags",
+      "enumerants" : [
+        {
+          "enumerant" : "None",
+          "value" : "0x0000"
+        },
+        {
+          "enumerant" : "FlagIsProtected",
+          "value" : "0x01"
+        },
+        {
+          "enumerant" : "FlagIsPrivate",
+          "value" : "0x02"
+        },
+        {
+          "enumerant" : "FlagIsPublic",
+          "value" : "0x03"
+        },
+        {
+          "enumerant" : "FlagIsLocal",
+          "value" : "0x04"
+        },
+        {
+          "enumerant" : "FlagIsDefinition",
+          "value" : "0x08"
+        },
+        {
+          "enumerant" : "FlagFwdDecl",
+          "value" : "0x10"
+        },
+        {
+          "enumerant" : "FlagArtificial",
+          "value" : "0x20"
+        },
+        {
+          "enumerant" : "FlagExplicit",
+          "value" : "0x40"
+        },
+        {
+          "enumerant" : "FlagPrototyped",
+          "value" : "0x80"
+        },
+        {
+          "enumerant" : "FlagObjectPointer",
+          "value" : "0x100"
+        },
+        {
+          "enumerant" : "FlagStaticMember",
+          "value" : "0x200"
+        },
+        {
+          "enumerant" : "FlagIndirectVariable",
+          "value" : "0x400"
+        },
+        {
+          "enumerant" : "FlagLValueReference",
+          "value" : "0x800"
+        },
+        {
+          "enumerant" : "FlagRValueReference",
+          "value" : "0x1000"
+        },
+        {
+          "enumerant" : "FlagIsOptimized",
+          "value" : "0x2000"
+        },
+        {
+          "enumerant" : "FlagIsEnumClass",
+          "value" : "0x4000"
+        },
+        {
+          "enumerant" : "FlagTypePassByValue",
+          "value" : "0x8000"
+        },
+        {
+          "enumerant" : "FlagTypePassByReference",
+          "value" : "0x10000"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugBaseTypeAttributeEncoding",
+      "enumerants" : [
+        {
+          "enumerant" : "Unspecified",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Address",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Boolean",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "Float",
+          "value" : "3"
+        },
+        {
+          "enumerant" : "Signed",
+          "value" : "4"
+        },
+        {
+          "enumerant" : "SignedChar",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "Unsigned",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "UnsignedChar",
+          "value" : "7"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugCompositeType",
+      "enumerants" : [
+        {
+          "enumerant" : "Class",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Structure",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Union",
+          "value" : "2"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugTypeQualifier",
+      "enumerants" : [
+        {
+          "enumerant" : "ConstType",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "VolatileType",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "RestrictType",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "AtomicType",
+          "value" : "3"
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugOperation",
+      "enumerants" : [
+        {
+          "enumerant" : "Deref",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "Plus",
+          "value" : "1"
+        },
+        {
+          "enumerant" : "Minus",
+          "value" : "2"
+        },
+        {
+          "enumerant" : "PlusUconst",
+          "value" : "3",
+          "parameters" : [
+             { "kind" : "LiteralInteger" }
+          ]
+        },
+        {
+          "enumerant" : "BitPiece",
+          "value" : "4",
+          "parameters" : [
+             { "kind" : "LiteralInteger" },
+             { "kind" : "LiteralInteger" }
+          ]
+        },
+        {
+          "enumerant" : "Swap",
+          "value" : "5"
+        },
+        {
+          "enumerant" : "Xderef",
+          "value" : "6"
+        },
+        {
+          "enumerant" : "StackValue",
+          "value" : "7"
+        },
+        {
+          "enumerant" : "Constu",
+          "value" : "8",
+          "parameters" : [
+             { "kind" : "LiteralInteger" }
+          ]
+        },
+        {
+          "enumerant" : "Fragment",
+          "value" : "9",
+          "parameters" : [
+             { "kind" : "LiteralInteger" },
+             { "kind" : "LiteralInteger" }
+          ]
+        }
+      ]
+    },
+    {
+      "category" : "ValueEnum",
+      "kind" : "DebugImportedEntity",
+      "enumerants" : [
+        {
+          "enumerant" : "ImportedModule",
+          "value" : "0"
+        },
+        {
+          "enumerant" : "ImportedDeclaration",
+          "value" : "1"
+	}
+      ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.spv-amd-gcn-shader.grammar.json

@@ -0,0 +1,26 @@
+{
+  "revision" : 2,
+  "instructions" : [
+    {
+      "opname" : "CubeFaceIndexAMD",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'P'" }
+      ],
+      "extensions" : [ "SPV_AMD_gcn_shader" ]
+    },
+    {
+      "opname" : "CubeFaceCoordAMD",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'P'" }
+      ],
+      "extensions" : [ "SPV_AMD_gcn_shader" ]
+    },
+    {
+      "opname" : "TimeAMD",
+      "opcode" : 3,
+      "extensions" : [ "SPV_AMD_gcn_shader" ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.spv-amd-shader-ballot.grammar.json

@@ -0,0 +1,41 @@
+{
+  "revision" : 5,
+  "instructions" : [
+    {
+      "opname" : "SwizzleInvocationsAMD",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'data'" },
+        { "kind" : "IdRef", "name" : "'offset'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_ballot" ]
+    },
+    {
+      "opname" : "SwizzleInvocationsMaskedAMD",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'data'" },
+        { "kind" : "IdRef", "name" : "'mask'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_ballot" ]
+    },
+    {
+      "opname" : "WriteInvocationAMD",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'inputValue'" },
+        { "kind" : "IdRef", "name" : "'writeValue'" },
+        { "kind" : "IdRef", "name" : "'invocationIndex'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_ballot" ]
+    },
+    {
+      "opname" : "MbcntAMD",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'mask'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_ballot" ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.spv-amd-shader-explicit-vertex-parameter.grammar.json

@@ -0,0 +1,14 @@
+{
+  "revision" : 4,
+  "instructions" : [
+    {
+      "opname" : "InterpolateAtVertexAMD",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'interpolant'" },
+        { "kind" : "IdRef", "name" : "'vertexIdx'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/include/spirv/unified1/extinst.spv-amd-shader-trinary-minmax.grammar.json

@@ -0,0 +1,95 @@
+{
+  "revision" : 4,
+  "instructions" : [
+    {
+      "opname" : "FMin3AMD",
+      "opcode" : 1,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "UMin3AMD",
+      "opcode" : 2,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "SMin3AMD",
+      "opcode" : 3,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "FMax3AMD",
+      "opcode" : 4,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "UMax3AMD",
+      "opcode" : 5,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "SMax3AMD",
+      "opcode" : 6,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "FMid3AMD",
+      "opcode" : 7,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "UMid3AMD",
+      "opcode" : 8,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    },
+    {
+      "opname" : "SMid3AMD",
+      "opcode" : 9,
+      "operands" : [
+        { "kind" : "IdRef", "name" : "'x'" },
+        { "kind" : "IdRef", "name" : "'y'" },
+        { "kind" : "IdRef", "name" : "'z'" }
+      ],
+      "extensions" : [ "SPV_AMD_shader_trinary_minmax" ]
+    }
+  ]
+}

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tests/CMakeLists.txt

@@ -0,0 +1,47 @@
+# Copyright (c) 2015-2024 The Khronos Group Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and/or associated documentation files (the
+# "Materials"), to deal in the Materials without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Materials, and to
+# permit persons to whom the Materials are furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Materials.
+#
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+# KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+# SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+#    https://www.khronos.org/registry/
+#
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+add_library(spirv_headers_simple_test STATIC)
+
+target_sources(spirv_headers_simple_test PRIVATE
+    example.cpp
+)
+
+target_link_libraries(spirv_headers_simple_test PRIVATE
+    SPIRV-Headers::SPIRV-Headers
+)
+
+if (NOT TARGET SPIRV-Headers)
+    message(FATAL_ERROR "SPIRV-Headers target not defined!")
+endif()
+
+if (NOT PROJECT_NAME STREQUAL "SPIRV-Headers")
+    message(FATAL_ERROR "PROJECT_NAME changed!") # Needed for backcompat with SPIRV-Tools.
+endif()
+
+if (NOT DEFINED SPIRV-Headers_SOURCE_DIR)
+    message(FATAL_ERROR "SPIRV-Headers_SOURCE_DIR not defined!") # Needed for backcompat with SPIRV-Tools.
+endif()

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tests/example.cpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2016-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include <spirv/unified1/GLSL.std.450.h>
+#include <spirv/unified1/OpenCL.std.h>
+#include <spirv/unified1/spirv.hpp>
+
+namespace {
+
+const GLSLstd450 kSin = GLSLstd450Sin;
+const OpenCLLIB::Entrypoints kNative_cos = OpenCLLIB::Native_cos;
+const spv::Op kNop = spv::OpNop;
+
+}  // anonymous namespace

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tests/find_package/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(TEST_FIND_PACKAGE LANGUAGES CXX)
+
+add_library(find_package_example STATIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../example.cpp
+)
+
+find_package(SPIRV-Headers REQUIRED CONFIG)
+
+if (NOT TARGET SPIRV-Headers::SPIRV-Headers)
+    message(FATAL_ERROR "SPIRV-Headers::SPIRV-Headers target not defined")
+endif()
+
+target_link_libraries(find_package_example PRIVATE
+    SPIRV-Headers::SPIRV-Headers
+)
+
+if (NOT DEFINED SPIRV-Headers_VERSION)
+    message(FATAL_ERROR "SPIRV-Headers_VERSION not provided!")
+endif()
+
+message(STATUS "SPIRV-Headers_VERSION = ${SPIRV-Headers_VERSION}")

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tests/pkg_config/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.14)
+
+project(TEST_PKGCONFIG LANGUAGES CXX)
+
+add_library(pkgconfig_example STATIC)
+
+target_sources(pkgconfig_example PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../example.cpp
+)
+
+find_package(PkgConfig REQUIRED)
+
+pkg_check_modules(SPIRV_HEADERS REQUIRED IMPORTED_TARGET SPIRV-Headers)
+
+target_link_libraries(pkgconfig_example PRIVATE
+    PkgConfig::SPIRV_HEADERS
+)
+
+if (NOT DEFINED SPIRV_HEADERS_VERSION)
+    message(FATAL_ERROR "SPIRV_HEADERS_VERSION not defined!")
+endif()
+
+message(STATUS "PkgConfig::SPIRV_HEADERS version = ${SPIRV_HEADERS_VERSION}")

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tools/buildHeaders/CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.0)
+
+set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "prefix" FORCE)
+
+project(buildSpvHeaders)
+
+set(SOURCES
+    main.cpp
+    jsonToSpirv.cpp
+    header.cpp
+    jsoncpp/dist/jsoncpp.cpp)
+
+set(HEADERS
+    jsonToSpirv.h
+    header.h
+    jsoncpp/dist/json/json.h)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    add_definitions(-std=c++11)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_definitions(-std=c++11)
+endif()
+
+add_executable(buildSpvHeaders ${SOURCES} ${HEADERS})
+
+install(TARGETS buildSpvHeaders RUNTIME DESTINATION bin)

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tools/buildHeaders/bin/generate_language_headers.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# Copyright (c) 2017-2024 Google LLC
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and/or associated documentation files (the
+# "Materials"), to deal in the Materials without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Materials, and to
+# permit persons to whom the Materials are furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Materials.
+#
+# MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+# KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+# SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+#    https://www.khronos.org/registry/
+#
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+"""Generates a C language headers from a SPIR-V JSON grammar file"""
+
+import errno
+import json
+import os.path
+import re
+
+DEFAULT_COPYRIGHT="""Copyright (c) 2020-2024 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+   https://www.khronos.org/registry/
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+""".split('\n')
+
+def make_path_to_file(f):
+    """Makes all ancestor directories to the given file, if they
+    don't yet exist.
+
+    Arguments:
+        f: The file whose ancestor directories are to be created.
+    """
+    dir = os.path.dirname(os.path.abspath(f))
+    try:
+        os.makedirs(dir)
+    except OSError as e:
+        if e.errno == errno.EEXIST and os.path.isdir(dir):
+            pass
+        else:
+            raise
+
+class ExtInstGrammar:
+    """The grammar for an extended instruction set"""
+
+    def __init__(self, name, copyright, instructions, operand_kinds, version = None, revision = None):
+       self.name = name
+       self.copyright = copyright
+       self.instructions = instructions
+       self.operand_kinds = operand_kinds
+       self.version = version
+       self.revision = revision
+
+
+class LangGenerator:
+    """A language-specific generator"""
+
+    def __init__(self):
+        self.upper_case_initial = re.compile('^[A-Z]')
+        pass
+
+    def comment_prefix(self):
+        return ""
+
+    def namespace_prefix(self):
+        return ""
+
+    def uses_guards(self):
+        return False
+
+    def cpp_guard_preamble(self):
+        return ""
+
+    def cpp_guard_postamble(self):
+        return ""
+
+    def enum_value(self, prefix, name, value):
+        if self.upper_case_initial.match(name):
+            use_name = name
+        else:
+            use_name = '_' + name
+
+        return "    {}{} = {},".format(prefix, use_name, value)
+
+    def generate(self, grammar):
+        """Returns a string that is the language-specific header for the given grammar"""
+
+        parts = []
+        if grammar.copyright:
+            parts.extend(["{}{}".format(self.comment_prefix(), f) for f in grammar.copyright])
+        parts.append('')
+
+        guard = 'SPIRV_UNIFIED1_{}_H_'.format(grammar.name)
+        if self.uses_guards:
+            parts.append('#ifndef {}'.format(guard))
+            parts.append('#define {}'.format(guard))
+        parts.append('')
+
+        parts.append(self.cpp_guard_preamble())
+
+        if grammar.version:
+            parts.append(self.const_definition(grammar.name, 'Version', grammar.version))
+
+        if grammar.revision is not None:
+            parts.append(self.const_definition(grammar.name, 'Revision', grammar.revision))
+
+        parts.append('')
+
+        if grammar.instructions:
+            parts.append(self.enum_prefix(grammar.name, 'Instructions'))
+            for inst in grammar.instructions:
+                parts.append(self.enum_value(grammar.name, inst['opname'], inst['opcode']))
+            parts.append(self.enum_end(grammar.name, 'Instructions'))
+            parts.append('')
+
+        if grammar.operand_kinds:
+            for kind in grammar.operand_kinds:
+                parts.append(self.enum_prefix(grammar.name, kind['kind']))
+                for e in kind['enumerants']:
+                    parts.append(self.enum_value(grammar.name, e['enumerant'], e['value']))
+                parts.append(self.enum_end(grammar.name, kind['kind']))
+            parts.append('')
+
+        parts.append(self.cpp_guard_postamble())
+
+        if self.uses_guards:
+            parts.append('#endif // {}'.format(guard))
+
+        # Ensre the file ends in an end of line
+        parts.append('')
+
+        return '\n'.join(parts)
+
+
+class CLikeGenerator(LangGenerator):
+    def uses_guards(self):
+        return True
+
+    def comment_prefix(self):
+        return "// "
+
+    def const_definition(self, prefix, var, value):
+        # Use an anonymous enum.  Don't use a static const int variable because
+        # that can bloat binary size.
+        return 'enum {0}{1}{2}{3} = {4},{1}{2}{3}_BitWidthPadding = 0x7fffffff{5};'.format(
+               '{', '\n    ', prefix, var, value, '\n}')
+
+    def enum_prefix(self, prefix, name):
+        return 'enum {}{} {}'.format(prefix, name, '{')
+
+    def enum_end(self, prefix, enum):
+        return '    {}{}Max = 0x7fffffff\n{};\n'.format(prefix, enum, '}')
+
+    def cpp_guard_preamble(self):
+        return '#ifdef __cplusplus\nextern "C" {\n#endif\n'
+
+    def cpp_guard_postamble(self):
+        return '#ifdef __cplusplus\n}\n#endif\n'
+
+
+class CGenerator(CLikeGenerator):
+    pass
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Generate language headers from a JSON grammar')
+
+    parser.add_argument('--extinst-name',
+                        type=str, required=True,
+                        help='The name to use in tokens')
+    parser.add_argument('--extinst-grammar', metavar='<path>',
+                        type=str, required=True,
+                        help='input JSON grammar file for extended instruction set')
+    parser.add_argument('--extinst-output-base', metavar='<path>',
+                        type=str, required=True,
+                        help='Basename of the language-specific output file.')
+    args = parser.parse_args()
+
+    with open(args.extinst_grammar) as json_file:
+        grammar_json = json.loads(json_file.read())
+        if 'copyright' in grammar_json:
+          copyright = grammar_json['copyright']
+        else:
+          copyright = DEFAULT_COPYRIGHT
+        if 'version' in grammar_json:
+          version = grammar_json['version']
+        else:
+          version = 0
+        if 'operand_kinds' in grammar_json:
+          operand_kinds = grammar_json['operand_kinds']
+        else:
+          operand_kinds = []
+
+        grammar = ExtInstGrammar(name = args.extinst_name,
+                                 copyright = copyright,
+                                 instructions = grammar_json['instructions'],
+                                 operand_kinds = operand_kinds,
+                                 version = version,
+                                 revision = grammar_json['revision'])
+        make_path_to_file(args.extinst_output_base)
+        with open(args.extinst_output_base + '.h', 'w') as f:
+            f.write(CGenerator().generate(grammar))
+
+
+if __name__ == '__main__':
+    main()

dependencies/SPIRV-Headers-vulkan-sdk-1.3.296.0/tools/buildHeaders/bin/makeExtinstHeaders.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""Generate C headers for certain extended instruction sets"""
+
+import subprocess
+import os
+
+# Assume we are running from the tools/buildHeaders directory
+os.chdir('../../include/spirv/unified1')
+
+def mk_extinst(name, grammar_file):
+  """Generate one C header from a grammar"""
+  script = '../../../tools/buildHeaders/bin/generate_language_headers.py'
+  subprocess.check_call(['python3',
+                         script,
+                         '--extinst-name=' + name,
+                         '--extinst-grammar=' + grammar_file,
+                         '--extinst-output-base=' + name])
+  subprocess.check_call(['dos2unix', name + '.h'])
+
+
+mk_extinst('DebugInfo', 'extinst.debuginfo.grammar.json')
+mk_extinst('OpenCLDebugInfo100', 'extinst.opencl.debuginfo.100.grammar.json')
+mk_extinst('AMD_gcn_shader', 'extinst.spv-amd-gcn-shader.grammar.json')
+mk_extinst('AMD_shader_ballot', 'extinst.spv-amd-shader-ballot.grammar.json')
+mk_extinst('AMD_shader_explicit_vertex_parameter', 'extinst.spv-amd-shader-explicit-vertex-parameter.grammar.json')
+mk_extinst('AMD_shader_trinary_minmax', 'extinst.spv-amd-shader-trinary-minmax.grammar.json')
+mk_extinst('NonSemanticDebugPrintf', 'extinst.nonsemantic.debugprintf.grammar.json')
+mk_extinst('NonSemanticClspvReflection', 'extinst.nonsemantic.clspvreflection.grammar.json')
+mk_extinst('NonSemanticDebugBreak', 'extinst.nonsemantic.debugbreak.grammar.json')
+mk_extinst('NonSemanticVkspReflection', 'extinst.nonsemantic.vkspreflection.grammar.json')