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 } VkLayerFunction; 87 88 typedef struct VkLayerInstanceLink_ { 89 struct VkLayerInstanceLink_ *pNext; 90 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 91 PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; 92 } VkLayerInstanceLink; 93 94 /* 95 * When creating the device chain the loader needs to pass 96 * down information about it's device structure needed at 97 * the end of the chain. Passing the data via the 98 * VkLayerDeviceInfo avoids issues with finding the 99 * exact instance being used. 100 */ 101 typedef struct VkLayerDeviceInfo_ { 102 void *device_info; 103 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 104 } VkLayerDeviceInfo; 105 106 typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, 107 void *object); 108 typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, 109 void *object); 110 111 typedef struct { 112 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO 113 const void *pNext; 114 VkLayerFunction function; 115 union { 116 VkLayerInstanceLink *pLayerInfo; 117 PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; 118 } u; 119 } VkLayerInstanceCreateInfo; 120 121 typedef struct VkLayerDeviceLink_ { 122 struct VkLayerDeviceLink_ *pNext; 123 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 124 PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; 125 } VkLayerDeviceLink; 126 127 typedef struct { 128 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO 129 const void *pNext; 130 VkLayerFunction function; 131 union { 132 VkLayerDeviceLink *pLayerInfo; 133 PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; 134 } u; 135 } VkLayerDeviceCreateInfo; 136 137 #ifdef __cplusplus 138 extern "C" { 139 #endif 140 141 VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); 142 143 typedef enum VkChainType { 144 VK_CHAIN_TYPE_UNKNOWN = 0, 145 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, 146 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, 147 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, 148 } VkChainType; 149 150 typedef struct VkChainHeader { 151 VkChainType type; 152 uint32_t version; 153 uint32_t size; 154 } VkChainHeader; 155 156 typedef struct VkEnumerateInstanceExtensionPropertiesChain { 157 VkChainHeader header; 158 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, 159 VkExtensionProperties *); 160 const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; 161 162 #if defined(__cplusplus) CallDownVkEnumerateInstanceExtensionPropertiesChain163 inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { 164 return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); 165 } 166 #endif 167 } VkEnumerateInstanceExtensionPropertiesChain; 168 169 typedef struct VkEnumerateInstanceLayerPropertiesChain { 170 VkChainHeader header; 171 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); 172 const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; 173 174 #if defined(__cplusplus) CallDownVkEnumerateInstanceLayerPropertiesChain175 inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { 176 return pfnNextLayer(pNextLink, pPropertyCount, pProperties); 177 } 178 #endif 179 } VkEnumerateInstanceLayerPropertiesChain; 180 181 typedef struct VkEnumerateInstanceVersionChain { 182 VkChainHeader header; 183 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); 184 const struct VkEnumerateInstanceVersionChain *pNextLink; 185 186 #if defined(__cplusplus) CallDownVkEnumerateInstanceVersionChain187 inline VkResult CallDown(uint32_t *pApiVersion) const { 188 return pfnNextLayer(pNextLink, pApiVersion); 189 } 190 #endif 191 } VkEnumerateInstanceVersionChain; 192 193 #ifdef __cplusplus 194 } 195 #endif 196