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