| /* |
| * Copyright (c) 2015-2016 The Khronos Group Inc. |
| * Copyright (c) 2015-2016 Valve Corporation |
| * Copyright (c) 2015-2016 LunarG, 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. |
| * |
| * Author: Mark Lobodzinski <mark@lunarg.com> |
| */ |
| |
| #define _GNU_SOURCE |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "vk_loader_platform.h" |
| #include "loader.h" |
| #include "extensions.h" |
| #include <vulkan/vk_icd.h> |
| |
| // Definitions for the VK_NV_external_memory_capabilities extension |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL |
| vkGetPhysicalDeviceExternalImageFormatPropertiesNV( |
| VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, |
| VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, |
| VkExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = |
| loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_dispatch(physicalDevice); |
| |
| return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV( |
| unwrapped_phys_dev, format, type, tiling, usage, flags, |
| externalHandleType, pExternalImageFormatProperties); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL |
| terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( |
| VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, |
| VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, |
| VkExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { |
| struct loader_physical_device *phys_dev = |
| (struct loader_physical_device *)physicalDevice; |
| struct loader_icd *icd = phys_dev->this_icd; |
| |
| if (!icd->GetPhysicalDeviceExternalImageFormatPropertiesNV) { |
| if (externalHandleType) { |
| return VK_ERROR_FORMAT_NOT_SUPPORTED; |
| } |
| |
| if (!icd->GetPhysicalDeviceImageFormatProperties) { |
| return VK_ERROR_INITIALIZATION_FAILED; |
| } |
| |
| pExternalImageFormatProperties->externalMemoryFeatures = 0; |
| pExternalImageFormatProperties->exportFromImportedHandleTypes = 0; |
| pExternalImageFormatProperties->compatibleHandleTypes = 0; |
| |
| return icd->GetPhysicalDeviceImageFormatProperties( |
| phys_dev->phys_dev, format, type, tiling, usage, flags, |
| &pExternalImageFormatProperties->imageFormatProperties); |
| } |
| |
| return icd->GetPhysicalDeviceExternalImageFormatPropertiesNV( |
| phys_dev->phys_dev, format, type, tiling, usage, flags, |
| externalHandleType, pExternalImageFormatProperties); |
| } |
| |
| // Definitions for the VK_AMD_draw_indirect_count extension |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, |
| VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, |
| uint32_t stride) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, |
| countBufferOffset, maxDrawCount, stride); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, |
| VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, |
| uint32_t stride) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, |
| countBuffer, countBufferOffset, |
| maxDrawCount, stride); |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| // Definitions for the VK_NV_external_memory_win32 extension |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( |
| VkDevice device, VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); |
| } |
| |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| // GPA helpers for non-KHR extensions |
| |
| bool extension_instance_gpa(struct loader_instance *ptr_instance, |
| const char *name, void **addr) { |
| *addr = NULL; |
| |
| // Functions for the VK_NV_external_memory_capabilities extension |
| |
| if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) { |
| *addr = (ptr_instance->enabled_known_extensions |
| .nv_external_memory_capabilities == 1) |
| ? (void *)vkGetPhysicalDeviceExternalImageFormatPropertiesNV |
| : NULL; |
| return true; |
| } |
| |
| // Functions for the VK_AMD_draw_indirect_count extension |
| |
| if (!strcmp("vkCmdDrawIndirectCountAMD", name)) { |
| *addr = (void *)vkCmdDrawIndirectCountAMD; |
| return true; |
| } |
| |
| if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) { |
| *addr = (void *)vkCmdDrawIndexedIndirectCountAMD; |
| return true; |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| // Functions for the VK_NV_external_memory_win32 extension |
| |
| if (!strcmp("vkGetMemoryWin32HandleNV", name)) { |
| *addr = (void *)vkGetMemoryWin32HandleNV; |
| return true; |
| } |
| |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| return false; |
| } |
| |
| void extensions_create_instance(struct loader_instance *ptr_instance, |
| const VkInstanceCreateInfo *pCreateInfo) { |
| ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 0; |
| |
| for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { |
| if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], |
| VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) == 0) { |
| ptr_instance->enabled_known_extensions |
| .nv_external_memory_capabilities = 1; |
| return; |
| } |
| } |
| } |