1 // 2 // File: vk_layer.h 3 // 4 /* 5 * Copyright (c) 2015-2017 The Khronos Group Inc. 6 * Copyright (c) 2015-2017 Valve Corporation 7 * Copyright (c) 2015-2017 LunarG, Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 */ 22 23 /* Need to define dispatch table 24 * Core struct can then have ptr to dispatch table at the top 25 * Along with object ptrs for current and next OBJ 26 */ 27 #pragma once 28 29 #include "vulkan.h" 30 #if defined(__GNUC__) && __GNUC__ >= 4 31 #define VK_LAYER_EXPORT __attribute__((visibility("default"))) 32 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) 33 #define VK_LAYER_EXPORT __attribute__((visibility("default"))) 34 #else 35 #define VK_LAYER_EXPORT 36 #endif 37 38 #define MAX_NUM_UNKNOWN_EXTS 250 39 40 // Loader-Layer version negotiation API. Versions add the following features: 41 // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr 42 // or vk_icdNegotiateLoaderLayerInterfaceVersion. 43 // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and 44 // vk_icdNegotiateLoaderLayerInterfaceVersion. 45 #define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 46 #define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 47 48 #define VK_CURRENT_CHAIN_VERSION 1 49 50 // Typedef for use in the interfaces below 51 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); 52 53 // Version negotiation values 54 typedef enum VkNegotiateLayerStructType { 55 LAYER_NEGOTIATE_UNINTIALIZED = 0, 56 LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, 57 } VkNegotiateLayerStructType; 58 59 // Version negotiation structures 60 typedef struct VkNegotiateLayerInterface { 61 VkNegotiateLayerStructType sType; 62 void *pNext; 63 uint32_t loaderLayerInterfaceVersion; 64 PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; 65 PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; 66 PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; 67 } VkNegotiateLayerInterface; 68 69 // Version negotiation functions 70 typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); 71 72 // Function prototype for unknown physical device extension command 73 typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); 74 75 // ------------------------------------------------------------------------------------------------ 76 // CreateInstance and CreateDevice support structures 77 78 /* Sub type of structure for instance and device loader ext of CreateInfo. 79 * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO 80 * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO 81 * then VkLayerFunction indicates struct type pointed to by pNext 82 */ 83 typedef enum VkLayerFunction_ { 84 VK_LAYER_LINK_INFO = 0, 85 VK_LOADER_DATA_CALLBACK = 1, 86 VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2 87 } VkLayerFunction; 88 89 typedef struct VkLayerInstanceLink_ { 90 struct VkLayerInstanceLink_ *pNext; 91 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 92 PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; 93 } VkLayerInstanceLink; 94 95 /* 96 * When creating the device chain the loader needs to pass 97 * down information about it's device structure needed at 98 * the end of the chain. Passing the data via the 99 * VkLayerDeviceInfo avoids issues with finding the 100 * exact instance being used. 101 */ 102 typedef struct VkLayerDeviceInfo_ { 103 void *device_info; 104 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 105 } VkLayerDeviceInfo; 106 107 typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, 108 void *object); 109 typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, 110 void *object); 111 typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, 112 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); 113 typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); 114 typedef struct { 115 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO 116 const void *pNext; 117 VkLayerFunction function; 118 union { 119 VkLayerInstanceLink *pLayerInfo; 120 PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; 121 struct { 122 PFN_vkLayerCreateDevice pfnLayerCreateDevice; 123 PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; 124 } layerDevice; 125 } u; 126 } VkLayerInstanceCreateInfo; 127 128 typedef struct VkLayerDeviceLink_ { 129 struct VkLayerDeviceLink_ *pNext; 130 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 131 PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; 132 } VkLayerDeviceLink; 133 134 typedef struct { 135 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO 136 const void *pNext; 137 VkLayerFunction function; 138 union { 139 VkLayerDeviceLink *pLayerInfo; 140 PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; 141 } u; 142 } VkLayerDeviceCreateInfo; 143 144 #ifdef __cplusplus 145 extern "C" { 146 #endif 147 148 VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); 149 150 typedef enum VkChainType { 151 VK_CHAIN_TYPE_UNKNOWN = 0, 152 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, 153 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, 154 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, 155 } VkChainType; 156 157 typedef struct VkChainHeader { 158 VkChainType type; 159 uint32_t version; 160 uint32_t size; 161 } VkChainHeader; 162 163 typedef struct VkEnumerateInstanceExtensionPropertiesChain { 164 VkChainHeader header; 165 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, 166 VkExtensionProperties *); 167 const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; 168 169 #if defined(__cplusplus) CallDownVkEnumerateInstanceExtensionPropertiesChain170 inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { 171 return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); 172 } 173 #endif 174 } VkEnumerateInstanceExtensionPropertiesChain; 175 176 typedef struct VkEnumerateInstanceLayerPropertiesChain { 177 VkChainHeader header; 178 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); 179 const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; 180 181 #if defined(__cplusplus) CallDownVkEnumerateInstanceLayerPropertiesChain182 inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { 183 return pfnNextLayer(pNextLink, pPropertyCount, pProperties); 184 } 185 #endif 186 } VkEnumerateInstanceLayerPropertiesChain; 187 188 typedef struct VkEnumerateInstanceVersionChain { 189 VkChainHeader header; 190 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); 191 const struct VkEnumerateInstanceVersionChain *pNextLink; 192 193 #if defined(__cplusplus) CallDownVkEnumerateInstanceVersionChain194 inline VkResult CallDown(uint32_t *pApiVersion) const { 195 return pfnNextLayer(pNextLink, pApiVersion); 196 } 197 #endif 198 } VkEnumerateInstanceVersionChain; 199 200 #ifdef __cplusplus 201 } 202 #endif 203