include/vulkan/vk_layer.h

   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)
 163     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)
 175     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)
 187     inline VkResult CallDown(uint32_t *pApiVersion) const {
 188         return pfnNextLayer(pNextLink, pApiVersion);
 189     }
 190 #endif
 191 } VkEnumerateInstanceVersionChain;
 192
 193 #ifdef __cplusplus
 194 }
 195 #endif