| /* | |
| ** Copyright (c) 2015-2017 The Khronos Group Inc. | |
| ** | |
| ** 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. | |
| */ | |
| // clang-format off | |
| #include <vulkan/vulkan.h> | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( | |
| const VkInstanceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkInstance* pInstance) { return VK_ERROR_INCOMPATIBLE_DRIVER; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( | |
| VkInstance instance, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceCount, | |
| VkPhysicalDevice* pPhysicalDevices) { return VK_ERROR_INITIALIZATION_FAILED; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures* pFeatures) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures2* pFeatures) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties* pFormatProperties) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkImageTiling tiling, | |
| VkImageUsageFlags usage, | |
| VkImageCreateFlags flags, | |
| VkImageFormatProperties* pImageFormatProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties* pProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties* pQueueFamilyProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) {} | |
| VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( | |
| VkInstance instance, | |
| const char* pName) { | |
| return NULL; | |
| } | |
| VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( | |
| VkDevice device, | |
| const char* pName) { return NULL; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( | |
| VkPhysicalDevice physicalDevice, | |
| const VkDeviceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDevice* pDevice) { return VK_ERROR_INITIALIZATION_FAILED; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( | |
| VkDevice device, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( | |
| const char* pLayerName, | |
| uint32_t* pPropertyCount, | |
| VkExtensionProperties* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( | |
| VkPhysicalDevice physicalDevice, | |
| const char* pLayerName, | |
| uint32_t* pPropertyCount, | |
| VkExtensionProperties* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( | |
| uint32_t* pPropertyCount, | |
| VkLayerProperties* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkLayerProperties* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( | |
| uint32_t* pApiVersion) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( | |
| VkDevice device, | |
| uint32_t queueFamilyIndex, | |
| uint32_t queueIndex, | |
| VkQueue* pQueue) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( | |
| VkQueue queue, | |
| uint32_t submitCount, | |
| const VkSubmitInfo* pSubmits, | |
| VkFence fence) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( | |
| VkDevice device, | |
| const VkDeviceQueueInfo2* pQueueInfo, | |
| VkQueue* pQueue) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( | |
| VkQueue queue) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( | |
| VkDevice device) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( | |
| VkDevice device, | |
| const VkMemoryAllocateInfo* pAllocateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDeviceMemory* pMemory) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkFreeMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkDeviceSize offset, | |
| VkDeviceSize size, | |
| VkMemoryMapFlags flags, | |
| void** ppData) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( | |
| VkDevice device, | |
| VkDeviceMemory memory) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( | |
| VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( | |
| VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkDeviceSize* pCommittedMemoryInBytes) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( | |
| VkDevice device, | |
| VkImage image, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| VkMemoryRequirements* pMemoryRequirements) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( | |
| VkDevice device, | |
| VkImage image, | |
| VkMemoryRequirements* pMemoryRequirements) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( | |
| VkDevice device, | |
| VkImage image, | |
| uint32_t* pSparseMemoryRequirementCount, | |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkSampleCountFlagBits samples, | |
| VkImageUsageFlags usage, | |
| VkImageTiling tiling, | |
| uint32_t* pPropertyCount, | |
| VkSparseImageFormatProperties* pProperties) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( | |
| VkQueue queue, | |
| uint32_t bindInfoCount, | |
| const VkBindSparseInfo* pBindInfo, | |
| VkFence fence) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( | |
| VkDevice device, | |
| const VkFenceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyFence( | |
| VkDevice device, | |
| VkFence fence, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( | |
| VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( | |
| VkDevice device, | |
| VkFence fence) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( | |
| VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences, | |
| VkBool32 waitAll, | |
| uint64_t timeout) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( | |
| VkDevice device, | |
| const VkSemaphoreCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSemaphore* pSemaphore) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( | |
| VkDevice device, | |
| VkSemaphore semaphore, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( | |
| VkDevice device, | |
| const VkEventCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkEvent* pEvent) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( | |
| VkDevice device, | |
| VkEvent event, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( | |
| VkDevice device, | |
| VkEvent event) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( | |
| VkDevice device, | |
| VkEvent event) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( | |
| VkDevice device, | |
| VkEvent event) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( | |
| VkDevice device, | |
| const VkQueryPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkQueryPool* pQueryPool) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( | |
| VkDevice device, | |
| VkQueryPool queryPool, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| 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) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( | |
| VkDevice device, | |
| const VkBufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBuffer* pBuffer) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( | |
| VkDevice device, | |
| const VkBufferViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBufferView* pView) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( | |
| VkDevice device, | |
| VkBufferView bufferView, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( | |
| VkDevice device, | |
| const VkImageCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImage* pImage) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyImage( | |
| VkDevice device, | |
| VkImage image, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( | |
| VkDevice device, | |
| VkImage image, | |
| const VkImageSubresource* pSubresource, | |
| VkSubresourceLayout* pLayout) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( | |
| VkDevice device, | |
| const VkImageViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImageView* pView) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( | |
| VkDevice device, | |
| VkImageView imageView, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( | |
| VkDevice device, | |
| const VkShaderModuleCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkShaderModule* pShaderModule) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( | |
| VkDevice device, | |
| VkShaderModule shaderModule, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( | |
| VkDevice device, | |
| const VkPipelineCacheCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineCache* pPipelineCache) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| size_t* pDataSize, | |
| void* pData) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( | |
| VkDevice device, | |
| VkPipelineCache dstCache, | |
| uint32_t srcCacheCount, | |
| const VkPipelineCache* pSrcCaches) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( | |
| VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkComputePipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( | |
| VkDevice device, | |
| const VkPipelineLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipelineLayout* pPipelineLayout) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( | |
| VkDevice device, | |
| VkPipelineLayout pipelineLayout, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( | |
| VkDevice device, | |
| const VkSamplerCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSampler* pSampler) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroySampler( | |
| VkDevice device, | |
| VkSampler sampler, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( | |
| VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorSetLayout* pSetLayout) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( | |
| VkDevice device, | |
| VkDescriptorSetLayout descriptorSetLayout, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( | |
| VkDevice device, | |
| const VkDescriptorPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorPool* pDescriptorPool) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| VkDescriptorPoolResetFlags flags) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( | |
| VkDevice device, | |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, | |
| VkDescriptorSet* pDescriptorSets) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VkDescriptorSet* pDescriptorSets) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( | |
| VkDevice device, | |
| uint32_t descriptorWriteCount, | |
| const VkWriteDescriptorSet* pDescriptorWrites, | |
| uint32_t descriptorCopyCount, | |
| const VkCopyDescriptorSet* pDescriptorCopies) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( | |
| VkDevice device, | |
| const VkFramebufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFramebuffer* pFramebuffer) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( | |
| VkDevice device, | |
| VkFramebuffer framebuffer, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( | |
| VkDevice device, | |
| const VkRenderPassCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| VkExtent2D* pGranularity) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( | |
| VkDevice device, | |
| const VkCommandPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkCommandPool* pCommandPool) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| VkCommandPoolResetFlags flags) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( | |
| VkDevice device, | |
| const VkCommandBufferAllocateInfo* pAllocateInfo, | |
| VkCommandBuffer* pCommandBuffers) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( | |
| VkCommandBuffer commandBuffer, | |
| const VkCommandBufferBeginInfo* pBeginInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( | |
| VkCommandBuffer commandBuffer) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkCommandBufferResetFlags flags) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineBindPoint pipelineBindPoint, | |
| VkPipeline pipeline) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VkViewport* pViewports) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstScissor, | |
| uint32_t scissorCount, | |
| const VkRect2D* pScissors) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( | |
| VkCommandBuffer commandBuffer, | |
| float lineWidth) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( | |
| VkCommandBuffer commandBuffer, | |
| float depthBiasConstantFactor, | |
| float depthBiasClamp, | |
| float depthBiasSlopeFactor) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( | |
| VkCommandBuffer commandBuffer, | |
| const float blendConstants[4]) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( | |
| VkCommandBuffer commandBuffer, | |
| float minDepthBounds, | |
| float maxDepthBounds) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t compareMask) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t writeMask) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( | |
| VkCommandBuffer commandBuffer, | |
| VkStencilFaceFlags faceMask, | |
| uint32_t reference) {} | |
| 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) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkIndexType indexType) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstBinding, | |
| uint32_t bindingCount, | |
| const VkBuffer* pBuffers, | |
| const VkDeviceSize* pOffsets) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDraw( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t vertexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstVertex, | |
| uint32_t firstInstance) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t indexCount, | |
| uint32_t instanceCount, | |
| uint32_t firstIndex, | |
| int32_t vertexOffset, | |
| uint32_t firstInstance) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| uint32_t drawCount, | |
| uint32_t stride) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferCopy* pRegions) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageCopy* pRegions) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageBlit* pRegions, | |
| VkFilter filter) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize dataSize, | |
| const void* pData) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize size, | |
| uint32_t data) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage image, | |
| VkImageLayout imageLayout, | |
| const VkClearColorValue* pColor, | |
| uint32_t rangeCount, | |
| const VkImageSubresourceRange* pRanges) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage image, | |
| VkImageLayout imageLayout, | |
| const VkClearDepthStencilValue* pDepthStencil, | |
| uint32_t rangeCount, | |
| const VkImageSubresourceRange* pRanges) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t attachmentCount, | |
| const VkClearAttachment* pAttachments, | |
| uint32_t rectCount, | |
| const VkClearRect* pRects) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( | |
| VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkImageResolve* pRegions) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( | |
| VkCommandBuffer commandBuffer, | |
| VkEvent event, | |
| VkPipelineStageFlags stageMask) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( | |
| VkCommandBuffer commandBuffer, | |
| VkEvent event, | |
| VkPipelineStageFlags stageMask) {} | |
| 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) {} | |
| 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) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query, | |
| VkQueryControlFlags flags) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t query) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineStageFlagBits pipelineStage, | |
| VkQueryPool queryPool, | |
| uint32_t query) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( | |
| VkCommandBuffer commandBuffer, | |
| VkQueryPool queryPool, | |
| uint32_t firstQuery, | |
| uint32_t queryCount, | |
| VkBuffer dstBuffer, | |
| VkDeviceSize dstOffset, | |
| VkDeviceSize stride, | |
| VkQueryResultFlags flags) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineLayout layout, | |
| VkShaderStageFlags stageFlags, | |
| uint32_t offset, | |
| uint32_t size, | |
| const void* pValues) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( | |
| VkCommandBuffer commandBuffer, | |
| const VkRenderPassBeginInfo* pRenderPassBegin, | |
| VkSubpassContents contents) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( | |
| VkCommandBuffer commandBuffer, | |
| VkSubpassContents contents) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( | |
| VkCommandBuffer commandBuffer) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers) {} | |
| VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( | |
| VkInstance instance, | |
| VkSurfaceKHR surface, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| VkSurfaceKHR surface, | |
| VkBool32* pSupported) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pSurfaceFormatCount, | |
| VkSurfaceFormatKHR* pSurfaceFormats) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pPresentModeCount, | |
| VkPresentModeKHR* pPresentModes) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( | |
| VkDevice device, | |
| const VkSwapchainCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchain) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pSwapchainImageCount, | |
| VkImage* pSwapchainImages) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint64_t timeout, | |
| VkSemaphore semaphore, | |
| VkFence fence, | |
| uint32_t* pImageIndex) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( | |
| VkQueue queue, | |
| const VkPresentInfoKHR* pPresentInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayPropertiesKHR* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkDisplayPlanePropertiesKHR* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t planeIndex, | |
| uint32_t* pDisplayCount, | |
| VkDisplayKHR* pDisplays) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| uint32_t* pPropertyCount, | |
| VkDisplayModePropertiesKHR* pProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display, | |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDisplayModeKHR* pMode) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayModeKHR mode, | |
| uint32_t planeIndex, | |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( | |
| VkInstance instance, | |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| #ifdef VK_USE_PLATFORM_XLIB_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( | |
| VkInstance instance, | |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| Display* dpy, | |
| VisualID visualID) { return VK_TRUE; } | |
| #endif /* VK_USE_PLATFORM_XLIB_KHR */ | |
| #ifdef VK_USE_PLATFORM_XCB_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( | |
| VkInstance instance, | |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| xcb_connection_t* connection, | |
| xcb_visualid_t visual_id) { return VK_TRUE; } | |
| #endif /* VK_USE_PLATFORM_XCB_KHR */ | |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( | |
| VkInstance instance, | |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| struct wl_display* display) { return VK_TRUE; } | |
| #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ | |
| #ifdef VK_USE_PLATFORM_MIR_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( | |
| VkInstance instance, | |
| const VkMirSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| MirConnection* connection) { return VK_TRUE; } | |
| #endif /* VK_USE_PLATFORM_MIR_KHR */ | |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( | |
| VkInstance instance, | |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_ANDROID_KHR */ | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( | |
| VkInstance instance, | |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex) { return VK_TRUE; } | |
| #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures2KHR* pFeatures) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties2KHR* pProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties2KHR* pFormatProperties) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, | |
| VkImageFormatProperties2KHR* pImageFormatProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties2KHR* pQueueFamilyProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, | |
| uint32_t* pPropertyCount, | |
| VkSparseImageFormatProperties2KHR* pProperties) {} | |
| VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| VkCommandPoolTrimFlagsKHR flags) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, | |
| VkExternalBufferPropertiesKHR* pExternalBufferProperties) {} | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( | |
| VkDevice device, | |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBitsKHR handleType, | |
| HANDLE handle, | |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( | |
| VkDevice device, | |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, | |
| int* pFd) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBitsKHR handleType, | |
| int fd, | |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, | |
| VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) {} | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, | |
| int* pFd) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkPipelineBindPoint pipelineBindPoint, | |
| VkPipelineLayout layout, | |
| uint32_t set, | |
| uint32_t descriptorWriteCount, | |
| const VkWriteDescriptorSet* pDescriptorWrites) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( | |
| VkDevice device, | |
| VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( | |
| VkDevice device, | |
| VkDescriptorSet descriptorSet, | |
| VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, | |
| const void* pData) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( | |
| VkCommandBuffer commandBuffer, | |
| VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, | |
| VkPipelineLayout layout, | |
| uint32_t set, | |
| const void* pData) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, | |
| VkExternalFencePropertiesKHR* pExternalFenceProperties) {} | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( | |
| VkDevice device, | |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( | |
| VkDevice device, | |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( | |
| VkDevice device, | |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( | |
| VkDevice device, | |
| const VkFenceGetFdInfoKHR* pGetFdInfo, | |
| int* pFd) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, | |
| uint32_t* pSurfaceFormatCount, | |
| VkSurfaceFormat2KHR* pSurfaceFormats) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkImageMemoryRequirementsInfo2KHR* pInfo, | |
| VkMemoryRequirements2KHR* pMemoryRequirements) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkBufferMemoryRequirementsInfo2KHR* pInfo, | |
| VkMemoryRequirements2KHR* pMemoryRequirements) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( | |
| VkDevice device, | |
| const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, | |
| uint32_t* pSparseMemoryRequirementCount, | |
| VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSamplerYcbcrConversionKHR* pYcbcrConversion) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( | |
| VkDevice device, | |
| VkSamplerYcbcrConversionKHR ycbcrConversion, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindBufferMemoryInfoKHR* pBindInfos) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( | |
| VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindImageMemoryInfoKHR* pBindInfos) { return VK_SUCCESS; } | |
| #ifdef VK_USE_PLATFORM_FUCHSIA | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFuchsiaHandleKHR( | |
| VkDevice device, | |
| const VkMemoryGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo, | |
| uint32_t* pFuchsiaHandle) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFuchsiaHandlePropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBitsKHR handleType, | |
| uint32_t fuchsiaHandle, | |
| VkMemoryFuchsiaHandlePropertiesKHR* pMemoryFuchsiaHandleProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFuchsiaHandleKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreFuchsiaHandleInfoKHR* pImportSemaphoreFuchsiaHandleInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFuchsiaHandleKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetFuchsiaHandleInfoKHR* pGetFuchsiaHandleInfo, | |
| uint32_t* pFuchsiaHandle) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateMagmaSurfaceKHR( | |
| VkInstance instance, | |
| const VkMagmaSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMagmaPresentationSupportKHR( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex); | |
| #endif /* VK_USE_PLATFORM_FUCHSIA */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( | |
| VkInstance instance, | |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugReportCallbackEXT* pCallback) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( | |
| VkInstance instance, | |
| VkDebugReportCallbackEXT callback, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( | |
| VkInstance instance, | |
| VkDebugReportFlagsEXT flags, | |
| VkDebugReportObjectTypeEXT objectType, | |
| uint64_t object, | |
| size_t location, | |
| int32_t messageCode, | |
| const char* pLayerPrefix, | |
| const char* pMessage) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( | |
| VkDevice device, | |
| const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( | |
| VkDevice device, | |
| const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( | |
| VkCommandBuffer commandBuffer) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( | |
| VkCommandBuffer commandBuffer, | |
| VkBuffer buffer, | |
| VkDeviceSize offset, | |
| VkBuffer countBuffer, | |
| VkDeviceSize countBufferOffset, | |
| uint32_t maxDrawCount, | |
| uint32_t stride) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( | |
| VkDevice device, | |
| VkPipeline pipeline, | |
| VkShaderStageFlagBits shaderStage, | |
| VkShaderInfoTypeAMD infoType, | |
| size_t* pInfoSize, | |
| void* pInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkImageType type, | |
| VkImageTiling tiling, | |
| VkImageUsageFlags usage, | |
| VkImageCreateFlags flags, | |
| VkExternalMemoryHandleTypeFlagsNV externalHandleType, | |
| VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { return VK_SUCCESS; } | |
| #ifdef VK_USE_PLATFORM_WIN32_KHR | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( | |
| VkDevice device, | |
| VkDeviceMemory memory, | |
| VkExternalMemoryHandleTypeFlagsNV handleType, | |
| HANDLE* pHandle) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_WIN32_KHR */ | |
| VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( | |
| VkDevice device, | |
| uint32_t heapIndex, | |
| uint32_t localDeviceIndex, | |
| uint32_t remoteDeviceIndex, | |
| VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t deviceMask) {} | |
| VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t baseGroupX, | |
| uint32_t baseGroupY, | |
| uint32_t baseGroupZ, | |
| uint32_t groupCountX, | |
| uint32_t groupCountY, | |
| uint32_t groupCountZ) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( | |
| VkDevice device, | |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( | |
| VkDevice device, | |
| VkSurfaceKHR surface, | |
| VkDeviceGroupPresentModeFlagsKHR* pModes) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pRectCount, | |
| VkRect2D* pRects) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( | |
| VkDevice device, | |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, | |
| uint32_t* pImageIndex) { return VK_SUCCESS; } | |
| #ifdef VK_USE_PLATFORM_VI_NN | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( | |
| VkInstance instance, | |
| const VkViSurfaceCreateInfoNN* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_VI_NN */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( | |
| VkInstance instance, | |
| uint32_t* pPhysicalDeviceGroupCount, | |
| VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstViewport, | |
| uint32_t viewportCount, | |
| const VkViewportWScalingNV* pViewportWScalings) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkDisplayKHR display) { return VK_SUCCESS; } | |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT | |
| VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| Display* dpy, | |
| VkDisplayKHR display) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( | |
| VkPhysicalDevice physicalDevice, | |
| Display* dpy, | |
| RROutput rrOutput, | |
| VkDisplayKHR* pDisplay) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( | |
| VkDevice device, | |
| VkDisplayKHR display, | |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( | |
| VkDevice device, | |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( | |
| VkDevice device, | |
| VkDisplayKHR display, | |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| VkSurfaceCounterFlagBitsEXT counter, | |
| uint64_t* pCounterValue) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pPresentationTimingCount, | |
| VkPastPresentationTimingGOOGLE* pPresentationTimings) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t firstDiscardRectangle, | |
| uint32_t discardRectangleCount, | |
| const VkRect2D* pDiscardRectangles) {} | |
| VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( | |
| VkDevice device, | |
| uint32_t swapchainCount, | |
| const VkSwapchainKHR* pSwapchains, | |
| const VkHdrMetadataEXT* pMetadata) {} | |
| #ifdef VK_USE_PLATFORM_IOS_MVK | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_IOS_MVK */ | |
| #ifdef VK_USE_PLATFORM_MACOS_MVK | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( | |
| VkInstance instance, | |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { return VK_SUCCESS; } | |
| #endif /* VK_USE_PLATFORM_MACOS_MVK */ | |
| VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( | |
| VkCommandBuffer commandBuffer, | |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {} | |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( | |
| VkPhysicalDevice physicalDevice, | |
| VkSampleCountFlagBits samples, | |
| VkMultisamplePropertiesEXT* pMultisampleProperties) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( | |
| VkDevice device, | |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkValidationCacheEXT* pValidationCache) { return VK_SUCCESS; } | |
| VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT validationCache, | |
| const VkAllocationCallbacks* pAllocator) {} | |
| VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT dstCache, | |
| uint32_t srcCacheCount, | |
| const VkValidationCacheEXT* pSrcCaches) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( | |
| VkDevice device, | |
| VkValidationCacheEXT validationCache, | |
| size_t* pDataSize, | |
| void* pData) { return VK_SUCCESS; } | |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBitsKHR handleType, | |
| const void* pHostPointer, | |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { return VK_SUCCESS; } | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| // clang-format on |