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
51typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
52
53// Version negotiation values
54typedef enum VkNegotiateLayerStructType {
55    LAYER_NEGOTIATE_UNINTIALIZED = 0,
56    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
57} VkNegotiateLayerStructType;
58
59// Version negotiation structures
60typedef 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
70typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
71
72// Function prototype for unknown physical device extension command
73typedef 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 */
83typedef enum VkLayerFunction_ {
84    VK_LAYER_LINK_INFO = 0,
85    VK_LOADER_DATA_CALLBACK = 1,
86    VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2,
87    VK_LOADER_FEATURES = 3,
88} VkLayerFunction;
89
90typedef struct VkLayerInstanceLink_ {
91    struct VkLayerInstanceLink_ *pNext;
92    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
93    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
94} VkLayerInstanceLink;
95
96/*
97 * When creating the device chain the loader needs to pass
98 * down information about it's device structure needed at
99 * the end of the chain. Passing the data via the
100 * VkLayerDeviceInfo avoids issues with finding the
101 * exact instance being used.
102 */
103typedef struct VkLayerDeviceInfo_ {
104    void *device_info;
105    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
106} VkLayerDeviceInfo;
107
108typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
109        void *object);
110typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
111        void *object);
112typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
113						      const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
114typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
115
116typedef enum VkLoaderFeastureFlagBits {
117    VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001,
118} VkLoaderFlagBits;
119typedef VkFlags VkLoaderFeatureFlags;
120
121typedef struct {
122    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
123    const void *pNext;
124    VkLayerFunction function;
125    union {
126        VkLayerInstanceLink *pLayerInfo;
127        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
128        struct {
129	        PFN_vkLayerCreateDevice pfnLayerCreateDevice;
130	        PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
131	    } layerDevice;
132        VkLoaderFeatureFlags loaderFeatures;
133    } u;
134} VkLayerInstanceCreateInfo;
135
136typedef struct VkLayerDeviceLink_ {
137    struct VkLayerDeviceLink_ *pNext;
138    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
139    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
140} VkLayerDeviceLink;
141
142typedef struct {
143    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
144    const void *pNext;
145    VkLayerFunction function;
146    union {
147        VkLayerDeviceLink *pLayerInfo;
148        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
149    } u;
150} VkLayerDeviceCreateInfo;
151
152#ifdef __cplusplus
153extern "C" {
154#endif
155
156VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
157
158typedef enum VkChainType {
159    VK_CHAIN_TYPE_UNKNOWN = 0,
160    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
161    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
162    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
163} VkChainType;
164
165typedef struct VkChainHeader {
166    VkChainType type;
167    uint32_t version;
168    uint32_t size;
169} VkChainHeader;
170
171typedef struct VkEnumerateInstanceExtensionPropertiesChain {
172    VkChainHeader header;
173    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
174                                      VkExtensionProperties *);
175    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
176
177#if defined(__cplusplus)
178    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
179        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
180    }
181#endif
182} VkEnumerateInstanceExtensionPropertiesChain;
183
184typedef struct VkEnumerateInstanceLayerPropertiesChain {
185    VkChainHeader header;
186    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
187    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
188
189#if defined(__cplusplus)
190    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
191        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
192    }
193#endif
194} VkEnumerateInstanceLayerPropertiesChain;
195
196typedef struct VkEnumerateInstanceVersionChain {
197    VkChainHeader header;
198    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
199    const struct VkEnumerateInstanceVersionChain *pNextLink;
200
201#if defined(__cplusplus)
202    inline VkResult CallDown(uint32_t *pApiVersion) const {
203        return pfnNextLayer(pNextLink, pApiVersion);
204    }
205#endif
206} VkEnumerateInstanceVersionChain;
207
208#ifdef __cplusplus
209}
210#endif
211