Home | History | Annotate | Download | only in vulkan 
      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 // Definition for VkLayerDispatchTable and VkLayerInstanceDispatchTable now appear in externally generated header
     39 #include "vk_layer_dispatch_table.h"
     40 
     41 #define MAX_NUM_UNKNOWN_EXTS 250
     42 
     43  // Loader-Layer version negotiation API.  Versions add the following features:
     44  //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
     45  //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
     46  //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
     47  //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
     48 #define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
     49 #define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
     50 
     51 #define VK_CURRENT_CHAIN_VERSION 1
     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 } VkChainType;
    148 
    149 typedef struct VkChainHeader {
    150     VkChainType type;
    151     uint32_t version;
    152     uint32_t size;
    153 } VkChainHeader;
    154 
    155 typedef struct VkEnumerateInstanceExtensionPropertiesChain {
    156     VkChainHeader header;
    157     VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
    158                                       VkExtensionProperties *);
    159     const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
    160 
    161 #if defined(__cplusplus)
    162     inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
    163         return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
    164     }
    165 #endif
    166 } VkEnumerateInstanceExtensionPropertiesChain;
    167 
    168 typedef struct VkEnumerateInstanceLayerPropertiesChain {
    169     VkChainHeader header;
    170     VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
    171     const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
    172 
    173 #if defined(__cplusplus)
    174     inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
    175         return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
    176     }
    177 #endif
    178 } VkEnumerateInstanceLayerPropertiesChain;
    179 
    180 #ifdef __cplusplus
    181 }
    182 #endif
    183