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