Skip to content

S
swiftshader
Commit e3eb327e by Caio Marcelo de Oliveira Filho Committed by Caio Oliveira
Options

Convert Vulkan headers from CRLF to LF endings

In 34c59c9b ("Update Vulkan headers to version 1.1.111") the Vulkan Headers were inadvertently converted to CRLF line endings, convert them back. Bug: b/157893908 Change-Id: I4ce4edd941e55cbfb7172c8d6041bf9e9a0254d3 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/45430Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Kokoro-Result: kokoro <noreply+kokoro@google.com>
parent 0711869b
Showing with 1694 additions and 1694 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,
VK_ICD_WSI_PLATFORM_HEADLESS, VK_ICD_WSI_PLATFORM_HEADLESS,
VK_ICD_WSI_PLATFORM_METAL, VK_ICD_WSI_PLATFORM_METAL,
} VkIcdWsiPlatform; } VkIcdWsiPlatform;
typedef struct { typedef struct {
VkIcdWsiPlatform platform; VkIcdWsiPlatform platform;
} VkIcdSurfaceBase; } VkIcdSurfaceBase;
#ifdef VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_MIR_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
MirConnection *connection; MirConnection *connection;
MirSurface *mirSurface; MirSurface *mirSurface;
} VkIcdSurfaceMir; } VkIcdSurfaceMir;
#endif // VK_USE_PLATFORM_MIR_KHR #endif // VK_USE_PLATFORM_MIR_KHR
#ifdef VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
struct wl_display *display; struct wl_display *display;
struct wl_surface *surface; struct wl_surface *surface;
} VkIcdSurfaceWayland; } VkIcdSurfaceWayland;
#endif // VK_USE_PLATFORM_WAYLAND_KHR #endif // VK_USE_PLATFORM_WAYLAND_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
HINSTANCE hinstance; HINSTANCE hinstance;
HWND hwnd; HWND hwnd;
} VkIcdSurfaceWin32; } VkIcdSurfaceWin32;
#endif // VK_USE_PLATFORM_WIN32_KHR #endif // VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
xcb_connection_t *connection; xcb_connection_t *connection;
xcb_window_t window; xcb_window_t window;
} VkIcdSurfaceXcb; } VkIcdSurfaceXcb;
#endif // VK_USE_PLATFORM_XCB_KHR #endif // VK_USE_PLATFORM_XCB_KHR
#ifdef VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
Display *dpy; Display *dpy;
Window window; Window window;
} VkIcdSurfaceXlib; } VkIcdSurfaceXlib;
#endif // VK_USE_PLATFORM_XLIB_KHR #endif // VK_USE_PLATFORM_XLIB_KHR
#ifdef VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
struct ANativeWindow *window; struct ANativeWindow *window;
} VkIcdSurfaceAndroid; } VkIcdSurfaceAndroid;
#endif // VK_USE_PLATFORM_ANDROID_KHR #endif // VK_USE_PLATFORM_ANDROID_KHR
#ifdef VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_MACOS_MVK
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
const void *pView; const void *pView;
} VkIcdSurfaceMacOS; } VkIcdSurfaceMacOS;
#endif // VK_USE_PLATFORM_MACOS_MVK #endif // VK_USE_PLATFORM_MACOS_MVK
#ifdef VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_IOS_MVK
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
const void *pView; const void *pView;
} VkIcdSurfaceIOS; } VkIcdSurfaceIOS;
#endif // VK_USE_PLATFORM_IOS_MVK #endif // VK_USE_PLATFORM_IOS_MVK
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
VkDisplayModeKHR displayMode; VkDisplayModeKHR displayMode;
uint32_t planeIndex; uint32_t planeIndex;
uint32_t planeStackIndex; uint32_t planeStackIndex;
VkSurfaceTransformFlagBitsKHR transform; VkSurfaceTransformFlagBitsKHR transform;
float globalAlpha; float globalAlpha;
VkDisplayPlaneAlphaFlagBitsKHR alphaMode; VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
VkExtent2D imageExtent; VkExtent2D imageExtent;
} VkIcdSurfaceDisplay; } VkIcdSurfaceDisplay;
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
} VkIcdSurfaceHeadless; } VkIcdSurfaceHeadless;
#ifdef VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_METAL_EXT
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
const CAMetalLayer *pLayer; const CAMetalLayer *pLayer;
} VkIcdSurfaceMetal; } VkIcdSurfaceMetal;
#endif // VK_USE_PLATFORM_METAL_EXT #endif // VK_USE_PLATFORM_METAL_EXT
#endif // VKICD_H #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,
VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2 VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2
} VkLayerFunction; } VkLayerFunction;
typedef struct VkLayerInstanceLink_ { typedef struct VkLayerInstanceLink_ {
struct VkLayerInstanceLink_ *pNext; struct VkLayerInstanceLink_ *pNext;
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
} VkLayerInstanceLink; } VkLayerInstanceLink;
/* /*
* When creating the device chain the loader needs to pass * When creating the device chain the loader needs to pass
* down information about it's device structure needed at * down information about it's device structure needed at
* the end of the chain. Passing the data via the * the end of the chain. Passing the data via the
* VkLayerDeviceInfo avoids issues with finding the * VkLayerDeviceInfo avoids issues with finding the
* exact instance being used. * exact instance being used.
*/ */
typedef struct VkLayerDeviceInfo_ { typedef struct VkLayerDeviceInfo_ {
void *device_info; void *device_info;
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
} VkLayerDeviceInfo; } VkLayerDeviceInfo;
typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
void *object); void *object);
typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
void *object); void *object);
typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
typedef struct { typedef struct {
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
const void *pNext; const void *pNext;
VkLayerFunction function; VkLayerFunction function;
union { union {
VkLayerInstanceLink *pLayerInfo; VkLayerInstanceLink *pLayerInfo;
PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
struct { struct {
PFN_vkLayerCreateDevice pfnLayerCreateDevice; PFN_vkLayerCreateDevice pfnLayerCreateDevice;
PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
} layerDevice; } layerDevice;
} u; } u;
} VkLayerInstanceCreateInfo; } VkLayerInstanceCreateInfo;
typedef struct VkLayerDeviceLink_ { typedef struct VkLayerDeviceLink_ {
struct VkLayerDeviceLink_ *pNext; struct VkLayerDeviceLink_ *pNext;
PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
} VkLayerDeviceLink; } VkLayerDeviceLink;
typedef struct { typedef struct {
VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
const void *pNext; const void *pNext;
VkLayerFunction function; VkLayerFunction function;
union { union {
VkLayerDeviceLink *pLayerInfo; VkLayerDeviceLink *pLayerInfo;
PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
} u; } u;
} VkLayerDeviceCreateInfo; } VkLayerDeviceCreateInfo;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
typedef enum VkChainType { typedef enum VkChainType {
VK_CHAIN_TYPE_UNKNOWN = 0, VK_CHAIN_TYPE_UNKNOWN = 0,
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
} VkChainType; } VkChainType;
typedef struct VkChainHeader { typedef struct VkChainHeader {
VkChainType type; VkChainType type;
uint32_t version; uint32_t version;
uint32_t size; uint32_t size;
} VkChainHeader; } VkChainHeader;
typedef struct VkEnumerateInstanceExtensionPropertiesChain { typedef struct VkEnumerateInstanceExtensionPropertiesChain {
VkChainHeader header; VkChainHeader header;
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
VkExtensionProperties *); VkExtensionProperties *);
const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
#if defined(__cplusplus) #if defined(__cplusplus)
inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
} }
#endif #endif
} VkEnumerateInstanceExtensionPropertiesChain; } VkEnumerateInstanceExtensionPropertiesChain;
typedef struct VkEnumerateInstanceLayerPropertiesChain { typedef struct VkEnumerateInstanceLayerPropertiesChain {
VkChainHeader header; VkChainHeader header;
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
#if defined(__cplusplus) #if defined(__cplusplus)
inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
return pfnNextLayer(pNextLink, pPropertyCount, pProperties); return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
} }
#endif #endif
} VkEnumerateInstanceLayerPropertiesChain; } VkEnumerateInstanceLayerPropertiesChain;
typedef struct VkEnumerateInstanceVersionChain { typedef struct VkEnumerateInstanceVersionChain {
VkChainHeader header; VkChainHeader header;
VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
const struct VkEnumerateInstanceVersionChain *pNextLink; const struct VkEnumerateInstanceVersionChain *pNextLink;
#if defined(__cplusplus) #if defined(__cplusplus)
inline VkResult CallDown(uint32_t *pApiVersion) const { inline VkResult CallDown(uint32_t *pApiVersion) const {
return pfnNextLayer(pNextLink, pApiVersion); return pfnNextLayer(pNextLink, pApiVersion);
} }
#endif #endif
} VkEnumerateInstanceVersionChain; } VkEnumerateInstanceVersionChain;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
include/vulkan/vk_platform.h
// //
// File: vk_platform.h // File: vk_platform.h
// //
/* /*
** Copyright (c) 2014-2020 The Khronos Group Inc. ** Copyright (c) 2014-2020 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-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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"
#include "vulkan_fuchsia_extras.h" #include "vulkan_fuchsia_extras.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_METAL_EXT
#include "vulkan_metal.h" #include "vulkan_metal.h"
#endif #endif
#ifdef VK_USE_PLATFORM_VI_NN #ifdef VK_USE_PLATFORM_VI_NN
#include "vulkan_vi.h" #include "vulkan_vi.h"
#endif #endif
#ifdef VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR
#include <wayland-client.h> #include <wayland-client.h>
#include "vulkan_wayland.h" #include "vulkan_wayland.h"
#endif #endif
#ifdef VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR
#include <windows.h> #include <windows.h>
#include "vulkan_win32.h" #include "vulkan_win32.h"
#endif #endif
#ifdef VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR
#include <xcb/xcb.h> #include <xcb/xcb.h>
#include "vulkan_xcb.h" #include "vulkan_xcb.h"
#endif #endif
#ifdef VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include "vulkan_xlib.h" #include "vulkan_xlib.h"
#endif #endif
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h> #include <X11/extensions/Xrandr.h>
#include "vulkan_xlib_xrandr.h" #include "vulkan_xlib_xrandr.h"
#endif #endif
#ifdef VK_USE_PLATFORM_GGP #ifdef VK_USE_PLATFORM_GGP
#include <ggp_c/vulkan_types.h> #include <ggp_c/vulkan_types.h>
#include "vulkan_ggp.h" #include "vulkan_ggp.h"
#endif #endif
#ifdef VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS
#include "vulkan_beta.h" #include "vulkan_beta.h"
#endif #endif
#endif // VULKAN_H_ #endif // VULKAN_H_
include/vulkan/vulkan_android.h
#ifndef VULKAN_ANDROID_H_ #ifndef VULKAN_ANDROID_H_
#define VULKAN_ANDROID_H_ 1 #define VULKAN_ANDROID_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_KHR_android_surface 1 #define VK_KHR_android_surface 1
struct ANativeWindow; 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 { typedef struct VkAndroidSurfaceCreateInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkAndroidSurfaceCreateFlagsKHR flags; VkAndroidSurfaceCreateFlagsKHR flags;
struct ANativeWindow* window; struct ANativeWindow* window;
} VkAndroidSurfaceCreateInfoKHR; } VkAndroidSurfaceCreateInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
VkInstance instance, VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #endif
#define VK_ANDROID_external_memory_android_hardware_buffer 1 #define VK_ANDROID_external_memory_android_hardware_buffer 1
struct AHardwareBuffer; struct AHardwareBuffer;
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
typedef struct VkAndroidHardwareBufferUsageANDROID { typedef struct VkAndroidHardwareBufferUsageANDROID {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
uint64_t androidHardwareBufferUsage; uint64_t androidHardwareBufferUsage;
} VkAndroidHardwareBufferUsageANDROID; } VkAndroidHardwareBufferUsageANDROID;
typedef struct VkAndroidHardwareBufferPropertiesANDROID { typedef struct VkAndroidHardwareBufferPropertiesANDROID {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
VkDeviceSize allocationSize; VkDeviceSize allocationSize;
uint32_t memoryTypeBits; uint32_t memoryTypeBits;
} VkAndroidHardwareBufferPropertiesANDROID; } VkAndroidHardwareBufferPropertiesANDROID;
typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
VkFormat format; VkFormat format;
uint64_t externalFormat; uint64_t externalFormat;
VkFormatFeatureFlags formatFeatures; VkFormatFeatureFlags formatFeatures;
VkComponentMapping samplerYcbcrConversionComponents; VkComponentMapping samplerYcbcrConversionComponents;
VkSamplerYcbcrModelConversion suggestedYcbcrModel; VkSamplerYcbcrModelConversion suggestedYcbcrModel;
VkSamplerYcbcrRange suggestedYcbcrRange; VkSamplerYcbcrRange suggestedYcbcrRange;
VkChromaLocation suggestedXChromaOffset; VkChromaLocation suggestedXChromaOffset;
VkChromaLocation suggestedYChromaOffset; VkChromaLocation suggestedYChromaOffset;
} VkAndroidHardwareBufferFormatPropertiesANDROID; } VkAndroidHardwareBufferFormatPropertiesANDROID;
typedef struct VkImportAndroidHardwareBufferInfoANDROID { typedef struct VkImportAndroidHardwareBufferInfoANDROID {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
struct AHardwareBuffer* buffer; struct AHardwareBuffer* buffer;
} VkImportAndroidHardwareBufferInfoANDROID; } VkImportAndroidHardwareBufferInfoANDROID;
typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkDeviceMemory memory; VkDeviceMemory memory;
} VkMemoryGetAndroidHardwareBufferInfoANDROID; } VkMemoryGetAndroidHardwareBufferInfoANDROID;
typedef struct VkExternalFormatANDROID { typedef struct VkExternalFormatANDROID {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
uint64_t externalFormat; uint64_t externalFormat;
} VkExternalFormatANDROID; } VkExternalFormatANDROID;
typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
VkDevice device, VkDevice device,
const struct AHardwareBuffer* buffer, const struct AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties); VkAndroidHardwareBufferPropertiesANDROID* pProperties);
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
VkDevice device, VkDevice device,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
struct AHardwareBuffer** pBuffer); struct AHardwareBuffer** pBuffer);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_FUCHSIA_imagepipe_surface 1 #define VK_FUCHSIA_imagepipe_surface 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 #define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" #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 #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
VkInstance instance, VkInstance instance,
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
include/vulkan/vulkan_ggp.h
#ifndef VULKAN_GGP_H_ #ifndef VULKAN_GGP_H_
#define VULKAN_GGP_H_ 1 #define VULKAN_GGP_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_GGP_stream_descriptor_surface 1 #define VK_GGP_stream_descriptor_surface 1
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1 #define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface" #define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
typedef struct VkStreamDescriptorSurfaceCreateInfoGGP { typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkStreamDescriptorSurfaceCreateFlagsGGP flags; VkStreamDescriptorSurfaceCreateFlagsGGP flags;
GgpStreamDescriptor streamDescriptor; GgpStreamDescriptor streamDescriptor;
} VkStreamDescriptorSurfaceCreateInfoGGP; } VkStreamDescriptorSurfaceCreateInfoGGP;
typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP( VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
VkInstance instance, VkInstance instance,
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #endif
#define VK_GGP_frame_token 1 #define VK_GGP_frame_token 1
#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1 #define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1
#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token" #define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
typedef struct VkPresentFrameTokenGGP { typedef struct VkPresentFrameTokenGGP {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
GgpFrameToken frameToken; GgpFrameToken frameToken;
} VkPresentFrameTokenGGP; } VkPresentFrameTokenGGP;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_MVK_ios_surface 1 #define VK_MVK_ios_surface 1
#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 #define VK_MVK_IOS_SURFACE_SPEC_VERSION 2
#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" #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 #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
VkInstance instance, VkInstance instance,
const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_MVK_macos_surface 1 #define VK_MVK_macos_surface 1
#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" #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 #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
VkInstance instance, VkInstance instance,
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
include/vulkan/vulkan_metal.h
#ifndef VULKAN_METAL_H_ #ifndef VULKAN_METAL_H_
#define VULKAN_METAL_H_ 1 #define VULKAN_METAL_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_EXT_metal_surface 1 #define VK_EXT_metal_surface 1
#ifdef __OBJC__ #ifdef __OBJC__
@class CAMetalLayer; @class CAMetalLayer;
#else #else
typedef void CAMetalLayer; typedef void CAMetalLayer;
#endif #endif
#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1 #define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface" #define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
typedef VkFlags VkMetalSurfaceCreateFlagsEXT; typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
typedef struct VkMetalSurfaceCreateInfoEXT { typedef struct VkMetalSurfaceCreateInfoEXT {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkMetalSurfaceCreateFlagsEXT flags; VkMetalSurfaceCreateFlagsEXT flags;
const CAMetalLayer* pLayer; const CAMetalLayer* pLayer;
} VkMetalSurfaceCreateInfoEXT; } VkMetalSurfaceCreateInfoEXT;
typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
VkInstance instance, VkInstance instance,
const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_NN_vi_surface 1 #define VK_NN_vi_surface 1
#define VK_NN_VI_SURFACE_SPEC_VERSION 1 #define VK_NN_VI_SURFACE_SPEC_VERSION 1
#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" #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 #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
VkInstance instance, VkInstance instance,
const VkViSurfaceCreateInfoNN* pCreateInfo, const VkViSurfaceCreateInfoNN* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_KHR_wayland_surface 1 #define VK_KHR_wayland_surface 1
#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" #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 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 VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
VkInstance instance, VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex, uint32_t queueFamilyIndex,
struct wl_display* display); struct wl_display* display);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_KHR_win32_surface 1 #define VK_KHR_win32_surface 1
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" #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 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 VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
VkInstance instance, VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex); uint32_t queueFamilyIndex);
#endif #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 { typedef struct VkImportMemoryWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType; VkExternalMemoryHandleTypeFlagBits handleType;
HANDLE handle; HANDLE handle;
LPCWSTR name; LPCWSTR name;
} VkImportMemoryWin32HandleInfoKHR; } VkImportMemoryWin32HandleInfoKHR;
typedef struct VkExportMemoryWin32HandleInfoKHR { typedef struct VkExportMemoryWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess; DWORD dwAccess;
LPCWSTR name; LPCWSTR name;
} VkExportMemoryWin32HandleInfoKHR; } VkExportMemoryWin32HandleInfoKHR;
typedef struct VkMemoryWin32HandlePropertiesKHR { typedef struct VkMemoryWin32HandlePropertiesKHR {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
uint32_t memoryTypeBits; uint32_t memoryTypeBits;
} VkMemoryWin32HandlePropertiesKHR; } VkMemoryWin32HandlePropertiesKHR;
typedef struct VkMemoryGetWin32HandleInfoKHR { typedef struct VkMemoryGetWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkDeviceMemory memory; VkDeviceMemory memory;
VkExternalMemoryHandleTypeFlagBits handleType; VkExternalMemoryHandleTypeFlagBits handleType;
} VkMemoryGetWin32HandleInfoKHR; } VkMemoryGetWin32HandleInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); 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_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
VkDevice device, VkDevice device,
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle); HANDLE* pHandle);
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
VkDevice device, VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType, VkExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle, HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
#endif #endif
#define VK_KHR_win32_keyed_mutex 1 #define VK_KHR_win32_keyed_mutex 1
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
uint32_t acquireCount; uint32_t acquireCount;
const VkDeviceMemory* pAcquireSyncs; const VkDeviceMemory* pAcquireSyncs;
const uint64_t* pAcquireKeys; const uint64_t* pAcquireKeys;
const uint32_t* pAcquireTimeouts; const uint32_t* pAcquireTimeouts;
uint32_t releaseCount; uint32_t releaseCount;
const VkDeviceMemory* pReleaseSyncs; const VkDeviceMemory* pReleaseSyncs;
const uint64_t* pReleaseKeys; const uint64_t* pReleaseKeys;
} VkWin32KeyedMutexAcquireReleaseInfoKHR; } VkWin32KeyedMutexAcquireReleaseInfoKHR;
#define VK_KHR_external_semaphore_win32 1 #define VK_KHR_external_semaphore_win32 1
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 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_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
typedef struct VkImportSemaphoreWin32HandleInfoKHR { typedef struct VkImportSemaphoreWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkSemaphore semaphore; VkSemaphore semaphore;
VkSemaphoreImportFlags flags; VkSemaphoreImportFlags flags;
VkExternalSemaphoreHandleTypeFlagBits handleType; VkExternalSemaphoreHandleTypeFlagBits handleType;
HANDLE handle; HANDLE handle;
LPCWSTR name; LPCWSTR name;
} VkImportSemaphoreWin32HandleInfoKHR; } VkImportSemaphoreWin32HandleInfoKHR;
typedef struct VkExportSemaphoreWin32HandleInfoKHR { typedef struct VkExportSemaphoreWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess; DWORD dwAccess;
LPCWSTR name; LPCWSTR name;
} VkExportSemaphoreWin32HandleInfoKHR; } VkExportSemaphoreWin32HandleInfoKHR;
typedef struct VkD3D12FenceSubmitInfoKHR { typedef struct VkD3D12FenceSubmitInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
uint32_t waitSemaphoreValuesCount; uint32_t waitSemaphoreValuesCount;
const uint64_t* pWaitSemaphoreValues; const uint64_t* pWaitSemaphoreValues;
uint32_t signalSemaphoreValuesCount; uint32_t signalSemaphoreValuesCount;
const uint64_t* pSignalSemaphoreValues; const uint64_t* pSignalSemaphoreValues;
} VkD3D12FenceSubmitInfoKHR; } VkD3D12FenceSubmitInfoKHR;
typedef struct VkSemaphoreGetWin32HandleInfoKHR { typedef struct VkSemaphoreGetWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkSemaphore semaphore; VkSemaphore semaphore;
VkExternalSemaphoreHandleTypeFlagBits handleType; VkExternalSemaphoreHandleTypeFlagBits handleType;
} VkSemaphoreGetWin32HandleInfoKHR; } VkSemaphoreGetWin32HandleInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
VkDevice device, VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
VkDevice device, VkDevice device,
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle); HANDLE* pHandle);
#endif #endif
#define VK_KHR_external_fence_win32 1 #define VK_KHR_external_fence_win32 1
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
typedef struct VkImportFenceWin32HandleInfoKHR { typedef struct VkImportFenceWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkFence fence; VkFence fence;
VkFenceImportFlags flags; VkFenceImportFlags flags;
VkExternalFenceHandleTypeFlagBits handleType; VkExternalFenceHandleTypeFlagBits handleType;
HANDLE handle; HANDLE handle;
LPCWSTR name; LPCWSTR name;
} VkImportFenceWin32HandleInfoKHR; } VkImportFenceWin32HandleInfoKHR;
typedef struct VkExportFenceWin32HandleInfoKHR { typedef struct VkExportFenceWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess; DWORD dwAccess;
LPCWSTR name; LPCWSTR name;
} VkExportFenceWin32HandleInfoKHR; } VkExportFenceWin32HandleInfoKHR;
typedef struct VkFenceGetWin32HandleInfoKHR { typedef struct VkFenceGetWin32HandleInfoKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkFence fence; VkFence fence;
VkExternalFenceHandleTypeFlagBits handleType; VkExternalFenceHandleTypeFlagBits handleType;
} VkFenceGetWin32HandleInfoKHR; } VkFenceGetWin32HandleInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
VkDevice device, VkDevice device,
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
VkDevice device, VkDevice device,
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle); HANDLE* pHandle);
#endif #endif
#define VK_NV_external_memory_win32 1 #define VK_NV_external_memory_win32 1
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
typedef struct VkImportMemoryWin32HandleInfoNV { typedef struct VkImportMemoryWin32HandleInfoNV {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkExternalMemoryHandleTypeFlagsNV handleType; VkExternalMemoryHandleTypeFlagsNV handleType;
HANDLE handle; HANDLE handle;
} VkImportMemoryWin32HandleInfoNV; } VkImportMemoryWin32HandleInfoNV;
typedef struct VkExportMemoryWin32HandleInfoNV { typedef struct VkExportMemoryWin32HandleInfoNV {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
const SECURITY_ATTRIBUTES* pAttributes; const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess; DWORD dwAccess;
} VkExportMemoryWin32HandleInfoNV; } VkExportMemoryWin32HandleInfoNV;
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
VkDevice device, VkDevice device,
VkDeviceMemory memory, VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType, VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE* pHandle); HANDLE* pHandle);
#endif #endif
#define VK_NV_win32_keyed_mutex 1 #define VK_NV_win32_keyed_mutex 1
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
uint32_t acquireCount; uint32_t acquireCount;
const VkDeviceMemory* pAcquireSyncs; const VkDeviceMemory* pAcquireSyncs;
const uint64_t* pAcquireKeys; const uint64_t* pAcquireKeys;
const uint32_t* pAcquireTimeoutMilliseconds; const uint32_t* pAcquireTimeoutMilliseconds;
uint32_t releaseCount; uint32_t releaseCount;
const VkDeviceMemory* pReleaseSyncs; const VkDeviceMemory* pReleaseSyncs;
const uint64_t* pReleaseKeys; const uint64_t* pReleaseKeys;
} VkWin32KeyedMutexAcquireReleaseInfoNV; } VkWin32KeyedMutexAcquireReleaseInfoNV;
#define VK_EXT_full_screen_exclusive 1 #define VK_EXT_full_screen_exclusive 1
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive" #define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
typedef enum VkFullScreenExclusiveEXT { typedef enum VkFullScreenExclusiveEXT {
VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkFullScreenExclusiveEXT; } VkFullScreenExclusiveEXT;
typedef struct VkSurfaceFullScreenExclusiveInfoEXT { typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
VkFullScreenExclusiveEXT fullScreenExclusive; VkFullScreenExclusiveEXT fullScreenExclusive;
} VkSurfaceFullScreenExclusiveInfoEXT; } VkSurfaceFullScreenExclusiveInfoEXT;
typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;
VkBool32 fullScreenExclusiveSupported; VkBool32 fullScreenExclusiveSupported;
} VkSurfaceCapabilitiesFullScreenExclusiveEXT; } VkSurfaceCapabilitiesFullScreenExclusiveEXT;
typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT { typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
HMONITOR hmonitor; HMONITOR hmonitor;
} VkSurfaceFullScreenExclusiveWin32InfoEXT; } VkSurfaceFullScreenExclusiveWin32InfoEXT;
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 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_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(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); typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT( VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
uint32_t* pPresentModeCount, uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes); VkPresentModeKHR* pPresentModes);
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT( VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
VkDevice device, VkDevice device,
VkSwapchainKHR swapchain); VkSwapchainKHR swapchain);
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT( VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
VkDevice device, VkDevice device,
VkSwapchainKHR swapchain); VkSwapchainKHR swapchain);
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
VkDevice device, VkDevice device,
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkDeviceGroupPresentModeFlagsKHR* pModes); VkDeviceGroupPresentModeFlagsKHR* pModes);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_KHR_xcb_surface 1 #define VK_KHR_xcb_surface 1
#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 #define VK_KHR_XCB_SURFACE_SPEC_VERSION 6
#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" #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 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 VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
VkInstance instance, VkInstance instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex, uint32_t queueFamilyIndex,
xcb_connection_t* connection, xcb_connection_t* connection,
xcb_visualid_t visual_id); xcb_visualid_t visual_id);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_KHR_xlib_surface 1 #define VK_KHR_xlib_surface 1
#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6
#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" #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 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 VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
VkInstance instance, VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex, uint32_t queueFamilyIndex,
Display* dpy, Display* dpy,
VisualID visualID); VisualID visualID);
#endif #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
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright (c) 2015-2020 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.
** **
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define VK_EXT_acquire_xlib_display 1 #define VK_EXT_acquire_xlib_display 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" #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