Vulkan API (GetProcAddr only)
This patch contains an empty Vulkan shell with only GetProcAddr implemented
Initial version of the VulkanAPI, empty and unimplemented.
Successfully builds vk_swiftshader.dll for all platforms/configuration in Visual Studio.
To test using dEQP:
- Edit environment variables
- Define VK_ICD_FILENAMES to <SwiftShader's source directory>\src\Vulkan\vk_swiftshader_icd.json
- If the location of vk_swiftshader.dll you're using is different than the one specified in
src\Vulkan\vk_swiftshader_icd.json, modify it to point to the vk_swiftshader.dll file you want to use
Bug b/116336664
Change-Id: I560b53c3e4340b9c5ccd244a6693ff2f9f994a6f
Reviewed-on: https://swiftshader-review.googlesource.com/20788
Reviewed-by: Alexis Hétu <sugoi@google.com>
Tested-by: Alexis Hétu <sugoi@google.com>
diff --git a/src/Vulkan/VkDebug.cpp b/src/Vulkan/VkDebug.cpp
new file mode 100644
index 0000000..b09abb6
--- /dev/null
+++ b/src/Vulkan/VkDebug.cpp
@@ -0,0 +1,38 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "vkdebug.hpp"
+
+#include <stdarg.h>
+
+namespace vk
+{
+void trace(const char *format, ...)
+{
+ if(false)
+ {
+ FILE *file = fopen("debug.txt", "a");
+
+ if(file)
+ {
+ va_list vararg;
+ va_start(vararg, format);
+ vfprintf(file, format, vararg);
+ va_end(vararg);
+
+ fclose(file);
+ }
+ }
+}
+}
\ No newline at end of file
diff --git a/src/Vulkan/VkDebug.hpp b/src/Vulkan/VkDebug.hpp
new file mode 100644
index 0000000..c436b3e
--- /dev/null
+++ b/src/Vulkan/VkDebug.hpp
@@ -0,0 +1,96 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// debug.h: Debugging utilities.
+
+#ifndef VK_DEBUG_H_
+#define VK_DEBUG_H_
+
+#include <assert.h>
+#include <stdio.h>
+
+#if !defined(TRACE_OUTPUT_FILE)
+#define TRACE_OUTPUT_FILE "debug.txt"
+#endif
+
+namespace vk
+{
+// Outputs text to the debugging log
+void trace(const char *format, ...);
+}
+
+// A macro to output a trace of a function call and its arguments to the debugging log
+#if defined(SWIFTSHADER_DISABLE_TRACE)
+#define TRACE(message, ...) (void(0))
+#else
+#define TRACE(message, ...) vk::trace("trace: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#endif
+
+// A macro to output a function call and its arguments to the debugging log, to denote an item in need of fixing.
+#if defined(SWIFTSHADER_DISABLE_TRACE)
+#define FIXME(message, ...) (void(0))
+#else
+#define FIXME(message, ...) do {vk::trace("fixme: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); assert(false);} while(false)
+#endif
+
+// A macro to output a function call and its arguments to the debugging log, in case of error.
+#if defined(SWIFTSHADER_DISABLE_TRACE)
+#define ERR(message, ...) (void(0))
+#else
+#define ERR(message, ...) do {vk::trace("err: %s(%d): " message "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); assert(false);} while(false)
+#endif
+
+// A macro asserting a condition and outputting failures to the debug log
+#undef ASSERT
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define ASSERT(expression) do { \
+ if(!(expression)) { \
+ ERR("\t! Assert failed in %s(%d): "#expression"\n", __FUNCTION__, __LINE__); \
+ assert(expression); \
+ } } while(0)
+#else
+#define ASSERT(expression) (void(0))
+#endif
+
+// A macro to indicate unimplemented functionality
+#undef UNIMPLEMENTED
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define UNIMPLEMENTED() do { \
+ FIXME("\t! Unimplemented: %s(%d)\n", __FUNCTION__, __LINE__); \
+ assert(false); \
+ } while(0)
+#else
+ #define UNIMPLEMENTED() FIXME("\t! Unimplemented: %s(%d)\n", __FUNCTION__, __LINE__)
+#endif
+
+// A macro for code which is not expected to be reached under valid assumptions
+#undef UNREACHABLE
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define UNREACHABLE(value) do { \
+ ERR("\t! Unreachable case reached: %s(%d). %s: %d\n", __FUNCTION__, __LINE__, #value, value); \
+ assert(false); \
+ } while(0)
+#else
+ #define UNREACHABLE(value) ERR("\t! Unreachable reached: %s(%d). %s: %d\n", __FUNCTION__, __LINE__, #value, value)
+#endif
+
+// A macro asserting a condition and outputting failures to the debug log, or return when in release mode.
+#undef ASSERT_OR_RETURN
+#define ASSERT_OR_RETURN(expression) do { \
+ if(!(expression)) { \
+ ASSERT(expression); \
+ return; \
+ } } while(0)
+
+#endif // VK_DEBUG_H_
diff --git a/src/Vulkan/VkGetProcAddress.cpp b/src/Vulkan/VkGetProcAddress.cpp
new file mode 100644
index 0000000..ea5f8c8
--- /dev/null
+++ b/src/Vulkan/VkGetProcAddress.cpp
@@ -0,0 +1,235 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VkGetProcAddress.h"
+
+#include <unordered_map>
+
+namespace vk
+{
+#define MAKE_VULKAN_ENTRY(aFunction) { #aFunction, reinterpret_cast<PFN_vkVoidFunction>(aFunction) }
+ static const std::unordered_map <std::string, PFN_vkVoidFunction> func_ptrs =
+ {
+ MAKE_VULKAN_ENTRY(vkCreateInstance),
+ MAKE_VULKAN_ENTRY(vkDestroyInstance),
+ MAKE_VULKAN_ENTRY(vkEnumeratePhysicalDevices),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFeatures),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFormatProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceImageFormatProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceMemoryProperties),
+ MAKE_VULKAN_ENTRY(vkGetInstanceProcAddr),
+ MAKE_VULKAN_ENTRY(vkGetDeviceProcAddr),
+ MAKE_VULKAN_ENTRY(vkCreateDevice),
+ MAKE_VULKAN_ENTRY(vkDestroyDevice),
+ MAKE_VULKAN_ENTRY(vkEnumerateInstanceExtensionProperties),
+ MAKE_VULKAN_ENTRY(vkEnumerateDeviceExtensionProperties),
+ MAKE_VULKAN_ENTRY(vkEnumerateInstanceLayerProperties),
+ MAKE_VULKAN_ENTRY(vkEnumerateDeviceLayerProperties),
+ MAKE_VULKAN_ENTRY(vkGetDeviceQueue),
+ MAKE_VULKAN_ENTRY(vkQueueSubmit),
+ MAKE_VULKAN_ENTRY(vkQueueWaitIdle),
+ MAKE_VULKAN_ENTRY(vkDeviceWaitIdle),
+ MAKE_VULKAN_ENTRY(vkAllocateMemory),
+ MAKE_VULKAN_ENTRY(vkFreeMemory),
+ MAKE_VULKAN_ENTRY(vkMapMemory),
+ MAKE_VULKAN_ENTRY(vkUnmapMemory),
+ MAKE_VULKAN_ENTRY(vkFlushMappedMemoryRanges),
+ MAKE_VULKAN_ENTRY(vkInvalidateMappedMemoryRanges),
+ MAKE_VULKAN_ENTRY(vkGetDeviceMemoryCommitment),
+ MAKE_VULKAN_ENTRY(vkBindBufferMemory),
+ MAKE_VULKAN_ENTRY(vkBindImageMemory),
+ MAKE_VULKAN_ENTRY(vkGetBufferMemoryRequirements),
+ MAKE_VULKAN_ENTRY(vkGetImageMemoryRequirements),
+ MAKE_VULKAN_ENTRY(vkGetImageSparseMemoryRequirements),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties),
+ MAKE_VULKAN_ENTRY(vkQueueBindSparse),
+ MAKE_VULKAN_ENTRY(vkCreateFence),
+ MAKE_VULKAN_ENTRY(vkDestroyFence),
+ MAKE_VULKAN_ENTRY(vkResetFences),
+ MAKE_VULKAN_ENTRY(vkGetFenceStatus),
+ MAKE_VULKAN_ENTRY(vkWaitForFences),
+ MAKE_VULKAN_ENTRY(vkCreateSemaphore),
+ MAKE_VULKAN_ENTRY(vkDestroySemaphore),
+ MAKE_VULKAN_ENTRY(vkCreateEvent),
+ MAKE_VULKAN_ENTRY(vkDestroyEvent),
+ MAKE_VULKAN_ENTRY(vkGetEventStatus),
+ MAKE_VULKAN_ENTRY(vkSetEvent),
+ MAKE_VULKAN_ENTRY(vkResetEvent),
+ MAKE_VULKAN_ENTRY(vkCreateQueryPool),
+ MAKE_VULKAN_ENTRY(vkDestroyQueryPool),
+ MAKE_VULKAN_ENTRY(vkGetQueryPoolResults),
+ MAKE_VULKAN_ENTRY(vkCreateBuffer),
+ MAKE_VULKAN_ENTRY(vkDestroyBuffer),
+ MAKE_VULKAN_ENTRY(vkCreateBufferView),
+ MAKE_VULKAN_ENTRY(vkDestroyBufferView),
+ MAKE_VULKAN_ENTRY(vkCreateImage),
+ MAKE_VULKAN_ENTRY(vkDestroyImage),
+ MAKE_VULKAN_ENTRY(vkGetImageSubresourceLayout),
+ MAKE_VULKAN_ENTRY(vkCreateImageView),
+ MAKE_VULKAN_ENTRY(vkDestroyImageView),
+ MAKE_VULKAN_ENTRY(vkCreateShaderModule),
+ MAKE_VULKAN_ENTRY(vkDestroyShaderModule),
+ MAKE_VULKAN_ENTRY(vkCreatePipelineCache),
+ MAKE_VULKAN_ENTRY(vkDestroyPipelineCache),
+ MAKE_VULKAN_ENTRY(vkGetPipelineCacheData),
+ MAKE_VULKAN_ENTRY(vkMergePipelineCaches),
+ MAKE_VULKAN_ENTRY(vkCreateGraphicsPipelines),
+ MAKE_VULKAN_ENTRY(vkCreateComputePipelines),
+ MAKE_VULKAN_ENTRY(vkDestroyPipeline),
+ MAKE_VULKAN_ENTRY(vkCreatePipelineLayout),
+ MAKE_VULKAN_ENTRY(vkDestroyPipelineLayout),
+ MAKE_VULKAN_ENTRY(vkCreateSampler),
+ MAKE_VULKAN_ENTRY(vkDestroySampler),
+ MAKE_VULKAN_ENTRY(vkCreateDescriptorSetLayout),
+ MAKE_VULKAN_ENTRY(vkDestroyDescriptorSetLayout),
+ MAKE_VULKAN_ENTRY(vkCreateDescriptorPool),
+ MAKE_VULKAN_ENTRY(vkDestroyDescriptorPool),
+ MAKE_VULKAN_ENTRY(vkResetDescriptorPool),
+ MAKE_VULKAN_ENTRY(vkAllocateDescriptorSets),
+ MAKE_VULKAN_ENTRY(vkFreeDescriptorSets),
+ MAKE_VULKAN_ENTRY(vkUpdateDescriptorSets),
+ MAKE_VULKAN_ENTRY(vkCreateFramebuffer),
+ MAKE_VULKAN_ENTRY(vkDestroyFramebuffer),
+ MAKE_VULKAN_ENTRY(vkCreateRenderPass),
+ MAKE_VULKAN_ENTRY(vkDestroyRenderPass),
+ MAKE_VULKAN_ENTRY(vkGetRenderAreaGranularity),
+ MAKE_VULKAN_ENTRY(vkCreateCommandPool),
+ MAKE_VULKAN_ENTRY(vkDestroyCommandPool),
+ MAKE_VULKAN_ENTRY(vkResetCommandPool),
+ MAKE_VULKAN_ENTRY(vkAllocateCommandBuffers),
+ MAKE_VULKAN_ENTRY(vkFreeCommandBuffers),
+ MAKE_VULKAN_ENTRY(vkBeginCommandBuffer),
+ MAKE_VULKAN_ENTRY(vkEndCommandBuffer),
+ MAKE_VULKAN_ENTRY(vkResetCommandBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdBindPipeline),
+ MAKE_VULKAN_ENTRY(vkCmdSetViewport),
+ MAKE_VULKAN_ENTRY(vkCmdSetScissor),
+ MAKE_VULKAN_ENTRY(vkCmdSetLineWidth),
+ MAKE_VULKAN_ENTRY(vkCmdSetDepthBias),
+ MAKE_VULKAN_ENTRY(vkCmdSetBlendConstants),
+ MAKE_VULKAN_ENTRY(vkCmdSetDepthBounds),
+ MAKE_VULKAN_ENTRY(vkCmdSetStencilCompareMask),
+ MAKE_VULKAN_ENTRY(vkCmdSetStencilWriteMask),
+ MAKE_VULKAN_ENTRY(vkCmdSetStencilReference),
+ MAKE_VULKAN_ENTRY(vkCmdBindDescriptorSets),
+ MAKE_VULKAN_ENTRY(vkCmdBindIndexBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdBindVertexBuffers),
+ MAKE_VULKAN_ENTRY(vkCmdDraw),
+ MAKE_VULKAN_ENTRY(vkCmdDrawIndexed),
+ MAKE_VULKAN_ENTRY(vkCmdDrawIndirect),
+ MAKE_VULKAN_ENTRY(vkCmdDrawIndexedIndirect),
+ MAKE_VULKAN_ENTRY(vkCmdDispatch),
+ MAKE_VULKAN_ENTRY(vkCmdDispatchIndirect),
+ MAKE_VULKAN_ENTRY(vkCmdCopyBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdCopyImage),
+ MAKE_VULKAN_ENTRY(vkCmdBlitImage),
+ MAKE_VULKAN_ENTRY(vkCmdCopyBufferToImage),
+ MAKE_VULKAN_ENTRY(vkCmdCopyImageToBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdUpdateBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdFillBuffer),
+ MAKE_VULKAN_ENTRY(vkCmdClearColorImage),
+ MAKE_VULKAN_ENTRY(vkCmdClearDepthStencilImage),
+ MAKE_VULKAN_ENTRY(vkCmdClearAttachments),
+ MAKE_VULKAN_ENTRY(vkCmdResolveImage),
+ MAKE_VULKAN_ENTRY(vkCmdSetEvent),
+ MAKE_VULKAN_ENTRY(vkCmdResetEvent),
+ MAKE_VULKAN_ENTRY(vkCmdWaitEvents),
+ MAKE_VULKAN_ENTRY(vkCmdPipelineBarrier),
+ MAKE_VULKAN_ENTRY(vkCmdBeginQuery),
+ MAKE_VULKAN_ENTRY(vkCmdEndQuery),
+ MAKE_VULKAN_ENTRY(vkCmdResetQueryPool),
+ MAKE_VULKAN_ENTRY(vkCmdWriteTimestamp),
+ MAKE_VULKAN_ENTRY(vkCmdCopyQueryPoolResults),
+ MAKE_VULKAN_ENTRY(vkCmdPushConstants),
+ MAKE_VULKAN_ENTRY(vkCmdBeginRenderPass),
+ MAKE_VULKAN_ENTRY(vkCmdNextSubpass),
+ MAKE_VULKAN_ENTRY(vkCmdEndRenderPass),
+ MAKE_VULKAN_ENTRY(vkCmdExecuteCommands),
+ MAKE_VULKAN_ENTRY(vkEnumerateInstanceVersion),
+ MAKE_VULKAN_ENTRY(vkBindBufferMemory2),
+ MAKE_VULKAN_ENTRY(vkBindImageMemory2),
+ MAKE_VULKAN_ENTRY(vkGetDeviceGroupPeerMemoryFeatures),
+ MAKE_VULKAN_ENTRY(vkCmdSetDeviceMask),
+ MAKE_VULKAN_ENTRY(vkCmdDispatchBase),
+ MAKE_VULKAN_ENTRY(vkEnumeratePhysicalDeviceGroups),
+ MAKE_VULKAN_ENTRY(vkGetImageMemoryRequirements2),
+ MAKE_VULKAN_ENTRY(vkGetBufferMemoryRequirements2),
+ MAKE_VULKAN_ENTRY(vkGetImageSparseMemoryRequirements2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFeatures2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceProperties2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFormatProperties2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceImageFormatProperties2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceMemoryProperties2),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2),
+ MAKE_VULKAN_ENTRY(vkTrimCommandPool),
+ MAKE_VULKAN_ENTRY(vkGetDeviceQueue2),
+ MAKE_VULKAN_ENTRY(vkCreateSamplerYcbcrConversion),
+ MAKE_VULKAN_ENTRY(vkDestroySamplerYcbcrConversion),
+ MAKE_VULKAN_ENTRY(vkCreateDescriptorUpdateTemplate),
+ MAKE_VULKAN_ENTRY(vkDestroyDescriptorUpdateTemplate),
+ MAKE_VULKAN_ENTRY(vkUpdateDescriptorSetWithTemplate),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalBufferProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalFenceProperties),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties),
+ MAKE_VULKAN_ENTRY(vkGetDescriptorSetLayoutSupport),
+ // VK_KHR_bind_memory2
+ MAKE_VULKAN_ENTRY(vkBindBufferMemory2KHR),
+ MAKE_VULKAN_ENTRY(vkBindImageMemory2KHR),
+ // VK_KHR_descriptor_update_template
+ MAKE_VULKAN_ENTRY(vkCreateDescriptorUpdateTemplateKHR),
+ MAKE_VULKAN_ENTRY(vkDestroyDescriptorUpdateTemplateKHR),
+ MAKE_VULKAN_ENTRY(vkUpdateDescriptorSetWithTemplateKHR),
+ // VK_KHR_device_group
+ MAKE_VULKAN_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR),
+ MAKE_VULKAN_ENTRY(vkCmdSetDeviceMaskKHR),
+ MAKE_VULKAN_ENTRY(vkCmdDispatchBaseKHR),
+ // VK_KHR_device_group_creation
+ MAKE_VULKAN_ENTRY(vkEnumeratePhysicalDeviceGroupsKHR),
+ // VK_KHR_external_fence_capabilities
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR),
+ // VK_KHR_external_memory_capabilities
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR),
+ // VK_KHR_external_semaphore_capabilities
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR),
+ // VK_KHR_get_memory_requirements2
+ MAKE_VULKAN_ENTRY(vkGetImageMemoryRequirements2KHR),
+ MAKE_VULKAN_ENTRY(vkGetBufferMemoryRequirements2KHR),
+ MAKE_VULKAN_ENTRY(vkGetImageSparseMemoryRequirements2KHR),
+ // VK_KHR_get_physical_device_properties2
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFeatures2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceProperties2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceFormatProperties2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceImageFormatProperties2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR),
+ MAKE_VULKAN_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR),
+ // VK_KHR_maintenance1
+ MAKE_VULKAN_ENTRY(vkTrimCommandPoolKHR),
+ // VK_KHR_maintenance3
+ MAKE_VULKAN_ENTRY(vkGetDescriptorSetLayoutSupportKHR),
+ // VK_KHR_sampler_ycbcr_conversion
+ MAKE_VULKAN_ENTRY(vkCreateSamplerYcbcrConversionKHR),
+ MAKE_VULKAN_ENTRY(vkDestroySamplerYcbcrConversionKHR),
+ };
+#undef MAKE_VULKAN_ENTRY
+
+ PFN_vkVoidFunction GetProcAddr(const char* pName)
+ {
+ auto pFunc = func_ptrs.find(std::string(pName));
+ return (pFunc == func_ptrs.end()) ? nullptr : pFunc->second;
+ }
+}
diff --git a/src/Vulkan/VkGetProcAddress.h b/src/Vulkan/VkGetProcAddress.h
new file mode 100644
index 0000000..c8bfc35
--- /dev/null
+++ b/src/Vulkan/VkGetProcAddress.h
@@ -0,0 +1,25 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef VK_UTILS_HPP_
+#define VK_UTILS_HPP_
+
+#include <vulkan/vulkan.h>
+
+namespace vk
+{
+ PFN_vkVoidFunction GetProcAddr(const char* pName);
+}
+
+#endif // VK_UTILS_HPP_
\ No newline at end of file
diff --git a/src/Vulkan/VkPromotedExtensions.cpp b/src/Vulkan/VkPromotedExtensions.cpp
new file mode 100644
index 0000000..8bfe9c4
--- /dev/null
+++ b/src/Vulkan/VkPromotedExtensions.cpp
@@ -0,0 +1,190 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains function definitions for extensions Vulkan 1.1
+// promoted into the core API. (See spec Appendix D: Core Revisions)
+
+// The current list of promoted extensions is:
+// VK_KHR_16bit_storage (no functions in this extension)
+// VK_KHR_bind_memory2
+// VK_KHR_dedicated_allocation (no functions in this extension)
+// VK_KHR_descriptor_update_template
+// VK_KHR_device_group
+// VK_KHR_device_group_creation
+// VK_KHR_external_fence (no functions in this extension)
+// VK_KHR_external_fence_capabilities
+// VK_KHR_external_memory (no functions in this extension)
+// VK_KHR_external_memory_capabilities
+// VK_KHR_external_semaphore (no functions in this extension)
+// VK_KHR_external_semaphore_capabilities
+// VK_KHR_get_memory_requirements2
+// VK_KHR_get_physical_device_properties2
+// VK_KHR_maintenance1
+// VK_KHR_maintenance2 (no functions in this extension)
+// VK_KHR_maintenance3
+// VK_KHR_multiview (no functions in this extension)
+// VK_KHR_relaxed_block_layout (no functions in this extension)
+// VK_KHR_sampler_ycbcr_conversion
+// VK_KHR_shader_draw_parameters (no functions in this extension)
+// VK_KHR_storage_buffer_storage_class (no functions in this extension)
+// VK_KHR_variable_pointers (no functions in this extension)
+
+#include <vulkan/vulkan.h>
+
+extern "C"
+{
+
+// VK_KHR_bind_memory2
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+ return vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+ return vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+}
+
+// VK_KHR_descriptor_update_template
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ return vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+ vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
+{
+ vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+
+// VK_KHR_device_group
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+ vkCmdSetDeviceMask(commandBuffer, deviceMask);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+ vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+
+// VK_KHR_device_group_creation
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ return vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+}
+
+// VK_KHR_external_fence_capabilities
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+ vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+
+// VK_KHR_external_memory_capabilities
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+ vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+
+// VK_KHR_external_semaphore_capabilities
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+
+// VK_KHR_get_memory_requirements2
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+ vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+ vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+// VK_KHR_get_physical_device_properties2
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+ vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+ vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+ vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+ return vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+ vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+
+// VK_KHR_maintenance1
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+ vkTrimCommandPool(device, commandPool, flags);
+}
+
+// VK_KHR_maintenance3
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+ vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
+
+// VK_KHR_sampler_ycbcr_conversion
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ return vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+ vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+}
+
+}
\ No newline at end of file
diff --git a/src/Vulkan/libVulkan.cpp b/src/Vulkan/libVulkan.cpp
new file mode 100644
index 0000000..ff86d67
--- /dev/null
+++ b/src/Vulkan/libVulkan.cpp
@@ -0,0 +1,1283 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VkDebug.hpp"
+#include "VkGetProcAddress.h"
+#include <vulkan/vulkan.h>
+#include <string>
+
+extern "C"
+{
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName)
+{
+ return vk::GetProcAddr(pName);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+ TRACE("(const VkInstanceCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkInstance* pInstance = 0x%X)",
+ pCreateInfo, pAllocator, pInstance);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkInstance instance = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)", instance, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+ TRACE("(VkInstance instance = 0x%X, uint32_t* pPhysicalDeviceCount = 0x%X, VkPhysicalDevice* pPhysicalDevices = 0x%X)",
+ instance, pPhysicalDeviceCount, pPhysicalDevices);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceFeatures* pFeatures = 0x%X)",
+ physicalDevice, pFeatures);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+ TRACE("GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice = 0x%X, VkFormat format = %d, VkFormatProperties* pFormatProperties = 0x%X)",
+ physicalDevice, (int)format, pFormatProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkFormat format = %d, VkImageType type = %d, VkImageTiling tiling = %d, VkImageUsageFlags usage = %d, VkImageCreateFlags flags = %d, VkImageFormatProperties* pImageFormatProperties = 0x%X)",
+ physicalDevice, (int)format, (int)type, (int)tiling, usage, flags, pImageFormatProperties);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceProperties* pProperties = 0x%X)",
+ physicalDevice, pProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, uint32_t* pQueueFamilyPropertyCount = 0x%X, VkQueueFamilyProperties* pQueueFamilyProperties = 0x%X))", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceMemoryProperties* pMemoryProperties = 0x%X)", physicalDevice, pMemoryProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* pName)
+{
+ TRACE("(VkInstance instance = 0x%X, const char* pName = 0x%X)", instance, pName);
+
+ UNIMPLEMENTED();
+
+ return vk::GetProcAddr(pName);
+}
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* pName)
+{
+ TRACE("(VkDevice device = 0x%X, const char* pName = 0x%X)", device, pName);
+
+ UNIMPLEMENTED();
+
+ return vk::GetProcAddr(pName);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const VkDeviceCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkDevice* pDevice = 0x%X)",
+ physicalDevice, pCreateInfo, pAllocator, pDevice);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)", device, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ TRACE("(const char* pLayerName = 0x%X, uint32_t* pPropertyCount = 0x%X, VkExtensionProperties* pProperties = 0x%X)",
+ pLayerName, pPropertyCount, pProperties);
+
+ static const char *extensions[] =
+ {
+ "VK_KHR_16bit_storage",
+ "VK_KHR_bind_memory2",
+ "VK_KHR_dedicated_allocation",
+ "VK_KHR_descriptor_update_template",
+ "VK_KHR_device_group",
+ "VK_KHR_device_group_creation",
+ "VK_KHR_external_fence",
+ "VK_KHR_external_fence_capabilities",
+ "VK_KHR_external_memory",
+ "VK_KHR_external_memory_capabilities",
+ "VK_KHR_external_semaphore",
+ "VK_KHR_external_semaphore_capabilities",
+ "VK_KHR_get_memory_requirements2",
+ "VK_KHR_get_physical_device_properties2",
+ "VK_KHR_maintenance1",
+ "VK_KHR_maintenance2",
+ "VK_KHR_maintenance3",
+ "VK_KHR_multiview",
+ "VK_KHR_relaxed_block_layout",
+ "VK_KHR_sampler_ycbcr_conversion",
+ "VK_KHR_shader_draw_parameters",
+ "VK_KHR_storage_buffer_storage_class",
+ "VK_KHR_variable_pointers",
+ };
+
+ if(!pProperties)
+ {
+ *pPropertyCount = sizeof(extensions) / sizeof(extensions[0]);
+ return VK_SUCCESS;
+ }
+
+ uint32_t apiVersion = 0;
+ VkResult result = vkEnumerateInstanceVersion(&apiVersion);
+ if(result != VK_SUCCESS)
+ {
+ return result;
+ }
+
+ for(uint32_t i = 0; i < *pPropertyCount; i++)
+ {
+ size_t len = strlen(extensions[i]);
+ memcpy(pProperties[i].extensionName, extensions[i], len);
+ pProperties[i].extensionName[len] = '\0';
+ pProperties[i].specVersion = apiVersion;
+ }
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const char* pLayerName, uint32_t* pPropertyCount = 0x%X, VkExtensionProperties* pProperties = 0x%X)", physicalDevice, pPropertyCount, pProperties);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+ TRACE("(uint32_t* pPropertyCount = 0x%X, VkLayerProperties* pProperties = 0x%X)", pPropertyCount, pProperties);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, uint32_t* pPropertyCount = 0x%X, VkLayerProperties* pProperties = 0x%X)", physicalDevice, pPropertyCount, pProperties);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+ TRACE("(VkDevice device = 0x%X, uint32_t queueFamilyIndex = %d, uint32_t queueIndex = %d, VkQueue* pQueue = 0x%X)",
+ device, queueFamilyIndex, queueIndex, pQueue);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+ TRACE("(VkDevice device = 0x%X, const VkMemoryAllocateInfo* pAllocateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkDeviceMemory* pMemory = 0x%X)",
+ device, pAllocateInfo, pAllocator, pMemory);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkDeviceMemory memory = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, memory, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
+{
+ TRACE("(VkDevice device = 0x%X, VkDeviceMemory memory = 0x%X, VkDeviceSize offset = %d, VkDeviceSize size = %d, VkMemoryMapFlags flags = 0x%X, void** ppData = 0x%X)",
+ device, memory, offset, size, flags, ppData);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+{
+ TRACE("(VkDevice device = 0x%X, VkDeviceMemory memory = 0x%X)", device, memory);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+ TRACE("(VkDevice device = 0x%X, uint32_t memoryRangeCount = %d, const VkMappedMemoryRange* pMemoryRanges = 0x%X)",
+ device, memoryRangeCount, pMemoryRanges);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+ TRACE("(VkDevice device = 0x%X, uint32_t memoryRangeCount = %d, const VkMappedMemoryRange* pMemoryRanges = 0x%X)",
+ device, memoryRangeCount, pMemoryRanges);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+ TRACE("(VkDevice device = 0x%X, VkBuffer buffer = 0x%X, VkDeviceMemory memory = 0x%X, VkDeviceSize memoryOffset = %d)",
+ device, buffer, memory, memoryOffset);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+ TRACE("(VkDevice device = 0x%X, VkImage image = 0x%X, VkDeviceMemory memory = 0x%X, VkDeviceSize memoryOffset = %d)",
+ device, image, memory, memoryOffset);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+ TRACE("(VkDevice device = 0x%X, VkBuffer buffer = 0x%X, VkMemoryRequirements* pMemoryRequirements = 0x%X)",
+ device, buffer, pMemoryRequirements);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+ TRACE("(VkDevice device = 0x%X, VkImage image = 0x%X, VkMemoryRequirements* pMemoryRequirements = 0x%X)",
+ device, image, pMemoryRequirements);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+ TRACE("(VkDevice device = 0x%X, const VkFenceCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkFence* pFence = 0x%X)",
+ device, pCreateInfo, pAllocator, pFence);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkFence fence = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, fence, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+ TRACE("(VkDevice device = 0x%X, const VkBufferCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkBuffer* pBuffer = 0x%X)",
+ device, pCreateInfo, pAllocator, pBuffer);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkBuffer buffer = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, buffer, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+ TRACE("(VkDevice device = 0x%X, const VkImageCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkImage* pImage = 0x%X)",
+ device, pCreateInfo, pAllocator, pImage);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkImage image = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, image, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+ TRACE("(VkDevice device = 0x%X, const VkImageViewCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkImageView* pView = 0x%X)",
+ device, pCreateInfo, pAllocator, pView);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+ TRACE("(VkDevice device = 0x%X, const VkShaderModuleCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkShaderModule* pShaderModule = 0x%X)",
+ device, pCreateInfo, pAllocator, pShaderModule);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkShaderModule shaderModule = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, shaderModule, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+ TRACE("(VkDevice device = 0x%X, VkPipelineCache pipelineCache = 0x%X, uint32_t createInfoCount = %d, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator = 0x%X, VkPipeline* pPipelines = 0x%X)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+ TRACE("(VkDevice device = 0x%X, VkPipelineCache pipelineCache = 0x%X, uint32_t createInfoCount = %d, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator = 0x%X, VkPipeline* pPipelines = 0x%X)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkPipeline pipeline = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, pipeline, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+ TRACE("(VkDevice device = 0x%X, const VkPipelineLayoutCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkPipelineLayout* pPipelineLayout = 0x%X)",
+ device, pCreateInfo, pAllocator, pPipelineLayout);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkPipelineLayout pipelineLayout = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, pipelineLayout, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+ TRACE("(VkDevice device = 0x%X, const VkSamplerCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkSampler* pSampler = 0x%X)",
+ device, pCreateInfo, pAllocator, pSampler);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkSampler sampler = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, sampler, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+ TRACE("(VkDevice device = 0x%X, const VkFramebufferCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkFramebuffer* pFramebuffer = 0x%X)",
+ device, pCreateInfo, pAllocator, pFramebuffer);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkFramebuffer framebuffer = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)");
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+ TRACE("(VkDevice device = 0x%X, const VkRenderPassCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkRenderPass* pRenderPass = 0x%X)",
+ device, pCreateInfo, pAllocator, pRenderPass);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkRenderPass renderPass = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, renderPass, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+ TRACE("(VkDevice device = 0x%X, const VkCommandPoolCreateInfo* pCreateInfo = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X, VkCommandPool* pCommandPool = 0x%X)",
+ device, pCreateInfo, pAllocator, pCommandPool);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("(VkDevice device = 0x%X, VkCommandPool commandPool = 0x%X, const VkAllocationCallbacks* pAllocator = 0x%X)",
+ device, commandPool, pAllocator);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+ TRACE("(VkDevice device = 0x%X, const VkCommandBufferAllocateInfo* pAllocateInfo = 0x%X, VkCommandBuffer* pCommandBuffers = 0x%X)",
+ device, pAllocateInfo, pCommandBuffers);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+ TRACE("(VkDevice device = 0x%X, VkCommandPool commandPool = 0x%X, uint32_t commandBufferCount = %d, const VkCommandBuffer* pCommandBuffers = 0x%X)",
+ device, commandPool, commandBufferCount, pCommandBuffers);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, const VkCommandBufferBeginInfo* pBeginInfo = 0x%X)",
+ commandBuffer, pBeginInfo);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X)", commandBuffer);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, VkPipelineBindPoint pipelineBindPoint = %d, VkPipeline pipeline = 0x%X)",
+ commandBuffer, pipelineBindPoint, pipeline);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, uint32_t firstBinding = %d, uint32_t bindingCount = %d, const VkBuffer* pBuffers = 0x%X, const VkDeviceSize* pOffsets = 0x%X)",
+ commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, uint32_t vertexCount = %d, uint32_t instanceCount = %d, uint32_t firstVertex = %d, uint32_t firstInstance = %d)",
+ commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, uint32_t indexCount = %d, uint32_t instanceCount = %d, uint32_t firstIndex = %d, int32_t vertexOffset = %d, uint32_t firstInstance = %d)",
+ commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, VkBuffer buffer = 0x%X, VkDeviceSize offset = %d, uint32_t drawCount = %d, uint32_t stride = %d)",
+ commandBuffer, buffer, offset, drawCount, stride);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, VkBuffer buffer = 0x%X, VkDeviceSize offset = %d, uint32_t drawCount = %d, uint32_t stride = %d)",
+ commandBuffer, buffer, offset, drawCount, stride);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, VkImage srcImage = 0x%X, VkImageLayout srcImageLayout = %d, VkBuffer dstBuffer = 0x%X, uint32_t regionCount = %d, const VkBufferImageCopy* pRegions = 0x%X)",
+ commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, VkPipelineStageFlags srcStageMask = 0x%X, VkPipelineStageFlags dstStageMask = 0x%X, VkDependencyFlags dependencyFlags = %d, uint32_t memoryBarrierCount = %d, onst VkMemoryBarrier* pMemoryBarriers = 0x%X,"
+ " uint32_t bufferMemoryBarrierCount = %d, const VkBufferMemoryBarrier* pBufferMemoryBarriers = 0x%X, uint32_t imageMemoryBarrierCount = %d, const VkImageMemoryBarrier* pImageMemoryBarriers = 0x%X)",
+ commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X, const VkRenderPassBeginInfo* pRenderPassBegin = 0x%X, VkSubpassContents contents = %d)",
+ commandBuffer, pRenderPassBegin, contents);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+{
+ TRACE("(VkCommandBuffer commandBuffer = 0x%X)", commandBuffer);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(uint32_t* pApiVersion)
+{
+ TRACE("(uint32_t* pApiVersion = 0x%X)", pApiVersion);
+ *pApiVersion = VK_API_VERSION_1_1;
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceFeatures2* pFeatures = 0x%X)", physicalDevice, pFeatures);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceProperties2* pProperties = 0x%X)", physicalDevice, pProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkFormat format = %d, VkFormatProperties2* pFormatProperties = 0x%X)",
+ physicalDevice, format, pFormatProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo = 0x%X, VkImageFormatProperties2* pImageFormatProperties = 0x%X)",
+ physicalDevice, pImageFormatInfo, pImageFormatProperties);
+
+ UNIMPLEMENTED();
+
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, uint32_t* pQueueFamilyPropertyCount = 0x%X, VkQueueFamilyProperties2* pQueueFamilyProperties = 0x%X)",
+ physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ TRACE("(VkPhysicalDevice physicalDevice = 0x%X, VkPhysicalDeviceMemoryProperties2* pMemoryProperties = 0x%X)", physicalDevice, pMemoryProperties);
+
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+ TRACE("()");
+ UNIMPLEMENTED();
+}
+
+}
\ No newline at end of file
diff --git a/src/Vulkan/main.cpp b/src/Vulkan/main.cpp
new file mode 100644
index 0000000..cdcbf39
--- /dev/null
+++ b/src/Vulkan/main.cpp
@@ -0,0 +1,78 @@
+// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// main.cpp: DLL entry point.
+
+#include "resource.h"
+#include <windows.h>
+
+#if defined(_WIN32)
+#ifdef DEBUGGER_WAIT_DIALOG
+static INT_PTR CALLBACK DebuggerWaitDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+ RECT rect;
+
+ switch(uMsg)
+ {
+ case WM_INITDIALOG:
+ GetWindowRect(GetDesktopWindow(), &rect);
+ SetWindowPos(hwnd, HWND_TOP, rect.right / 2, rect.bottom / 2, 0, 0, SWP_NOSIZE);
+ SetTimer(hwnd, 1, 100, NULL);
+ return TRUE;
+ case WM_COMMAND:
+ if(LOWORD(wParam) == IDCANCEL)
+ {
+ EndDialog(hwnd, 0);
+ }
+ break;
+ case WM_TIMER:
+ if(IsDebuggerPresent())
+ {
+ EndDialog(hwnd, 0);
+ }
+ }
+
+ return FALSE;
+}
+
+static void WaitForDebugger(HINSTANCE instance)
+{
+ if(!IsDebuggerPresent())
+ {
+ HRSRC dialog = FindResource(instance, MAKEINTRESOURCE(IDD_DIALOG1), RT_DIALOG);
+ DLGTEMPLATE *dialogTemplate = (DLGTEMPLATE*)LoadResource(instance, dialog);
+ DialogBoxIndirect(instance, dialogTemplate, NULL, DebuggerWaitDialogProc);
+ }
+}
+#endif
+
+extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
+{
+ switch(reason)
+ {
+ case DLL_PROCESS_ATTACH:
+#ifdef DEBUGGER_WAIT_DIALOG
+ WaitForDebugger(instance);
+#endif
+ break;
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ case DLL_PROCESS_DETACH:
+ default:
+ break;
+ }
+
+ return TRUE;
+}
+#endif
\ No newline at end of file
diff --git a/src/Vulkan/resource.h b/src/Vulkan/resource.h
new file mode 100644
index 0000000..69cd5d0
--- /dev/null
+++ b/src/Vulkan/resource.h
@@ -0,0 +1,17 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by Resource.rc
+
+#define IDD_DIALOG1 101
+#define IDC_STATIC -1
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 101
+#define _APS_NEXT_COMMAND_VALUE 40001
+#define _APS_NEXT_CONTROL_VALUE 1001
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif
diff --git a/src/Vulkan/swiftshader_icd.def b/src/Vulkan/swiftshader_icd.def
new file mode 100644
index 0000000..2b4f9c7
--- /dev/null
+++ b/src/Vulkan/swiftshader_icd.def
@@ -0,0 +1,3 @@
+LIBRARY vk_swiftshader.dll
+EXPORTS
+ vk_icdGetInstanceProcAddr
diff --git a/src/Vulkan/vk_swiftshader_icd.json b/src/Vulkan/vk_swiftshader_icd.json
new file mode 100644
index 0000000..0a76e0b
--- /dev/null
+++ b/src/Vulkan/vk_swiftshader_icd.json
@@ -0,0 +1,7 @@
+{
+ "file_format_version": "1.0.0",
+ "ICD": {
+ "library_path": "..\\..\\bin\\vulkan\\x64\\Debug\\vk_swiftshader.dll",
+ "api_version": "1.0.5"
+ }
+}
\ No newline at end of file
diff --git a/src/Vulkan/vulkan.vcxproj b/src/Vulkan/vulkan.vcxproj
new file mode 100644
index 0000000..966a679
--- /dev/null
+++ b/src/Vulkan/vulkan.vcxproj
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <VCProjectVersion>15.0</VCProjectVersion>
+ <ProjectGuid>{E1C34B66-C942-4B9A-B8C3-9A12625650D3}</ProjectGuid>
+ <RootNamespace>vulkan</RootNamespace>
+ <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+ <ProjectName>Vulkan</ProjectName>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>NotSet</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v141</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>NotSet</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="Shared">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <IncludePath>$(SolutionDir)\include;$(SolutionDir)\src\Common;$(IncludePath)</IncludePath>
+ <OutDir>$(SolutionDir)bin\$(MSBuildProjectName)\$(Platform)\$(Configuration)\</OutDir>
+ <TargetName>vk_swiftshader</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <IncludePath>$(SolutionDir)\include;$(SolutionDir)\src\Common;$(IncludePath)</IncludePath>
+ <OutDir>$(SolutionDir)bin\$(MSBuildProjectName)\$(Platform)\$(Configuration)\</OutDir>
+ <TargetName>vk_swiftshader</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <IncludePath>$(SolutionDir)\include;$(SolutionDir)\src\Common;$(IncludePath)</IncludePath>
+ <OutDir>$(SolutionDir)bin\$(MSBuildProjectName)\$(Platform)\$(Configuration)\</OutDir>
+ <TargetName>vk_swiftshader</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <IncludePath>$(SolutionDir)\include;$(SolutionDir)\src\Common;$(IncludePath)</IncludePath>
+ <OutDir>$(SolutionDir)bin\$(MSBuildProjectName)\$(Platform)\$(Configuration)\</OutDir>
+ <TargetName>vk_swiftshader</TargetName>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalIncludeDirectories>$(ProjectDir)/..;$(ProjectDir)/../..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;EGLAPI=;EGL_EGLEXT_PROTOTYPES;NO_SANITIZE_FUNCTION=;NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ <ModuleDefinitionFile>swiftshader_icd.def</ModuleDefinitionFile>
+ </Link>
+ <PostBuildEvent>
+ <Command>mkdir "$(SolutionDir)lib\$(Configuration)_$(Platform)\"
+copy "$(OutDir)vk_swiftshader.dll" "$(SolutionDir)lib\$(Configuration)_$(Platform)\"</Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalIncludeDirectories>$(ProjectDir)/..;$(ProjectDir)/../..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;EGLAPI=;EGL_EGLEXT_PROTOTYPES;NO_SANITIZE_FUNCTION=;_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;DEBUGGER_WAIT_DIALOG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <ModuleDefinitionFile>swiftshader_icd.def</ModuleDefinitionFile>
+ </Link>
+ <PostBuildEvent>
+ <Command>mkdir "$(SolutionDir)lib\$(Configuration)_$(Platform)\"
+copy "$(OutDir)vk_swiftshader.dll" "$(SolutionDir)lib\$(Configuration)_$(Platform)\"</Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalIncludeDirectories>$(ProjectDir)/..;$(ProjectDir)/../..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;EGLAPI=;EGL_EGLEXT_PROTOTYPES;NO_SANITIZE_FUNCTION=;_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;DEBUGGER_WAIT_DIALOG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <ModuleDefinitionFile>swiftshader_icd.def</ModuleDefinitionFile>
+ </Link>
+ <PostBuildEvent>
+ <Command>mkdir "$(SolutionDir)lib\$(Configuration)_$(Platform)\"
+copy "$(OutDir)vk_swiftshader.dll" "$(SolutionDir)lib\$(Configuration)_$(Platform)\"</Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>true</SDLCheck>
+ <AdditionalIncludeDirectories>$(ProjectDir)/..;$(ProjectDir)/../..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;EGLAPI=;EGL_EGLEXT_PROTOTYPES;NO_SANITIZE_FUNCTION=;NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ <ModuleDefinitionFile>swiftshader_icd.def</ModuleDefinitionFile>
+ </Link>
+ <PostBuildEvent>
+ <Command>mkdir "$(SolutionDir)lib\$(Configuration)_$(Platform)\"
+copy "$(OutDir)vk_swiftshader.dll" "$(SolutionDir)lib\$(Configuration)_$(Platform)\"</Command>
+ </PostBuildEvent>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClCompile Include="libVulkan.cpp" />
+ <ClCompile Include="main.cpp" />
+ <ClCompile Include="VkDebug.cpp" />
+ <ClCompile Include="VkGetProcAddress.cpp" />
+ <ClCompile Include="VkPromotedExtensions.cpp" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="VkDebug.hpp" />
+ <ClInclude Include="resource.h" />
+ <ClInclude Include="VkGetProcAddress.h" />
+ </ItemGroup>
+ <ItemGroup>
+ <None Include="swiftshader_icd.def" />
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Vulkan/vulkan.vcxproj.filters b/src/Vulkan/vulkan.vcxproj.filters
new file mode 100644
index 0000000..3c129fe
--- /dev/null
+++ b/src/Vulkan/vulkan.vcxproj.filters
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Source Files">
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+ </Filter>
+ <Filter Include="Header Files">
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+ <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+ </Filter>
+ <Filter Include="Resource Files">
+ <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="main.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="libVulkan.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="VkGetProcAddress.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="VkDebug.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="VkPromotedExtensions.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="resource.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="VkDebug.hpp">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="VkGetProcAddress.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ </ItemGroup>
+ <ItemGroup>
+ <None Include="swiftshader_icd.def" />
+ </ItemGroup>
+</Project>
\ No newline at end of file
