Skip to content

S
swiftshader
Commit 34c59c9b by Nicolas Capens Committed by Nicolas Capens
Options

Update Vulkan headers to version 1.1.111

https://github.com/KhronosGroup/Vulkan-Headers revision 4d49d5ced52e1ba1fe5d403726ad8291c1266d97 tag v1.1.111 Bug: b/129792032 Change-Id: Ia4e581160c4612aca44971390b31c7a497b98cfc Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/32968 Presubmit-Ready: Nicolas Capens <nicolascapens@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarBen Clayton <bclayton@google.com> Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
parent d354537f
Showing with 1671 additions and 1553 deletions
include/vulkan/vk_icd.h
// //
// File: vk_icd.h // File: vk_icd.h
// //
/* /*
* Copyright (c) 2015-2016 The Khronos Group Inc. * Copyright (c) 2015-2016 The Khronos Group Inc.
* Copyright (c) 2015-2016 Valve Corporation * Copyright (c) 2015-2016 Valve Corporation
* Copyright (c) 2015-2016 LunarG, Inc. * Copyright (c) 2015-2016 LunarG, Inc.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
* *
*/ */
#ifndef VKICD_H #ifndef VKICD_H
#define VKICD_H #define VKICD_H
#include "vulkan.h" #include "vulkan.h"
#include <stdbool.h> #include <stdbool.h>
// Loader-ICD version negotiation API. Versions add the following features: // Loader-ICD version negotiation API. Versions add the following features:
// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr // Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr
// or vk_icdNegotiateLoaderICDInterfaceVersion. // or vk_icdNegotiateLoaderICDInterfaceVersion.
// Version 1 - Add support for vk_icdGetInstanceProcAddr. // Version 1 - Add support for vk_icdGetInstanceProcAddr.
// Version 2 - Add Loader/ICD Interface version negotiation // Version 2 - Add Loader/ICD Interface version negotiation
// via vk_icdNegotiateLoaderICDInterfaceVersion. // via vk_icdNegotiateLoaderICDInterfaceVersion.
// Version 3 - Add ICD creation/destruction of KHR_surface objects. // Version 3 - Add ICD creation/destruction of KHR_surface objects.
// Version 4 - Add unknown physical device extension qyering via // Version 4 - Add unknown physical device extension qyering via
// vk_icdGetPhysicalDeviceProcAddr. // vk_icdGetPhysicalDeviceProcAddr.
// Version 5 - Tells ICDs that the loader is now paying attention to the // Version 5 - Tells ICDs that the loader is now paying attention to the
// application version of Vulkan passed into the ApplicationInfo // application version of Vulkan passed into the ApplicationInfo
// structure during vkCreateInstance. This will tell the ICD // structure during vkCreateInstance. This will tell the ICD
// that if the loader is older, it should automatically fail a // that if the loader is older, it should automatically fail a
// call for any API version > 1.0. Otherwise, the loader will // call for any API version > 1.0. Otherwise, the loader will
// manually determine if it can support the expected version. // manually determine if it can support the expected version.
#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5 #define CURRENT_LOADER_ICD_INTERFACE_VERSION 5
#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 #define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 #define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this // This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
// file directly, it won't be found. // file directly, it won't be found.
#ifndef PFN_GetPhysicalDeviceProcAddr #ifndef PFN_GetPhysicalDeviceProcAddr
typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
#endif #endif
/* /*
* The ICD must reserve space for a pointer for the loader's dispatch * The ICD must reserve space for a pointer for the loader's dispatch
* table, at the start of <each object>. * table, at the start of <each object>.
* The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
*/ */
#define ICD_LOADER_MAGIC 0x01CDC0DE #define ICD_LOADER_MAGIC 0x01CDC0DE
typedef union { typedef union {
uintptr_t loaderMagic; uintptr_t loaderMagic;
void *loaderData; void *loaderData;
} VK_LOADER_DATA; } VK_LOADER_DATA;
static inline void set_loader_magic_value(void *pNewObject) { static inline void set_loader_magic_value(void *pNewObject) {
VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
loader_info->loaderMagic = ICD_LOADER_MAGIC; loader_info->loaderMagic = ICD_LOADER_MAGIC;
} }
static inline bool valid_loader_magic_value(void *pNewObject) { static inline bool valid_loader_magic_value(void *pNewObject) {
const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
} }
/* /*
* Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
* contains the platform-specific connection and surface information. * contains the platform-specific connection and surface information.
*/ */
typedef enum { typedef enum {
VK_ICD_WSI_PLATFORM_MIR, VK_ICD_WSI_PLATFORM_MIR,
VK_ICD_WSI_PLATFORM_WAYLAND, VK_ICD_WSI_PLATFORM_WAYLAND,
VK_ICD_WSI_PLATFORM_WIN32, VK_ICD_WSI_PLATFORM_WIN32,
VK_ICD_WSI_PLATFORM_XCB, VK_ICD_WSI_PLATFORM_XCB,
VK_ICD_WSI_PLATFORM_XLIB, VK_ICD_WSI_PLATFORM_XLIB,
VK_ICD_WSI_PLATFORM_ANDROID, VK_ICD_WSI_PLATFORM_ANDROID,
VK_ICD_WSI_PLATFORM_MACOS, VK_ICD_WSI_PLATFORM_MACOS,
VK_ICD_WSI_PLATFORM_IOS, VK_ICD_WSI_PLATFORM_IOS,
VK_ICD_WSI_PLATFORM_DISPLAY VK_ICD_WSI_PLATFORM_DISPLAY,
} VkIcdWsiPlatform; VK_ICD_WSI_PLATFORM_HEADLESS
} VkIcdWsiPlatform;
typedef struct {
VkIcdWsiPlatform platform; typedef struct {
} VkIcdSurfaceBase; VkIcdWsiPlatform platform;
} VkIcdSurfaceBase;
#ifdef VK_USE_PLATFORM_MIR_KHR
typedef struct { #ifdef VK_USE_PLATFORM_MIR_KHR
VkIcdSurfaceBase base; typedef struct {
MirConnection *connection; VkIcdSurfaceBase base;
MirSurface *mirSurface; MirConnection *connection;
} VkIcdSurfaceMir; MirSurface *mirSurface;
#endif // VK_USE_PLATFORM_MIR_KHR } VkIcdSurfaceMir;
#endif // VK_USE_PLATFORM_MIR_KHR
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
typedef struct { #ifdef VK_USE_PLATFORM_WAYLAND_KHR
VkIcdSurfaceBase base; typedef struct {
struct wl_display *display; VkIcdSurfaceBase base;
struct wl_surface *surface; struct wl_display *display;
} VkIcdSurfaceWayland; struct wl_surface *surface;
#endif // VK_USE_PLATFORM_WAYLAND_KHR } VkIcdSurfaceWayland;
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
typedef struct { #ifdef VK_USE_PLATFORM_WIN32_KHR
VkIcdSurfaceBase base; typedef struct {
HINSTANCE hinstance; VkIcdSurfaceBase base;
HWND hwnd; HINSTANCE hinstance;
} VkIcdSurfaceWin32; HWND hwnd;
#endif // VK_USE_PLATFORM_WIN32_KHR } VkIcdSurfaceWin32;
#endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_XCB_KHR
typedef struct { #ifdef VK_USE_PLATFORM_XCB_KHR
VkIcdSurfaceBase base; typedef struct {
xcb_connection_t *connection; VkIcdSurfaceBase base;
xcb_window_t window; xcb_connection_t *connection;
} VkIcdSurfaceXcb; xcb_window_t window;
#endif // VK_USE_PLATFORM_XCB_KHR } VkIcdSurfaceXcb;
#endif // VK_USE_PLATFORM_XCB_KHR
#ifdef VK_USE_PLATFORM_XLIB_KHR
typedef struct { #ifdef VK_USE_PLATFORM_XLIB_KHR
VkIcdSurfaceBase base; typedef struct {
Display *dpy; VkIcdSurfaceBase base;
Window window; Display *dpy;
} VkIcdSurfaceXlib; Window window;
#endif // VK_USE_PLATFORM_XLIB_KHR } VkIcdSurfaceXlib;
#endif // VK_USE_PLATFORM_XLIB_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR
typedef struct { #ifdef VK_USE_PLATFORM_ANDROID_KHR
VkIcdSurfaceBase base; typedef struct {
struct ANativeWindow *window; VkIcdSurfaceBase base;
} VkIcdSurfaceAndroid; struct ANativeWindow *window;
#endif // VK_USE_PLATFORM_ANDROID_KHR } VkIcdSurfaceAndroid;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_MACOS_MVK
typedef struct { #ifdef VK_USE_PLATFORM_MACOS_MVK
VkIcdSurfaceBase base; typedef struct {
const void *pView; VkIcdSurfaceBase base;
} VkIcdSurfaceMacOS; const void *pView;
#endif // VK_USE_PLATFORM_MACOS_MVK } VkIcdSurfaceMacOS;
#endif // VK_USE_PLATFORM_MACOS_MVK
#ifdef VK_USE_PLATFORM_IOS_MVK
typedef struct { #ifdef VK_USE_PLATFORM_IOS_MVK
VkIcdSurfaceBase base; typedef struct {
const void *pView; VkIcdSurfaceBase base;
} VkIcdSurfaceIOS; const void *pView;
#endif // VK_USE_PLATFORM_IOS_MVK } VkIcdSurfaceIOS;
#endif // VK_USE_PLATFORM_IOS_MVK
typedef struct {
VkIcdSurfaceBase base; typedef struct {
VkDisplayModeKHR displayMode; VkIcdSurfaceBase base;
uint32_t planeIndex; VkDisplayModeKHR displayMode;
uint32_t planeStackIndex; uint32_t planeIndex;
VkSurfaceTransformFlagBitsKHR transform; uint32_t planeStackIndex;
float globalAlpha; VkSurfaceTransformFlagBitsKHR transform;
VkDisplayPlaneAlphaFlagBitsKHR alphaMode; float globalAlpha;
VkExtent2D imageExtent; VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
} VkIcdSurfaceDisplay; VkExtent2D imageExtent;
} VkIcdSurfaceDisplay;
#endif // VKICD_H
typedef struct {
VkIcdSurfaceBase base;
} VkIcdSurfaceHeadless;
#endif // VKICD_H
include/vulkan/vk_layer.h
// //
// File: vk_layer.h // File: vk_layer.h
// //
/* /*
* Copyright (c) 2015-2017 The Khronos Group Inc. * Copyright (c) 2015-2017 The Khronos Group Inc.
* Copyright (c) 2015-2017 Valve Corporation * Copyright (c) 2015-2017 Valve Corporation
* Copyright (c) 2015-2017 LunarG, Inc. * Copyright (c) 2015-2017 LunarG, Inc.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
* *
*/ */
/* Need to define dispatch table /* Need to define dispatch table
* Core struct can then have ptr to dispatch table at the top * Core struct can then have ptr to dispatch table at the top
* Along with object ptrs for current and next OBJ * Along with object ptrs for current and next OBJ
*/ */
#pragma once #pragma once
#include "vulkan.h" #include "vulkan.h"
#if defined(__GNUC__) && __GNUC__ >= 4 #if defined(__GNUC__) && __GNUC__ >= 4
#define VK_LAYER_EXPORT __attribute__((visibility("default"))) #define VK_LAYER_EXPORT __attribute__((visibility("default")))
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
#define VK_LAYER_EXPORT __attribute__((visibility("default"))) #define VK_LAYER_EXPORT __attribute__((visibility("default")))
#else #else
#define VK_LAYER_EXPORT #define VK_LAYER_EXPORT
#endif #endif
#define MAX_NUM_UNKNOWN_EXTS 250 #define MAX_NUM_UNKNOWN_EXTS 250
// Loader-Layer version negotiation API. Versions add the following features: // Loader-Layer version negotiation API. Versions add the following features:
// Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr
// or vk_icdNegotiateLoaderLayerInterfaceVersion. // or vk_icdNegotiateLoaderLayerInterfaceVersion.
// Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and
// vk_icdNegotiateLoaderLayerInterfaceVersion. // vk_icdNegotiateLoaderLayerInterfaceVersion.
#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 #define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 #define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
#define VK_CURRENT_CHAIN_VERSION 1 #define VK_CURRENT_CHAIN_VERSION 1
// Typedef for use in the interfaces below // Typedef for use in the interfaces below
typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
// Version negotiation values // Version negotiation values
typedef enum VkNegotiateLayerStructType { typedef enum VkNegotiateLayerStructType {
LAYER_NEGOTIATE_UNINTIALIZED = 0, LAYER_NEGOTIATE_UNINTIALIZED = 0,
LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
} VkNegotiateLayerStructType; } VkNegotiateLayerStructType;
// Version negotiation structures // Version negotiation structures
typedef struct VkNegotiateLayerInterface { typedef struct VkNegotiateLayerInterface {
VkNegotiateLayerStructType sType; VkNegotiateLayerStructType sType;
void *pNext; void *pNext;
uint32_t loaderLayerInterfaceVersion; uint32_t loaderLayerInterfaceVersion;
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
} VkNegotiateLayerInterface; } VkNegotiateLayerInterface;
// Version negotiation functions // Version negotiation functions
typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
// Function prototype for unknown physical device extension command // Function prototype for unknown physical device extension command
typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// CreateInstance and CreateDevice support structures // CreateInstance and CreateDevice support structures
/* Sub type of structure for instance and device loader ext of CreateInfo. /* Sub type of structure for instance and device loader ext of CreateInfo.
* When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
* or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
* then VkLayerFunction indicates struct type pointed to by pNext * then VkLayerFunction indicates struct type pointed to by pNext
*/ */
typedef enum VkLayerFunction_ { typedef enum VkLayerFunction_ {
VK_LAYER_LINK_INFO = 0, VK_LAYER_LINK_INFO = 0,
VK_LOADER_DATA_CALLBACK = 1 VK_LOADER_DATA_CALLBACK = 1,
} VkLayerFunction; VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2
} VkLayerFunction;
typedef struct VkLayerInstanceLink_ {
struct VkLayerInstanceLink_ *pNext; typedef struct VkLayerInstanceLink_ {
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; struct VkLayerInstanceLink_ *pNext;
PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
} VkLayerInstanceLink; PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
} VkLayerInstanceLink;
/*
* When creating the device chain the loader needs to pass /*
* down information about it's device structure needed at * When creating the device chain the loader needs to pass
* the end of the chain. Passing the data via the * down information about it's device structure needed at
* VkLayerDeviceInfo avoids issues with finding the * the end of the chain. Passing the data via the
* exact instance being used. * VkLayerDeviceInfo avoids issues with finding the
*/ * exact instance being used.
typedef struct VkLayerDeviceInfo_ { */
void *device_info; typedef struct VkLayerDeviceInfo_ {
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; void *device_info;
} VkLayerDeviceInfo; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
} VkLayerDeviceInfo;
typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
void *object); typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, void *object);
void *object); typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
void *object);
typedef struct { typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
const void *pNext; typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
VkLayerFunction function; typedef struct {
union { VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
VkLayerInstanceLink *pLayerInfo; const void *pNext;
PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; VkLayerFunction function;
} u; union {
} VkLayerInstanceCreateInfo; VkLayerInstanceLink *pLayerInfo;
PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
typedef struct VkLayerDeviceLink_ { struct {
struct VkLayerDeviceLink_ *pNext; PFN_vkLayerCreateDevice pfnLayerCreateDevice;
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; } layerDevice;
} VkLayerDeviceLink; } u;
} VkLayerInstanceCreateInfo;
typedef struct {
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO typedef struct VkLayerDeviceLink_ {
const void *pNext; struct VkLayerDeviceLink_ *pNext;
VkLayerFunction function; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
union { PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
VkLayerDeviceLink *pLayerInfo; } VkLayerDeviceLink;
PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
} u; typedef struct {
} VkLayerDeviceCreateInfo; VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
const void *pNext;
#ifdef __cplusplus VkLayerFunction function;
extern "C" { union {
#endif VkLayerDeviceLink *pLayerInfo;
PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); } u;
} VkLayerDeviceCreateInfo;
typedef enum VkChainType {
VK_CHAIN_TYPE_UNKNOWN = 0, #ifdef __cplusplus
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, extern "C" {
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, #endif
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
} VkChainType; VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
typedef struct VkChainHeader { typedef enum VkChainType {
VkChainType type; VK_CHAIN_TYPE_UNKNOWN = 0,
uint32_t version; VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
uint32_t size; VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
} VkChainHeader; VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
} VkChainType;
typedef struct VkEnumerateInstanceExtensionPropertiesChain {
VkChainHeader header; typedef struct VkChainHeader {
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, VkChainType type;
VkExtensionProperties *); uint32_t version;
const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; uint32_t size;
} VkChainHeader;
#if defined(__cplusplus)
inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { typedef struct VkEnumerateInstanceExtensionPropertiesChain {
return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); VkChainHeader header;
} VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
#endif VkExtensionProperties *);
} VkEnumerateInstanceExtensionPropertiesChain; const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
typedef struct VkEnumerateInstanceLayerPropertiesChain { #if defined(__cplusplus)
VkChainHeader header; inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; }
#endif
#if defined(__cplusplus) } VkEnumerateInstanceExtensionPropertiesChain;
inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
return pfnNextLayer(pNextLink, pPropertyCount, pProperties); typedef struct VkEnumerateInstanceLayerPropertiesChain {
} VkChainHeader header;
#endif VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
} VkEnumerateInstanceLayerPropertiesChain; const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
typedef struct VkEnumerateInstanceVersionChain { #if defined(__cplusplus)
VkChainHeader header; inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
const struct VkEnumerateInstanceVersionChain *pNextLink; }
#endif
#if defined(__cplusplus) } VkEnumerateInstanceLayerPropertiesChain;
inline VkResult CallDown(uint32_t *pApiVersion) const {
return pfnNextLayer(pNextLink, pApiVersion); typedef struct VkEnumerateInstanceVersionChain {
} VkChainHeader header;
#endif VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
} VkEnumerateInstanceVersionChain; const struct VkEnumerateInstanceVersionChain *pNextLink;
#ifdef __cplusplus #if defined(__cplusplus)
} inline VkResult CallDown(uint32_t *pApiVersion) const {
#endif return pfnNextLayer(pNextLink, pApiVersion);
}
#endif
} VkEnumerateInstanceVersionChain;
#ifdef __cplusplus
}
#endif
include/vulkan/vk_platform.h
// //
// File: vk_platform.h // File: vk_platform.h
// //
/* /*
** Copyright (c) 2014-2017 The Khronos Group Inc. ** Copyright (c) 2014-2017 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
#ifndef VK_PLATFORM_H_ #ifndef VK_PLATFORM_H_
#define VK_PLATFORM_H_ #define VK_PLATFORM_H_
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif // __cplusplus #endif // __cplusplus
/* /*
*************************************************************************************************** ***************************************************************************************************
* Platform-specific directives and type declarations * Platform-specific directives and type declarations
*************************************************************************************************** ***************************************************************************************************
*/ */
/* Platform-specific calling convention macros. /* Platform-specific calling convention macros.
* *
* Platforms should define these so that Vulkan clients call Vulkan commands * Platforms should define these so that Vulkan clients call Vulkan commands
* with the same calling conventions that the Vulkan implementation expects. * with the same calling conventions that the Vulkan implementation expects.
* *
* VKAPI_ATTR - Placed before the return type in function declarations. * VKAPI_ATTR - Placed before the return type in function declarations.
* Useful for C++11 and GCC/Clang-style function attribute syntax. * Useful for C++11 and GCC/Clang-style function attribute syntax.
* VKAPI_CALL - Placed after the return type in function declarations. * VKAPI_CALL - Placed after the return type in function declarations.
* Useful for MSVC-style calling convention syntax. * Useful for MSVC-style calling convention syntax.
* VKAPI_PTR - Placed between the '(' and '*' in function pointer types. * VKAPI_PTR - Placed between the '(' and '*' in function pointer types.
* *
* Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void);
* Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
*/ */
#if defined(_WIN32) #if defined(_WIN32)
// On Windows, Vulkan commands use the stdcall convention // On Windows, Vulkan commands use the stdcall convention
#define VKAPI_ATTR #define VKAPI_ATTR
#define VKAPI_CALL __stdcall #define VKAPI_CALL __stdcall
#define VKAPI_PTR VKAPI_CALL #define VKAPI_PTR VKAPI_CALL
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
#error "Vulkan isn't supported for the 'armeabi' NDK ABI" #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
// On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
// calling convention, i.e. float parameters are passed in registers. This // calling convention, i.e. float parameters are passed in registers. This
// is true even if the rest of the application passes floats on the stack, // is true even if the rest of the application passes floats on the stack,
// as it does by default when compiling for the armeabi-v7a NDK ABI. // as it does by default when compiling for the armeabi-v7a NDK ABI.
#define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
#define VKAPI_CALL #define VKAPI_CALL
#define VKAPI_PTR VKAPI_ATTR #define VKAPI_PTR VKAPI_ATTR
#else #else
// On other platforms, use the default calling convention // On other platforms, use the default calling convention
#define VKAPI_ATTR #define VKAPI_ATTR
#define VKAPI_CALL #define VKAPI_CALL
#define VKAPI_PTR #define VKAPI_PTR
#endif #endif
#include <stddef.h> #include <stddef.h>
#if !defined(VK_NO_STDINT_H) #if !defined(VK_NO_STDINT_H)
#if defined(_MSC_VER) && (_MSC_VER < 1600) #if defined(_MSC_VER) && (_MSC_VER < 1600)
typedef signed __int8 int8_t; typedef signed __int8 int8_t;
typedef unsigned __int8 uint8_t; typedef unsigned __int8 uint8_t;
typedef signed __int16 int16_t; typedef signed __int16 int16_t;
typedef unsigned __int16 uint16_t; typedef unsigned __int16 uint16_t;
typedef signed __int32 int32_t; typedef signed __int32 int32_t;
typedef unsigned __int32 uint32_t; typedef unsigned __int32 uint32_t;
typedef signed __int64 int64_t; typedef signed __int64 int64_t;
typedef unsigned __int64 uint64_t; typedef unsigned __int64 uint64_t;
#else #else
#include <stdint.h> #include <stdint.h>
#endif #endif
#endif // !defined(VK_NO_STDINT_H) #endif // !defined(VK_NO_STDINT_H)
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif // __cplusplus #endif // __cplusplus
#endif #endif
include/vulkan/vk_sdk_platform.h
// //
// File: vk_sdk_platform.h // File: vk_sdk_platform.h
// //
/* /*
* Copyright (c) 2015-2016 The Khronos Group Inc. * Copyright (c) 2015-2016 The Khronos Group Inc.
* Copyright (c) 2015-2016 Valve Corporation * Copyright (c) 2015-2016 Valve Corporation
* Copyright (c) 2015-2016 LunarG, Inc. * Copyright (c) 2015-2016 LunarG, Inc.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef VK_SDK_PLATFORM_H #ifndef VK_SDK_PLATFORM_H
#define VK_SDK_PLATFORM_H #define VK_SDK_PLATFORM_H
#if defined(_WIN32) #if defined(_WIN32)
#define NOMINMAX #define NOMINMAX
#ifndef __cplusplus #ifndef __cplusplus
#undef inline #undef inline
#define inline __inline #define inline __inline
#endif // __cplusplus #endif // __cplusplus
#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) #if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
// C99: // C99:
// Microsoft didn't implement C99 in Visual Studio; but started adding it with // Microsoft didn't implement C99 in Visual Studio; but started adding it with
// VS2013. However, VS2013 still didn't have snprintf(). The following is a // VS2013. However, VS2013 still didn't have snprintf(). The following is a
// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the // work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
// "CMakeLists.txt" file). // "CMakeLists.txt" file).
// NOTE: This is fixed in Visual Studio 2015. // NOTE: This is fixed in Visual Studio 2015.
#define snprintf _snprintf #define snprintf _snprintf
#endif #endif
#define strdup _strdup #define strdup _strdup
#endif // _WIN32 #endif // _WIN32
// Check for noexcept support using clang, with fallback to Windows or GCC version numbers // Check for noexcept support using clang, with fallback to Windows or GCC version numbers
#ifndef NOEXCEPT #ifndef NOEXCEPT
#if defined(__clang__) #if defined(__clang__)
#if __has_feature(cxx_noexcept) #if __has_feature(cxx_noexcept)
#define HAS_NOEXCEPT #define HAS_NOEXCEPT
#endif #endif
#else #else
#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
#define HAS_NOEXCEPT #define HAS_NOEXCEPT
#else #else
#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS #if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
#define HAS_NOEXCEPT #define HAS_NOEXCEPT
#endif #endif
#endif #endif
#endif #endif
#ifdef HAS_NOEXCEPT #ifdef HAS_NOEXCEPT
#define NOEXCEPT noexcept #define NOEXCEPT noexcept
#else #else
#define NOEXCEPT #define NOEXCEPT
#endif #endif
#endif #endif
#endif // VK_SDK_PLATFORM_H #endif // VK_SDK_PLATFORM_H
include/vulkan/vulkan.h
#ifndef VULKAN_H_ #ifndef VULKAN_H_
#define VULKAN_H_ 1 #define VULKAN_H_ 1
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
#include "vk_platform.h" #include "vk_platform.h"
#include "vulkan_core.h" #include "vulkan_core.h"
#ifdef VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR
#include "vulkan_android.h" #include "vulkan_android.h"
#endif #endif
#ifdef VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_FUCHSIA
#include <zircon/types.h> #include <zircon/types.h>
#include "vulkan_fuchsia.h" #include "vulkan_fuchsia.h"
#endif #endif
#ifdef VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_IOS_MVK
#include "vulkan_ios.h" #include "vulkan_ios.h"
#endif #endif
#ifdef VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_MACOS_MVK
#include "vulkan_macos.h" #include "vulkan_macos.h"
#endif #endif
#ifdef VK_USE_PLATFORM_METAL_EXT
#ifdef VK_USE_PLATFORM_VI_NN #include "vulkan_metal.h"
#include "vulkan_vi.h" #endif
#endif
#ifdef VK_USE_PLATFORM_VI_NN
#include "vulkan_vi.h"
#ifdef VK_USE_PLATFORM_WAYLAND_KHR #endif
#include <wayland-client.h>
#include "vulkan_wayland.h"
#endif #ifdef VK_USE_PLATFORM_WAYLAND_KHR
#include <wayland-client.h>
#include "vulkan_wayland.h"
#ifdef VK_USE_PLATFORM_WIN32_KHR #endif
#include <windows.h>
#include "vulkan_win32.h"
#endif #ifdef VK_USE_PLATFORM_WIN32_KHR
#include <windows.h>
#include "vulkan_win32.h"
#ifdef VK_USE_PLATFORM_XCB_KHR #endif
#include <xcb/xcb.h>
#include "vulkan_xcb.h"
#endif #ifdef VK_USE_PLATFORM_XCB_KHR
#include <xcb/xcb.h>
#include "vulkan_xcb.h"
#ifdef VK_USE_PLATFORM_XLIB_KHR #endif
#include <X11/Xlib.h>
#include "vulkan_xlib.h"
#endif #ifdef VK_USE_PLATFORM_XLIB_KHR
#include <X11/Xlib.h>
#include "vulkan_xlib.h"
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT #endif
#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#include "vulkan_xlib_xrandr.h" #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
#endif #include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#endif // VULKAN_H_ #include "vulkan_xlib_xrandr.h"
#endif
#ifdef VK_USE_PLATFORM_GGP
#include <ggp_c/vulkan_types.h>
#include "vulkan_ggp.h"
#endif
#endif // VULKAN_H_
include/vulkan/vulkan.hpp
This source diff could not be displayed because it is too large. You can view the blob instead.
include/vulkan/vulkan_android.h
#ifndef VULKAN_ANDROID_H_ #ifndef VULKAN_ANDROID_H_
#define VULKAN_ANDROID_H_ 1 #define VULKAN_ANDROID_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_android_surface 1
struct ANativeWindow; #define VK_KHR_android_surface 1
struct ANativeWindow;
#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; typedef struct VkAndroidSurfaceCreateInfoKHR {
VkStructureType sType;
typedef struct VkAndroidSurfaceCreateInfoKHR { const void* pNext;
VkStructureType sType; VkAndroidSurfaceCreateFlagsKHR flags;
const void* pNext; struct ANativeWindow* window;
VkAndroidSurfaceCreateFlagsKHR flags; } VkAndroidSurfaceCreateInfoKHR;
struct ANativeWindow* window;
} VkAndroidSurfaceCreateInfoKHR; typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES
typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
VkInstance instance,
#ifndef VK_NO_PROTOTYPES const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( const VkAllocationCallbacks* pAllocator,
VkInstance instance, VkSurfaceKHR* pSurface);
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, #endif
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface);
#endif #define VK_ANDROID_external_memory_android_hardware_buffer 1
struct AHardwareBuffer;
#define VK_ANDROID_external_memory_android_hardware_buffer 1 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
struct AHardwareBuffer; #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
typedef struct VkAndroidHardwareBufferUsageANDROID {
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 VkStructureType sType;
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" void* pNext;
uint64_t androidHardwareBufferUsage;
typedef struct VkAndroidHardwareBufferUsageANDROID { } VkAndroidHardwareBufferUsageANDROID;
VkStructureType sType;
void* pNext; typedef struct VkAndroidHardwareBufferPropertiesANDROID {
uint64_t androidHardwareBufferUsage; VkStructureType sType;
} VkAndroidHardwareBufferUsageANDROID; void* pNext;
VkDeviceSize allocationSize;
typedef struct VkAndroidHardwareBufferPropertiesANDROID { uint32_t memoryTypeBits;
VkStructureType sType; } VkAndroidHardwareBufferPropertiesANDROID;
void* pNext;
VkDeviceSize allocationSize; typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
uint32_t memoryTypeBits; VkStructureType sType;
} VkAndroidHardwareBufferPropertiesANDROID; void* pNext;
VkFormat format;
typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { uint64_t externalFormat;
VkStructureType sType; VkFormatFeatureFlags formatFeatures;
void* pNext; VkComponentMapping samplerYcbcrConversionComponents;
VkFormat format; VkSamplerYcbcrModelConversion suggestedYcbcrModel;
uint64_t externalFormat; VkSamplerYcbcrRange suggestedYcbcrRange;
VkFormatFeatureFlags formatFeatures; VkChromaLocation suggestedXChromaOffset;
VkComponentMapping samplerYcbcrConversionComponents; VkChromaLocation suggestedYChromaOffset;
VkSamplerYcbcrModelConversion suggestedYcbcrModel; } VkAndroidHardwareBufferFormatPropertiesANDROID;
VkSamplerYcbcrRange suggestedYcbcrRange;
VkChromaLocation suggestedXChromaOffset; typedef struct VkImportAndroidHardwareBufferInfoANDROID {
VkChromaLocation suggestedYChromaOffset; VkStructureType sType;
} VkAndroidHardwareBufferFormatPropertiesANDROID; const void* pNext;
struct AHardwareBuffer* buffer;
typedef struct VkImportAndroidHardwareBufferInfoANDROID { } VkImportAndroidHardwareBufferInfoANDROID;
VkStructureType sType;
const void* pNext; typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
struct AHardwareBuffer* buffer; VkStructureType sType;
} VkImportAndroidHardwareBufferInfoANDROID; const void* pNext;
VkDeviceMemory memory;
typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { } VkMemoryGetAndroidHardwareBufferInfoANDROID;
VkStructureType sType;
const void* pNext; typedef struct VkExternalFormatANDROID {
VkDeviceMemory memory; VkStructureType sType;
} VkMemoryGetAndroidHardwareBufferInfoANDROID; void* pNext;
uint64_t externalFormat;
typedef struct VkExternalFormatANDROID { } VkExternalFormatANDROID;
VkStructureType sType;
void* pNext; typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
uint64_t externalFormat; typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
} VkExternalFormatANDROID;
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); VkDevice device,
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); const struct AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
VkDevice device, VkDevice device,
const struct AHardwareBuffer* buffer, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
VkAndroidHardwareBufferPropertiesANDROID* pProperties); struct AHardwareBuffer** pBuffer);
#endif
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
VkDevice device, #ifdef __cplusplus
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, }
struct AHardwareBuffer** pBuffer); #endif
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif
include/vulkan/vulkan_core.h
This source diff could not be displayed because it is too large. You can view the blob instead.
include/vulkan/vulkan_fuchsia.h
#ifndef VULKAN_FUCHSIA_H_ #ifndef VULKAN_FUCHSIA_H_
#define VULKAN_FUCHSIA_H_ 1 #define VULKAN_FUCHSIA_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_FUCHSIA_imagepipe_surface 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 #define VK_FUCHSIA_imagepipe_surface 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" #define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkImagePipeSurfaceCreateFlagsFUCHSIA flags;
VkImagePipeSurfaceCreateFlagsFUCHSIA flags; zx_handle_t imagePipeHandle;
zx_handle_t imagePipeHandle; } VkImagePipeSurfaceCreateInfoFUCHSIA;
} VkImagePipeSurfaceCreateInfoFUCHSIA;
typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator, #endif
VkSurfaceKHR* pSurface);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_ggp.h 0 → 100644
#ifndef VULKAN_GGP_H_
#define VULKAN_GGP_H_ 1
#ifdef __cplusplus
extern "C" {
#endif
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
/*
** This header is generated from the Khronos Vulkan XML API Registry.
**
*/
#define VK_GGP_stream_descriptor_surface 1
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
VkStructureType sType;
const void* pNext;
VkStreamDescriptorSurfaceCreateFlagsGGP flags;
GgpStreamDescriptor streamDescriptor;
} VkStreamDescriptorSurfaceCreateInfoGGP;
typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
VkInstance instance,
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface);
#endif
#define VK_GGP_frame_token 1
#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1
#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
typedef struct VkPresentFrameTokenGGP {
VkStructureType sType;
const void* pNext;
GgpFrameToken frameToken;
} VkPresentFrameTokenGGP;
#ifdef __cplusplus
}
#endif
#endif
include/vulkan/vulkan_ios.h
#ifndef VULKAN_IOS_H_ #ifndef VULKAN_IOS_H_
#define VULKAN_IOS_H_ 1 #define VULKAN_IOS_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_MVK_ios_surface 1
#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 #define VK_MVK_ios_surface 1
#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" #define VK_MVK_IOS_SURFACE_SPEC_VERSION 2
#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
typedef VkFlags VkIOSSurfaceCreateFlagsMVK; typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
typedef struct VkIOSSurfaceCreateInfoMVK {
typedef struct VkIOSSurfaceCreateInfoMVK { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkIOSSurfaceCreateFlagsMVK flags;
VkIOSSurfaceCreateFlagsMVK flags; const void* pView;
const void* pView; } VkIOSSurfaceCreateInfoMVK;
} VkIOSSurfaceCreateInfoMVK;
typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkIOSSurfaceCreateInfoMVK* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator, #endif
VkSurfaceKHR* pSurface);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_macos.h
#ifndef VULKAN_MACOS_H_ #ifndef VULKAN_MACOS_H_
#define VULKAN_MACOS_H_ 1 #define VULKAN_MACOS_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_MVK_macos_surface 1
#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 #define VK_MVK_macos_surface 1
#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
typedef struct VkMacOSSurfaceCreateInfoMVK {
typedef struct VkMacOSSurfaceCreateInfoMVK { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkMacOSSurfaceCreateFlagsMVK flags;
VkMacOSSurfaceCreateFlagsMVK flags; const void* pView;
const void* pView; } VkMacOSSurfaceCreateInfoMVK;
} VkMacOSSurfaceCreateInfoMVK;
typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator, #endif
VkSurfaceKHR* pSurface);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_mir.h → include/vulkan/vulkan_metal.h
#ifndef VULKAN_MIR_H_ #ifndef VULKAN_METAL_H_
#define VULKAN_MIR_H_ 1 #define VULKAN_METAL_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_mir_surface 1
#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 #define VK_EXT_metal_surface 1
#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
#ifdef __OBJC__
typedef VkFlags VkMirSurfaceCreateFlagsKHR; @class CAMetalLayer;
#else
typedef struct VkMirSurfaceCreateInfoKHR { typedef void CAMetalLayer;
VkStructureType sType; #endif
const void* pNext;
VkMirSurfaceCreateFlagsKHR flags; #define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
MirConnection* connection; #define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
MirSurface* mirSurface; typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
} VkMirSurfaceCreateInfoKHR; typedef struct VkMetalSurfaceCreateInfoEXT {
VkStructureType sType;
const void* pNext;
typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); VkMetalSurfaceCreateFlagsEXT flags;
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); const CAMetalLayer* pLayer;
} VkMetalSurfaceCreateInfoEXT;
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
VkInstance instance,
const VkMirSurfaceCreateInfoKHR* pCreateInfo, #ifndef VK_NO_PROTOTYPES
const VkAllocationCallbacks* pAllocator, VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
VkSurfaceKHR* pSurface); VkInstance instance,
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( const VkAllocationCallbacks* pAllocator,
VkPhysicalDevice physicalDevice, VkSurfaceKHR* pSurface);
uint32_t queueFamilyIndex, #endif
MirConnection* connection);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_vi.h
#ifndef VULKAN_VI_H_ #ifndef VULKAN_VI_H_
#define VULKAN_VI_H_ 1 #define VULKAN_VI_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_NN_vi_surface 1
#define VK_NN_VI_SURFACE_SPEC_VERSION 1 #define VK_NN_vi_surface 1
#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" #define VK_NN_VI_SURFACE_SPEC_VERSION 1
#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface"
typedef VkFlags VkViSurfaceCreateFlagsNN; typedef VkFlags VkViSurfaceCreateFlagsNN;
typedef struct VkViSurfaceCreateInfoNN {
typedef struct VkViSurfaceCreateInfoNN { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkViSurfaceCreateFlagsNN flags;
VkViSurfaceCreateFlagsNN flags; void* window;
void* window; } VkViSurfaceCreateInfoNN;
} VkViSurfaceCreateInfoNN;
typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( const VkViSurfaceCreateInfoNN* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkViSurfaceCreateInfoNN* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator, #endif
VkSurfaceKHR* pSurface);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_wayland.h
#ifndef VULKAN_WAYLAND_H_ #ifndef VULKAN_WAYLAND_H_
#define VULKAN_WAYLAND_H_ 1 #define VULKAN_WAYLAND_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_wayland_surface 1
#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 #define VK_KHR_wayland_surface 1
#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
typedef struct VkWaylandSurfaceCreateInfoKHR {
typedef struct VkWaylandSurfaceCreateInfoKHR { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkWaylandSurfaceCreateFlagsKHR flags;
VkWaylandSurfaceCreateFlagsKHR flags; struct wl_display* display;
struct wl_display* display; struct wl_surface* surface;
struct wl_surface* surface; } VkWaylandSurfaceCreateInfoKHR;
} VkWaylandSurfaceCreateInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
VkPhysicalDevice physicalDevice, struct wl_display* display);
uint32_t queueFamilyIndex, #endif
struct wl_display* display);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_win32.h
#ifndef VULKAN_WIN32_H_ #ifndef VULKAN_WIN32_H_
#define VULKAN_WIN32_H_ 1 #define VULKAN_WIN32_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_win32_surface 1
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 #define VK_KHR_win32_surface 1
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
typedef VkFlags VkWin32SurfaceCreateFlagsKHR; typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
typedef struct VkWin32SurfaceCreateInfoKHR {
typedef struct VkWin32SurfaceCreateInfoKHR { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkWin32SurfaceCreateFlagsKHR flags;
VkWin32SurfaceCreateFlagsKHR flags; HINSTANCE hinstance;
HINSTANCE hinstance; HWND hwnd;
HWND hwnd; } VkWin32SurfaceCreateInfoKHR;
} VkWin32SurfaceCreateInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice,
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( uint32_t queueFamilyIndex);
VkPhysicalDevice physicalDevice, #endif
uint32_t queueFamilyIndex);
#endif
#define VK_KHR_external_memory_win32 1
#define VK_KHR_external_memory_win32 1 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" typedef struct VkImportMemoryWin32HandleInfoKHR {
VkStructureType sType;
typedef struct VkImportMemoryWin32HandleInfoKHR { const void* pNext;
VkStructureType sType; VkExternalMemoryHandleTypeFlagBits handleType;
const void* pNext; HANDLE handle;
VkExternalMemoryHandleTypeFlagBits handleType; LPCWSTR name;
HANDLE handle; } VkImportMemoryWin32HandleInfoKHR;
LPCWSTR name;
} VkImportMemoryWin32HandleInfoKHR; typedef struct VkExportMemoryWin32HandleInfoKHR {
VkStructureType sType;
typedef struct VkExportMemoryWin32HandleInfoKHR { const void* pNext;
VkStructureType sType; const SECURITY_ATTRIBUTES* pAttributes;
const void* pNext; DWORD dwAccess;
const SECURITY_ATTRIBUTES* pAttributes; LPCWSTR name;
DWORD dwAccess; } VkExportMemoryWin32HandleInfoKHR;
LPCWSTR name;
} VkExportMemoryWin32HandleInfoKHR; typedef struct VkMemoryWin32HandlePropertiesKHR {
VkStructureType sType;
typedef struct VkMemoryWin32HandlePropertiesKHR { void* pNext;
VkStructureType sType; uint32_t memoryTypeBits;
void* pNext; } VkMemoryWin32HandlePropertiesKHR;
uint32_t memoryTypeBits;
} VkMemoryWin32HandlePropertiesKHR; typedef struct VkMemoryGetWin32HandleInfoKHR {
VkStructureType sType;
typedef struct VkMemoryGetWin32HandleInfoKHR { const void* pNext;
VkStructureType sType; VkDeviceMemory memory;
const void* pNext; VkExternalMemoryHandleTypeFlagBits handleType;
VkDeviceMemory memory; } VkMemoryGetWin32HandleInfoKHR;
VkExternalMemoryHandleTypeFlagBits handleType;
} VkMemoryGetWin32HandleInfoKHR; typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); #ifndef VK_NO_PROTOTYPES
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
VkDevice device,
#ifndef VK_NO_PROTOTYPES const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( HANDLE* pHandle);
VkDevice device,
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
HANDLE* pHandle); VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( HANDLE handle,
VkDevice device, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
VkExternalMemoryHandleTypeFlagBits handleType, #endif
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
#endif #define VK_KHR_win32_keyed_mutex 1
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
#define VK_KHR_win32_keyed_mutex 1 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" VkStructureType sType;
const void* pNext;
typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { uint32_t acquireCount;
VkStructureType sType; const VkDeviceMemory* pAcquireSyncs;
const void* pNext; const uint64_t* pAcquireKeys;
uint32_t acquireCount; const uint32_t* pAcquireTimeouts;
const VkDeviceMemory* pAcquireSyncs; uint32_t releaseCount;
const uint64_t* pAcquireKeys; const VkDeviceMemory* pReleaseSyncs;
const uint32_t* pAcquireTimeouts; const uint64_t* pReleaseKeys;
uint32_t releaseCount; } VkWin32KeyedMutexAcquireReleaseInfoKHR;
const VkDeviceMemory* pReleaseSyncs;
const uint64_t* pReleaseKeys;
} VkWin32KeyedMutexAcquireReleaseInfoKHR;
#define VK_KHR_external_semaphore_win32 1
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
#define VK_KHR_external_semaphore_win32 1 typedef struct VkImportSemaphoreWin32HandleInfoKHR {
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 VkStructureType sType;
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" const void* pNext;
VkSemaphore semaphore;
typedef struct VkImportSemaphoreWin32HandleInfoKHR { VkSemaphoreImportFlags flags;
VkStructureType sType; VkExternalSemaphoreHandleTypeFlagBits handleType;
const void* pNext; HANDLE handle;
VkSemaphore semaphore; LPCWSTR name;
VkSemaphoreImportFlags flags; } VkImportSemaphoreWin32HandleInfoKHR;
VkExternalSemaphoreHandleTypeFlagBits handleType;
HANDLE handle; typedef struct VkExportSemaphoreWin32HandleInfoKHR {
LPCWSTR name; VkStructureType sType;
} VkImportSemaphoreWin32HandleInfoKHR; const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes;
typedef struct VkExportSemaphoreWin32HandleInfoKHR { DWORD dwAccess;
VkStructureType sType; LPCWSTR name;
const void* pNext; } VkExportSemaphoreWin32HandleInfoKHR;
const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess; typedef struct VkD3D12FenceSubmitInfoKHR {
LPCWSTR name; VkStructureType sType;
} VkExportSemaphoreWin32HandleInfoKHR; const void* pNext;
uint32_t waitSemaphoreValuesCount;
typedef struct VkD3D12FenceSubmitInfoKHR { const uint64_t* pWaitSemaphoreValues;
VkStructureType sType; uint32_t signalSemaphoreValuesCount;
const void* pNext; const uint64_t* pSignalSemaphoreValues;
uint32_t waitSemaphoreValuesCount; } VkD3D12FenceSubmitInfoKHR;
const uint64_t* pWaitSemaphoreValues;
uint32_t signalSemaphoreValuesCount; typedef struct VkSemaphoreGetWin32HandleInfoKHR {
const uint64_t* pSignalSemaphoreValues; VkStructureType sType;
} VkD3D12FenceSubmitInfoKHR; const void* pNext;
VkSemaphore semaphore;
typedef struct VkSemaphoreGetWin32HandleInfoKHR { VkExternalSemaphoreHandleTypeFlagBits handleType;
VkStructureType sType; } VkSemaphoreGetWin32HandleInfoKHR;
const void* pNext;
VkSemaphore semaphore; typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
VkExternalSemaphoreHandleTypeFlagBits handleType; typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
} VkSemaphoreGetWin32HandleInfoKHR;
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); VkDevice device,
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
#ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( VkDevice device,
VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); HANDLE* pHandle);
#endif
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
VkDevice device,
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, #define VK_KHR_external_fence_win32 1
HANDLE* pHandle); #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
#endif #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
typedef struct VkImportFenceWin32HandleInfoKHR {
#define VK_KHR_external_fence_win32 1 VkStructureType sType;
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 const void* pNext;
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" VkFence fence;
VkFenceImportFlags flags;
typedef struct VkImportFenceWin32HandleInfoKHR { VkExternalFenceHandleTypeFlagBits handleType;
VkStructureType sType; HANDLE handle;
const void* pNext; LPCWSTR name;
VkFence fence; } VkImportFenceWin32HandleInfoKHR;
VkFenceImportFlags flags;
VkExternalFenceHandleTypeFlagBits handleType; typedef struct VkExportFenceWin32HandleInfoKHR {
HANDLE handle; VkStructureType sType;
LPCWSTR name; const void* pNext;
} VkImportFenceWin32HandleInfoKHR; const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess;
typedef struct VkExportFenceWin32HandleInfoKHR { LPCWSTR name;
VkStructureType sType; } VkExportFenceWin32HandleInfoKHR;
const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; typedef struct VkFenceGetWin32HandleInfoKHR {
DWORD dwAccess; VkStructureType sType;
LPCWSTR name; const void* pNext;
} VkExportFenceWin32HandleInfoKHR; VkFence fence;
VkExternalFenceHandleTypeFlagBits handleType;
typedef struct VkFenceGetWin32HandleInfoKHR { } VkFenceGetWin32HandleInfoKHR;
VkStructureType sType;
const void* pNext; typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
VkFence fence; typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
VkExternalFenceHandleTypeFlagBits handleType;
} VkFenceGetWin32HandleInfoKHR; #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
VkDevice device,
typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
#ifndef VK_NO_PROTOTYPES VkDevice device,
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
VkDevice device, HANDLE* pHandle);
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); #endif
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
VkDevice device, #define VK_NV_external_memory_win32 1
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
HANDLE* pHandle); #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
#endif typedef struct VkImportMemoryWin32HandleInfoNV {
VkStructureType sType;
#define VK_NV_external_memory_win32 1 const void* pNext;
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 VkExternalMemoryHandleTypeFlagsNV handleType;
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" HANDLE handle;
} VkImportMemoryWin32HandleInfoNV;
typedef struct VkImportMemoryWin32HandleInfoNV {
VkStructureType sType; typedef struct VkExportMemoryWin32HandleInfoNV {
const void* pNext; VkStructureType sType;
VkExternalMemoryHandleTypeFlagsNV handleType; const void* pNext;
HANDLE handle; const SECURITY_ATTRIBUTES* pAttributes;
} VkImportMemoryWin32HandleInfoNV; DWORD dwAccess;
} VkExportMemoryWin32HandleInfoNV;
typedef struct VkExportMemoryWin32HandleInfoNV {
VkStructureType sType; typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; #ifndef VK_NO_PROTOTYPES
DWORD dwAccess; VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
} VkExportMemoryWin32HandleInfoNV; VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); HANDLE* pHandle);
#endif
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
VkDevice device, #define VK_NV_win32_keyed_mutex 1
VkDeviceMemory memory, #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
VkExternalMemoryHandleTypeFlagsNV handleType, #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
HANDLE* pHandle); typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
#endif VkStructureType sType;
const void* pNext;
#define VK_NV_win32_keyed_mutex 1 uint32_t acquireCount;
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 const VkDeviceMemory* pAcquireSyncs;
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" const uint64_t* pAcquireKeys;
const uint32_t* pAcquireTimeoutMilliseconds;
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { uint32_t releaseCount;
VkStructureType sType; const VkDeviceMemory* pReleaseSyncs;
const void* pNext; const uint64_t* pReleaseKeys;
uint32_t acquireCount; } VkWin32KeyedMutexAcquireReleaseInfoNV;
const VkDeviceMemory* pAcquireSyncs;
const uint64_t* pAcquireKeys;
const uint32_t* pAcquireTimeoutMilliseconds;
uint32_t releaseCount; #define VK_EXT_full_screen_exclusive 1
const VkDeviceMemory* pReleaseSyncs; #define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 3
const uint64_t* pReleaseKeys; #define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
} VkWin32KeyedMutexAcquireReleaseInfoNV;
typedef enum VkFullScreenExclusiveEXT {
VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
#ifdef __cplusplus VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
} VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
#endif VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT,
#endif VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = (VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1),
VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkFullScreenExclusiveEXT;
typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
VkStructureType sType;
void* pNext;
VkFullScreenExclusiveEXT fullScreenExclusive;
} VkSurfaceFullScreenExclusiveInfoEXT;
typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
VkStructureType sType;
void* pNext;
VkBool32 fullScreenExclusiveSupported;
} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
VkStructureType sType;
const void* pNext;
HMONITOR hmonitor;
} VkSurfaceFullScreenExclusiveWin32InfoEXT;
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes);
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain);
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
VkDevice device,
VkSwapchainKHR swapchain);
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
VkDevice device,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkDeviceGroupPresentModeFlagsKHR* pModes);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/vulkan/vulkan_xcb.h
#ifndef VULKAN_XCB_H_ #ifndef VULKAN_XCB_H_
#define VULKAN_XCB_H_ 1 #define VULKAN_XCB_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_xcb_surface 1
#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 #define VK_KHR_xcb_surface 1
#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" #define VK_KHR_XCB_SURFACE_SPEC_VERSION 6
#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
typedef VkFlags VkXcbSurfaceCreateFlagsKHR; typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
typedef struct VkXcbSurfaceCreateInfoKHR {
typedef struct VkXcbSurfaceCreateInfoKHR { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkXcbSurfaceCreateFlagsKHR flags;
VkXcbSurfaceCreateFlagsKHR flags; xcb_connection_t* connection;
xcb_connection_t* connection; xcb_window_t window;
xcb_window_t window; } VkXcbSurfaceCreateInfoKHR;
} VkXcbSurfaceCreateInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
VkPhysicalDevice physicalDevice, xcb_connection_t* connection,
uint32_t queueFamilyIndex, xcb_visualid_t visual_id);
xcb_connection_t* connection, #endif
xcb_visualid_t visual_id);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_xlib.h
#ifndef VULKAN_XLIB_H_ #ifndef VULKAN_XLIB_H_
#define VULKAN_XLIB_H_ 1 #define VULKAN_XLIB_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_KHR_xlib_surface 1
#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 #define VK_KHR_xlib_surface 1
#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" #define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6
#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
typedef VkFlags VkXlibSurfaceCreateFlagsKHR; typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
typedef struct VkXlibSurfaceCreateInfoKHR {
typedef struct VkXlibSurfaceCreateInfoKHR { VkStructureType sType;
VkStructureType sType; const void* pNext;
const void* pNext; VkXlibSurfaceCreateFlagsKHR flags;
VkXlibSurfaceCreateFlagsKHR flags; Display* dpy;
Display* dpy; Window window;
Window window; } VkXlibSurfaceCreateInfoKHR;
} VkXlibSurfaceCreateInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
#ifndef VK_NO_PROTOTYPES VkInstance instance,
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
VkInstance instance, const VkAllocationCallbacks* pAllocator,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
VkPhysicalDevice physicalDevice, Display* dpy,
uint32_t queueFamilyIndex, VisualID visualID);
Display* dpy, #endif
VisualID visualID);
#endif #ifdef __cplusplus
}
#ifdef __cplusplus #endif
}
#endif #endif
#endif
include/vulkan/vulkan_xlib_xrandr.h
#ifndef VULKAN_XLIB_XRANDR_H_ #ifndef VULKAN_XLIB_XRANDR_H_
#define VULKAN_XLIB_XRANDR_H_ 1 #define VULKAN_XLIB_XRANDR_H_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2015-2018 The Khronos Group Inc. ** Copyright (c) 2015-2019 The Khronos Group Inc.
** **
** Licensed under the Apache License, Version 2.0 (the "License"); ** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. ** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at ** You may obtain a copy of the License at
** **
** http://www.apache.org/licenses/LICENSE-2.0 ** http://www.apache.org/licenses/LICENSE-2.0
** **
** Unless required by applicable law or agreed to in writing, software ** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, ** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and ** See the License for the specific language governing permissions and
** limitations under the License. ** limitations under the License.
*/ */
/* /*
** This header is generated from the Khronos Vulkan XML API Registry. ** This header is generated from the Khronos Vulkan XML API Registry.
** **
*/ */
#define VK_EXT_acquire_xlib_display 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 #define VK_EXT_acquire_xlib_display 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
Display* dpy, Display* dpy,
VkDisplayKHR display); VkDisplayKHR display);
VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
Display* dpy, Display* dpy,
RROutput rrOutput, RROutput rrOutput,
VkDisplayKHR* pDisplay); VkDisplayKHR* pDisplay);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment