Showing preview only (2,543K chars total). Download the full file or copy to clipboard to get everything.
Repository: mackron/vkbind
Branch: master
Commit: 445611b1f091
Files: 14
Total size: 2.4 MB
Directory structure:
gitextract_0dzrcb8h/
├── .gitignore
├── CMakeLists.txt
├── README.md
├── examples/
│ └── 01_Fundamentals/
│ ├── 01_Fundamentals.c
│ ├── 01_Fundamentals.cpp
│ ├── 01_Fundamentals_VFS.c
│ └── resources/
│ └── shaders/
│ ├── 01_Fundamentals.glsl.frag
│ └── 01_Fundamentals.glsl.vert
├── resources/
│ └── README.md
├── source/
│ ├── external/
│ │ ├── tinyxml2.cpp
│ │ └── tinyxml2.h
│ ├── vkbind_build.cpp
│ └── vkbind_template.h
└── vkbind.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.vscode
/#docs
/build
/examples/_build
/resources/vk.xml
/resources/video.xml
*.spirv
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.10)
# Extract version.
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/vkbind.h" VKBIND_VERSION_LINE REGEX "vkbind - v[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+")
string(REGEX MATCH "v([0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+)" _ ${VKBIND_VERSION_LINE})
set(VKBIND_VERSION ${CMAKE_MATCH_1})
message(STATUS "vkbind Version: ${VKBIND_VERSION}")
project(vkbind VERSION ${VKBIND_VERSION})
# Options
option(VKBIND_BUILD_EXAMPLES "Build vkbind examples" OFF)
option(VKBIND_BUILD_TESTS "Build vkbind tests" OFF)
option(VKBIND_BUILD_TOOLS "Build vkbind tools" OFF)
option(VKBIND_FORCE_CXX "Force compilation as C++" OFF)
option(VKBIND_FORCE_C89 "Force compilation as C89" OFF)
# Construct compiler options.
set(COMPILE_OPTIONS)
if(VKBIND_FORCE_CXX AND VKBIND_FORCE_C89)
message(FATAL_ERROR "VKBIND_FORCE_CXX and VKBIND_FORCE_C89 cannot be enabled at the same time.")
endif()
if(VKBIND_FORCE_CXX)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
message(STATUS "Compiling as C++ (GNU/Clang)")
list(APPEND COMPILE_OPTIONS -x c++)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
message(STATUS "Compiling as C++ (MSVC)")
list(APPEND COMPILE_OPTIONS /TP)
else()
message(WARNING "VKBIND_FORCE_CXX is enabled but the compiler does not support it. Ignoring.")
endif()
endif()
if(VKBIND_FORCE_C89)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
message(STATUS "Compiling as C89")
list(APPEND COMPILE_OPTIONS -std=c89)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
message(WARNING "MSVC does not support forcing C89. VKBIND_FORCE_C89 ignored.")
else()
message(WARNING "VKBIND_FORCE_C89 is enabled but the compiler does not support it. Ingoring.")
endif()
endif()
# Warnings
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
list(APPEND COMPILE_OPTIONS -Wall -Wextra -Wpedantic)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
#list(APPEND COMPILE_OPTIONS /W4)
endif()
# Link libraries
set(COMMON_LINK_LIBRARIES)
if (UNIX)
list(APPEND COMMON_LINK_LIBRARIES dl) # For dlopen(), etc. Most compilers will link to this by default, but some may not.
list(APPEND COMMON_LINK_LIBRARIES pthread) # Some compilers will not link to pthread by default so list it here just in case.
list(APPEND COMMON_LINK_LIBRARIES m)
# If we're compiling for 32-bit ARM we need to link to -latomic.
if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
list(APPEND COMMON_LINK_LIBRARIES atomic)
endif()
# X11 libraries for Vulkan surface support
find_package(PkgConfig QUIET)
if(PkgConfig_FOUND)
pkg_check_modules(X11 QUIET x11)
if(X11_FOUND)
list(APPEND COMMON_LINK_LIBRARIES ${X11_LIBRARIES})
message(STATUS "Found X11 libraries: ${X11_LIBRARIES}")
else()
# Fallback to standard X11 library
list(APPEND COMMON_LINK_LIBRARIES X11)
message(STATUS "Using fallback X11 library")
endif()
else()
# Fallback to standard X11 library
list(APPEND COMMON_LINK_LIBRARIES X11)
message(STATUS "Using fallback X11 library (no pkg-config)")
endif()
endif()
# Common interface
add_library(vkbind_common INTERFACE)
target_compile_options(vkbind_common INTERFACE ${COMPILE_OPTIONS})
target_link_libraries (vkbind_common INTERFACE ${COMMON_LINK_LIBRARIES})
# Examples
if (VKBIND_BUILD_EXAMPLES)
add_executable(01_Fundamentals examples/01_Fundamentals/01_Fundamentals.c)
target_link_libraries(01_Fundamentals vkbind_common)
endif()
# Tools
if (VKBIND_BUILD_TOOLS)
add_executable(vkbind_build source/vkbind_build.cpp)
target_link_libraries(vkbind_build vkbind_common)
#add_executable(vkbind_example_codegen source/vkbind_example_codegen.cpp)
#target_link_libraries(vkbind_example_codegen vkbind_common)
endif()
================================================
FILE: README.md
================================================
<h4 align="center">A single file Vulkan header and API loader.</h4>
<p align="center">
<a href="https://discord.gg/9vpqbjU"><img src="https://img.shields.io/discord/712952679415939085?label=discord&logo=discord&style=flat-square" alt="discord"></a>
<a href="https://fosstodon.org/@mackron"><img src="https://img.shields.io/mastodon/follow/109293691403797709?color=blue&domain=https%3A%2F%2Ffosstodon.org&label=mastodon&logo=mastodon&style=flat-square" alt="mastodon"></a>
</p>
vkbind is a Vulkan API loader and includes a full implementation of the Vulkan headers (auto-generated from the
Vulkan spec) so there's no need for the offical headers or SDK. Unlike the official headers, the platform-specific
sections are all contained within the same file.
Usage
=====
For platforms that statically expose all Vulkan APIs you can use vkbind like so:
```c
#define VKBIND_IMPLEMENTATION
#include "vkbind.h"
int main()
{
VkResult result = vkbInit(NULL);
if (result != VK_SUCCESS) {
printf("Failed to initialize vkbind.");
return -1;
}
// Do stuff here.
vkbUninit();
return 0;
}
```
For those platforms that do not statically expose all Vulkan APIs, you should do something like this:
```c
#define VKBIND_IMPLEMENTATION
#include "vkbind.h"
int main()
{
VkbAPI api;
VkResult result = vkbInit(&api);
if (result != VK_SUCCESS) {
printf("Failed to initialize vkbind.");
return -1;
}
// ... Create your Vulkan instance here (vkCreateInstance) ...
result = vkbInitInstanceAPI(instance, &api);
if (result != VK_SUCCESS) {
printf("Failed to initialize instance API.");
return -2;
}
result = vkbBindAPI(&api); // <-- Optional. Can call APIs directly like api.vkDestroyInstance().
if (result != VK_SUCCESS) {
printf("Failed to bind instance API.");
return -3;
}
// Do stuff here.
vkbUninit();
return 0;
}
```
The code above uses the `VkbAPI` structure which contains function pointers to all Vulkan APIs. The idea is that you
first initialize with `vkbInit()`, then call `vkbInitInstanceAPI()` after you've created your Vulkan instance. The
`VkbAPI` object will be filled with usable function pointers at this point (so long as they're supported by the platform).
In this example, the instance APIs are bound to global scope using `vkbBindAPI()`, however if you have multiple
instances running at the same time, you should instead invoke the functions directly from the `VkbAPI` object.
You can also initialize the `VkbAPI` object from a Vulkan device. This is optional, and is intended as an optimization
to avoid the cost of internal dispatching. To use this, you first initialize your `VkbAPI` object with
`vkbInitializeInstanceAPI()`, then call `vkbInitializeDeviceAPI()`, passing in the same `VkbAPI` object.
```c
VkbAPI api;
vkbInitInstanceAPI(instance, &api);
vkbInitDeviceAPI(device, &api);
vkbBindAPI(&api);
```
Examples
========
You can find some general Vulkan examples in the "examples" folder. The first example, 01_Fundamentals, is completely
flat and self contained in a single code file. This is unlike most of the other popular example projects out there which
are full of abstractions which make things too hard to follow. It covers most (all?) of the fundamentals any real Vulkan
program is going to need, and tries to explain how things like vertex layouts and descriptor sets interact with shaders
which I think is something other examples seem to overlook.
For practicality, future examples will not be entirely flat, but should still be significantly better than other
popular examples out there in terms of readability.
Note that shaders are pre-compiled with glslangValidator (GLSL to SPIR-V compiler) and embedded into a source file for
each example. This is just to avoid the need to worry about file IO for shaders and to focus on Vulkan itself.
License
=======
Public domain or MIT-0 (No Attribution). Choose whichever you prefer.
================================================
FILE: examples/01_Fundamentals/01_Fundamentals.c
================================================
/*
Demonstrates the fundamentals of the Vulkan API, including:
* Layers
* Extensions
* Physical and logical devices
* Queue families
* Swapchains
* Pipelines
* Vertex and index buffers
* Textures
* Uniform buffers
* Descriptor sets and how they connect to shaders
* Command buffers
This example is completely flat. The only library it uses is vkbind which is just a Vulkan API loader. The vkbind.h
file contains all of the Vulkan API declarations you need and is therefore a replacement for the official Vulkan
headers. Unlike the official Vulkan headers, vkbind includes all of the platform specific headers as well, as opposed
to keeping them all separate which is just unnecessary.
In a real-world program you would not want to write Vulkan code as it's written in this example. This example is void
of abstractions and functions in order to make it easier to see what's actually going on with Vulkan. The idea is to
show how to use Vulkan, not how to architecture your program. Also, resource cleanup is intentionally left out just to
keep things clean. A real program would probably want to clean everything up properly.
Currently only Windows is supported. This example will show you how to connect Vulkan to the Win32 windowing system
which is something almost all programs will want to do, so including that here is something I think is valuable. I will
look into adding X11 support at some point later on.
This example is focused on how to use the Vulkan API, not how to achieve specific graphics effects. If you're looking
for an example for lighting, PBR, etc. you'll need to look elsewhere.
Note that the program will close if you attempt to resize the window. This is due to the swapchain becoming invalid
since it's dimensions must always match that of the surface (the window, in this example). A normal program would want
to detect this and re-create the swapchain. The proper way to do this would be to wrap swapchain creation in a
function, but since we're keeping this example free of functions I'm just leaving it out. Once you understand how to
create a swapchain, which is demonstrated in this example, it should be easy enough for you to figure out how to handle
window resizes and re-create it.
*/
/*
The first thing to do is define which platforms you want to use. In our case we're only supporting Win32 for now. This
is done by #define-ing one of the `VK_USE_PLATFORM_*_KHR` symbols before the header. This is standard Vulkan and is
something you would need to do even if you were using the official headers instead of vkbind. This will enable some
platform-specific functionality that you'll need for displaying something in a window.
*/
#ifdef _WIN32
#define VK_USE_PLATFORM_WIN32_KHR
#else
#define VK_USE_PLATFORM_XLIB_KHR
#endif
/*
vkbind is a single file library. Use VKBIND_IMPLEMENTATION to define the implementation section. Make sure this is only
ever done in a single source file. All of the Vulkan symbols will be defined in vkbind.h, so no need for the official
Vulkan headers.
*/
#define VKBIND_IMPLEMENTATION
#include "../../vkbind.h"
/*
Vulkan requires shaders to be specified in a binary format called SPIR-V. Unfortunately I haven't been able to find a
good, small GLSL -> SPIR-V compiler library which would enable me to embed the shader code directly into this file,
which for demonstration purposes would be ideal. Instead I've pre-compiled the shader code with glslangValidator and
embedded the raw binary data into the source file below. Doing it this way means there's no need to worry about
distracting you with file IO. I'm keeping this in a separate file to just keep it separate from the focus of this
example which is the Vulkan API.
*/
#include "01_Fundamentals_VFS.c" /* <-- Compiled shader code is here. */
/*
This is the raw texture data that we'll be uploading to the Vulkan API when we create texture object. The texel
encoding we're using in this example is RGBA8 (or VK_FORMAT_R8G8B8A8_UNORM). We use this format for it's wide spread
support. This texture is a small 2x2 texture. We'll be using nearest-neighbor filtering (also known as point
filtering) when displaying the texture on the quad. Moving counter clockwise starting from the left, the texture
should be red, green, blue, black. The alpha channel is always set to opaque, or 0xFF.
*/
static const uint32_t g_TextureSizeX = 2;
static const uint32_t g_TextureSizeY = 2;
static const uint32_t g_TextureDataRGBA[4] = {
0xFF0000FF, 0xFF000000, /* Encoding is 0xAABBGGRR. */
0xFF00FF00, 0xFFFF0000
};
#include <stdio.h>
/* Platform-specific includes for X11 */
#ifndef _WIN32
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#endif
/*
This is just a standard, and empty, Win32 window procedure for event handling. The contents of this do not matter for
this example, but in a real program you'd handle your input and resizing stuff here. For resizing in particular, you
will likely want to recreate your swapchain (explained below). In this example, however, I'm not doing this because
it would require a function which would mean I wouldn't be able to keep this example flat.
*/
#ifdef _WIN32
static const char* g_WndClassName = "vkbWindowClass";
static LRESULT DefaultWindowProcWin32(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_CLOSE:
{
PostQuitMessage(0);
return 0;
}
default: break;
}
return DefWindowProcA(hWnd, msg, wParam, lParam);
}
#endif
/*
This callback is used with the VK_EXT_debug_report extension. This just prints any messages that come through.
*/
VKAPI_ATTR VkBool32 VKAPI_CALL OnDebugReport(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
{
printf("%s\n", pMessage);
/* Unused. */
(void)flags;
(void)objectType;
(void)object;
(void)location;
(void)messageCode;
(void)pLayerPrefix;
(void)pUserData;
return VK_FALSE;
}
/*
And here is the main function. Isn't it good to to have a Vulkan example where you can find main() without having to
search for it?!
*/
int main(int argc, char** argv)
{
(void)argc;
(void)argv;
/* Most Vulkan APIs return a result code. It's probably good practice to check these. :) */
VkResult result;
/*
The first thing to do is initialize vkbind. We're specifying a VkbAPI object because we want to initialize some
instance-specific function pointers (see extension section below). To do this we need this VkbAPI object.
*/
VkbAPI vk;
result = vkbInit(&vk);
if (result != VK_SUCCESS) {
printf("Failed to initialize vkbind.");
return result;
}
/*
This is where we create the window. This is not part of Vulkan. The idea is that you create your window, or more
generally, your "surface", and then specify it when you create your Vulkan surface that will eventually become the
target for your swapchain.
*/
#ifdef _WIN32
WNDCLASSEXA wc;
ZeroMemory(&wc, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.cbWndExtra = sizeof(void*);
wc.lpfnWndProc = (WNDPROC)DefaultWindowProcWin32;
wc.lpszClassName = g_WndClassName;
wc.hCursor = LoadCursorA(NULL, MAKEINTRESOURCEA(32512));
wc.style = CS_OWNDC | CS_DBLCLKS;
if (!RegisterClassExA(&wc)) {
printf("Failed to initialize window class.");
return -1;
}
HWND hWnd = CreateWindowExA(0, g_WndClassName, "Vulkan Tutorial", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, NULL, NULL, NULL, NULL);
if (hWnd == NULL) {
printf("Failed to create window.");
return -1;
}
ShowWindow(hWnd, SW_SHOWNORMAL);
#else
/* X11 window creation */
Display* pDisplay = XOpenDisplay(NULL);
if (pDisplay == NULL) {
printf("Failed to open X11 display.\n");
return -1;
}
int screen = DefaultScreen(pDisplay);
/* Create a simple window */
Window window = XCreateSimpleWindow(pDisplay, RootWindow(pDisplay, screen), 0, 0, 640, 480, 1, BlackPixel(pDisplay, screen), WhitePixel(pDisplay, screen));
if (window == 0) {
printf("Failed to create X11 window.\n");
XCloseDisplay(pDisplay);
return -1;
}
Atom wmDeleteMessage = XInternAtom(pDisplay, "WM_DELETE_WINDOW", False);
XSetWMProtocols(pDisplay, window, &wmDeleteMessage, 1);
/* Set window title */
XStoreName(pDisplay, window, "Vulkan Tutorial");
/* Select input events */
XSelectInput(pDisplay, window, ExposureMask | KeyPressMask | StructureNotifyMask);
/* Make the window visible */
XMapWindow(pDisplay, window);
XFlush(pDisplay);
#endif
/*
This is where we start getting into actual Vulkan programming. The first concept to be aware of is that of the
"instance". This should be fairly obvious - it's basically just the global object that everything is ultimately
created from.
To create an instance, there's two concepts to be aware of: layers and extensions. Vulkan has a layering feature
whereby certain functionality can be plugged into (or layered on top of) the API. This example is enabling the
standard validation layer which you've probably heard of already. If you're enabling a layer or extension, you need
to check that it's actually supported by the instance or else you'll get an error when trying to create the
instance.
Note that if the VK_LAYER_KHRONOS_validation layer is not detected, you should try installing the official Vulkan
SDK for your platform.
*/
/* I'm using fixed sized arrays here for this example, but in a real program you may want to size these dynamically. */
const char* ppEnabledLayerNames[32];
uint32_t enabledLayerCount = 0;
/* This is the list of layers that we'd like, but aren't strictly necessary. */
const char* ppDesiredLayers[] = {
"VK_LAYER_KHRONOS_validation"
};
/*
Here is where check for the availability of our desired layers. All layers are optional, so if they aren't
supported we'll just silently ignore it and keep running - no big deal. In a real program, you'd almost certainly
want to put this into a function called IsLayerSupported() or similar, but since we're keeping this flat, we'll do
it right here.
The first thing to do is retrieve the list of supported layers. You specify an array and capacity, and then call
vkEnumerateInstanceLayerProperties() to extract the layers. Then you can just loop over each entry and check them
against our desired layers.
*/
VkLayerProperties pSupportedLayers[32];
uint32_t supportedLayerCount = sizeof(pSupportedLayers)/sizeof(pSupportedLayers[0]);
result = vkEnumerateInstanceLayerProperties(&supportedLayerCount, pSupportedLayers);
if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
printf("Failed to retrieve layers.");
return -1;
}
for (uint32_t iDesiredLayer = 0; iDesiredLayer < sizeof(ppDesiredLayers)/sizeof(ppDesiredLayers[0]); iDesiredLayer += 1) {
for (uint32_t iSupportedLayer = 0; iSupportedLayer < supportedLayerCount; iSupportedLayer += 1) {
if (strcmp(ppDesiredLayers[iDesiredLayer], pSupportedLayers[iSupportedLayer].layerName) == 0) {
ppEnabledLayerNames[enabledLayerCount++] = ppDesiredLayers[iDesiredLayer]; /* The layer is supported. Enable it. */
break;
}
}
}
/*
Now we do the same with extensions. The extension must be present or else initialization of Vulkan will fail so
therefore we must ensure our optional extensions are only enabled if present. Some extensions are mandatory which
means we *want* initialization to fail if they are not present.
*/
/* I'm using fixed sized arrays here for this example, but in a real program you may want to size these dynamically. */
const char* ppEnabledExtensionNames[32];
uint32_t enabledExtensionCount = 0;
/*
This extension is required for outputting to a window (or "surface") which is what this example is doing which
makes this extension mandatory. We cannot continue without this which means we always specify it in our enabled
extensions list.
The VK_KHR_WIN32_SURFACE_EXTENSION_NAME is the Win32-specific component to the surface extension. We enable this
only for the Win32 build. On Windows this extension is mandatory for this example, so again, we always specify it
in the enabled extensions list and let Vulkan return an error if it's not supported.
*/
ppEnabledExtensionNames[enabledExtensionCount++] = VK_KHR_SURFACE_EXTENSION_NAME;
#ifdef VK_USE_PLATFORM_WIN32_KHR
ppEnabledExtensionNames[enabledExtensionCount++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
#endif
#ifdef VK_USE_PLATFORM_XLIB_KHR
ppEnabledExtensionNames[enabledExtensionCount++] = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
#endif
/*
The extensions below are optional, so we'll selectively enable these based on whether or not it is supported. This
is a little annoying because we will want to use a dynamic array to store the list of supported extensions since we
don't really know how many will be returned. If you have used OpenGL in the past you probably remember the way in
which extensions were retrieved back then: glGetString(GL_EXTENSION). This returns a string of space-delimited
extension names, but the problem was that some programs decided to make a copy of this string into a fixed sized
buffer. As time went on and more and more extensions were added, many of these programs broke because those fixed
sized buffer's weren't big enough to store the whole string! We're not going to be making that same mistake again
now, are we? ARE WE?!
To do this, we call vkEnumerateInstanceExtensionProperties() twice. The first time will pass in NULL for the output
buffer which will cause Vulkan to treat it as a query of the total number of extensions. We'll then use the result
from that query to determine how large of a buffer we should allocate. Then we'll call that same function again,
but this time with a valid output buffer which will fill it with actual data.
We should probably also do this with layers, but since all layers are optional, I'm not as concerned about that.
*/
const char* ppDesiredExtensions[] = {
VK_EXT_DEBUG_REPORT_EXTENSION_NAME /* This is optional and is used for consuming validation errors. */
};
VkExtensionProperties* pSupportedExtensions = NULL;
uint32_t supportedExtensionCount;
result = vkEnumerateInstanceExtensionProperties(NULL, &supportedExtensionCount, NULL);
if (result != VK_SUCCESS) {
printf("Failed to query extension count.");
return -1;
}
pSupportedExtensions = (VkExtensionProperties*)malloc(sizeof(*pSupportedExtensions) * supportedExtensionCount);
if (pSupportedExtensions == NULL) {
printf("Out of memory.");
return -1;
}
result = vkEnumerateInstanceExtensionProperties(NULL, &supportedExtensionCount, pSupportedExtensions);
if (result != VK_SUCCESS) {
printf("Failed to retrieve extensions.");
return -1;
}
/* We have the supported extensions. Now selectively enable our optional ones. */
for (uint32_t iDesiredExtension = 0; iDesiredExtension < sizeof(ppDesiredExtensions)/sizeof(ppDesiredExtensions[0]); iDesiredExtension += 1) {
for (uint32_t iSupportedExtension = 0; iSupportedExtension < supportedExtensionCount; iSupportedExtension += 1) {
if (strcmp(ppDesiredExtensions[iDesiredExtension], pSupportedExtensions[iSupportedExtension].extensionName) == 0) {
ppEnabledExtensionNames[enabledExtensionCount++] = ppDesiredExtensions[iDesiredExtension]; /* The extension is supported. Enable it. */
break;
}
}
}
/* We're not going to be using the pSupportedExtensions array anymore so it can be freed. */
free(pSupportedExtensions);
/*
At this point we've selected the layers and extensions we want to enable, so now we can initialize the Vulkan
instance. You're going to see a lot of this with Vulkan - you want to initialize an object, but before you can, you
need to do a whole heap of setup beforehand. You'll need to just get used to it.
Almost all objects in Vulkan are initialized using a info/create pattern where you first define a structure
containing information about the object you want to initialize, and then you call a "vkCreate*()" function to
create the actual object. The way to memorize it is like this. Take the type of the object you are creating. In
this case, "VkInstance". The info structure will be the same, but with "CreateInfo" at the end. So for the example
of VkInstance, it'll be VkInstanceCreateInfo.
Each CreateInfo structure takes a type which is specified in the "sType" member. This is also fairly easy to
remember. It's just "VK_STRUCTURE_TYPE_" and then "*_CREATE_INFO". So for VkInstanceCreateInfo, it's
"VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO". Personally I don't like this system, and I think it's more intended for
some future proofing, but in my opinion it's a bit over-engineered. But it is what it is, so let's move on.
The layers and extensions that were created earlier are specified in the VkInstanceCreateInfo object. You can also
specify some information about the application, but I don't really know what that's used for so I'm just leaving
that set to NULL. I'll leave that as an excercise for you to figure that one out.
The instance is created with vkCreateInstance(). The first parameter is the VkInstanceCreateInfo object that you
just filled out. The second parameter is a pointer to an object containing callbacks for customizing memory
allocations. For now you need not worry about that - you can consider that once you've figured out what you're
doing. For the purpose of this example, it just gets in the way so this will always be set to NULL. All creation
APIs will allow you to specify this. The final parameter is the VkInstance handle.
*/
VkInstanceCreateInfo instanceInfo;
instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceInfo.pNext = NULL;
instanceInfo.flags = 0;
instanceInfo.pApplicationInfo = NULL;
instanceInfo.enabledLayerCount = enabledLayerCount;
instanceInfo.ppEnabledLayerNames = ppEnabledLayerNames;
instanceInfo.enabledExtensionCount = enabledExtensionCount;
instanceInfo.ppEnabledExtensionNames = ppEnabledExtensionNames;
VkInstance instance;
result = vkCreateInstance(&instanceInfo, NULL, &instance);
if (result != VK_SUCCESS) {
printf("Failed to create Vulkan instance. Check that your hardware supports Vulkan and you have up to date drivers installed.");
return -1;
}
/*
If we've made it here it means we've successfully initialized the Vulkan instance. Here is where we do some vkbind
specific stuff. Below we are going to reference some functions that are specific to an extension. The problem is
that those APIs can only be retrieved if we have a valid instance. vkbind supports this. We need to call vkbind's
vkbInitInstanceAPI() and then bind the results to global scope. The binding to global scope is optional, but it
makes this example cleaner. Binding to global scope is only useful when your application is using only a single
Vulkan instance. If you're using multiple, you should instead call functions directly from the VkbAPI object.
*/
result = vkbInitInstanceAPI(instance, &vk);
if (result != VK_SUCCESS) {
vkDestroyInstance(instance, NULL);
printf("Failed to load instance-specific Vulkan APIs.");
return -1;
}
vkbBindAPI(&vk); /* <-- Bind Vulkan functions to global scope. */
/*
When we were setting up the extensions, we specified VK_EXT_DEBUG_REPORT_EXTENSION_NAME as one of our optional
extensions. Here is where we're going to get this one configured. What this does is allows us to intercept and
detect errors. Before configuring it we'll need to confirm that it's actually usable.
*/
VkDebugReportCallbackEXT debugReportCallbackObject;
for (uint32_t iEnabledExtension = 0; iEnabledExtension < enabledExtensionCount; iEnabledExtension += 1) {
if (strcmp(ppEnabledExtensionNames[iEnabledExtension], VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
VkDebugReportCallbackCreateInfoEXT debugReportCallbackCreateInfo;
debugReportCallbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
debugReportCallbackCreateInfo.pNext = NULL;
debugReportCallbackCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT;
debugReportCallbackCreateInfo.pfnCallback = OnDebugReport;
debugReportCallbackCreateInfo.pUserData = NULL;
result = vkCreateDebugReportCallbackEXT(instance, &debugReportCallbackCreateInfo, NULL, &debugReportCallbackObject);
if (result != VK_SUCCESS) {
printf("WARNING: Failed to create debug report callback.");
}
break;
}
}
/*
You probably remember right at the top where we created the application window. On Win32, this is where we created
the HWND object. Up until this point, that window has been completely disconnected from Vulkan. Now is the time
where we go ahead and connect them both up. To form this connection we now introduce the notion of a "surface". A
surface is actually created in a platform specific manner, which makes perfect sense since we're interacting with
platform specific objects such HWND, however the object itself (VkSurfaceKHR) is generic (it's just that it's
created from a platform specific API).
Think of the surface as representing the thing where the final image will be drawn to, in our case this being the
application window.
It's important that we create the surface pretty much immediately after the creation of the Vulkan instance. The
reason for this is the selection of the physical device in the next section. A physical device may not be able to
output to the specified window. To check for this we require a surface, which means we need to create it now,
before enumerating over the physical devices.
*/
VkSurfaceKHR surface; /* <-- This is our platform-independant surface object. */
/*
On Win32 the creation of the surface works pretty much exactly as one would expect. You just specify the HINSTANCE
and HWND which should be familiar to anybody whose done Win32 programming before. You can get the HINSTANCE from
the HWND which is demonstrated below.
*/
#ifdef _WIN32
VkWin32SurfaceCreateInfoKHR surfaceInfo;
surfaceInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
surfaceInfo.pNext = NULL;
surfaceInfo.flags = 0;
surfaceInfo.hinstance = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);
surfaceInfo.hwnd = hWnd;
result = vkCreateWin32SurfaceKHR(instance, &surfaceInfo, NULL, &surface);
if (result != VK_SUCCESS) {
vkDestroyInstance(instance, NULL);
printf("Failed to create a Vulkan surface for the main window.");
return -1;
}
#else
/* X11 surface creation */
VkXlibSurfaceCreateInfoKHR surfaceInfo;
surfaceInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
surfaceInfo.pNext = NULL;
surfaceInfo.flags = 0;
surfaceInfo.dpy = pDisplay;
surfaceInfo.window = window;
result = vkCreateXlibSurfaceKHR(instance, &surfaceInfo, NULL, &surface);
if (result != VK_SUCCESS) {
vkDestroyInstance(instance, NULL);
XCloseDisplay(pDisplay);
printf("Failed to create a Vulkan surface for the main window.");
return -1;
}
#endif
/*
At this point we have the Vulkan instance created and debugging set up. Now we can introduce the concept of
"devices". There's two types of devices - physical and logical. These are pretty much self explanatory. The
physical device represents a physical hardware device on your computer. A logical device is created from the
physical device and is essentially a proxy. You'll do everything through a logical device. The physical device is
basically only used for device selection and enumeration and to create logical devices.
This example always uses the first enumerated device. I haven't seen anywhere that specifies whether or not the
first enumerated device should be considered the default device, but this will work well enough for the purposes
of this example. For demonstration purposes we'll enumerate over each device anyway. For simplicity we're limiting
this to a fixed number of devices as defined by the pPhysicalDevices array.
*/
/*
This retrieves the physical devices and works the same way as layer and extension retrieval. You must call this or
else you won't be able to get access to a VkPhysicalDevice object for creating the logical device.
*/
VkPhysicalDevice pPhysicalDevices[16];
uint32_t physicalDeviceCount = sizeof(pPhysicalDevices) / sizeof(pPhysicalDevices[0]);
result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, pPhysicalDevices);
if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
printf("Failed to enumerate physical devices. Check that your hardware supports Vulkan and you have up to date drivers installed.");
return -1;
}
/*
At this point we have a list of physical devices and now we need to choose one. The selection of a physical device
depends on whether or not it supports the surface we created earlier. Since this example is outputting to a window,
this check becomes necessary. If you were doing purely off-screen rendering you wouldn't need to check this.
This is where we're introduced to the first of the stranger concepts introduced with Vulkan - queue families. When
you want to execute a command, you don't execute it directly. You instead post it to a queue which is then executed
at a later stage of your choosing. These queues have certain capabilities which are defined by the queue family.
The capabilities include things like graphics, compute and transfer. When you create the logical device, you need
to specify the number of queues you want for each queue family (the capabilities of those queues) that you're
needing to support.
To determine the queue family, you need to retrieve a list of supported queue families, which is determined by the
physical device. Then, you check the capabilities of those queue families. When you find a queue family that
supports what you need, you can create the logical device. For this example it's quite simple. All we're doing is
graphics which means we can just use the first queue family that reports support for graphics. When starting out, I
recommend following this. When you get to more advanced stuff you might be able to use dedicated compute and
transfer queues if that's what you'd prefer. Note that a queue family supporting graphics must also support
transfer operations, as defined by the Vulkan spec.
*/
uint32_t selectedPhysicalDeviceIndex = (uint32_t)-1; /* Set to -1 so we can determine whether or not a device has been selected. */
uint32_t selectedQueueFamilyIndex = (uint32_t)-1;
for (uint32_t iPhysicalDevice = 0; iPhysicalDevice < physicalDeviceCount; ++iPhysicalDevice) {
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(pPhysicalDevices[iPhysicalDevice], &properties);
printf("Physical Device: %s\n", properties.deviceName);
printf(" API Version: %d.%d\n", VK_VERSION_MAJOR(properties.apiVersion), VK_VERSION_MINOR(properties.apiVersion));
/*
Only try selecting the device if we haven't already found one. We don't break from the loop early because we
want to show all devices to the user, not just those that happened to come before the chosen device.
*/
if (selectedPhysicalDeviceIndex == (uint32_t)-1) {
/*
Before we can determine whether or not the physical device supports our surface, we need to find an appropriate
queue family which is defined by an index. That's what we do now. For simplicity we're just retrieving a fixed
maximum number of queue families, but a more robust implementation may want to dynamically allocate this.
*/
VkQueueFamilyProperties queueFamilyProperties[16];
uint32_t queueFamilyCount = sizeof(queueFamilyProperties) / sizeof(queueFamilyProperties[0]);
vkGetPhysicalDeviceQueueFamilyProperties(pPhysicalDevices[iPhysicalDevice], &queueFamilyCount, queueFamilyProperties);
/*
Selection of an appropriate queue family is just a matter of checking some flags. We need a graphics queue. For
simplicity we just use the first one we find.
*/
uint32_t queueFamilyIndex_Graphics = (uint32_t)-1;
for (uint32_t iQueueFamily = 0; iQueueFamily < queueFamilyCount; ++iQueueFamily) {
if ((queueFamilyProperties[iQueueFamily].queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
queueFamilyIndex_Graphics = iQueueFamily;
break;
}
}
/*
We want to use double buffering which means we'll need to retrieve the capabilities of the surface and check
the maxImageCount property.
*/
VkSurfaceCapabilitiesKHR surfaceCaps;
result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(pPhysicalDevices[iPhysicalDevice], surface, &surfaceCaps);
if (result != VK_SUCCESS) {
continue;
}
if (surfaceCaps.maxImageCount < 2) {
continue; /* The surface and device combination do not support at least two images (required for double buffering). */
}
/* The physical device needs to support outputting to our surface. To determine support, we need the physical device and queue family. */
VkBool32 isSupported;
result = vkGetPhysicalDeviceSurfaceSupportKHR(pPhysicalDevices[iPhysicalDevice], queueFamilyIndex_Graphics, surface, &isSupported);
if (result == VK_SUCCESS && isSupported == VK_TRUE) {
selectedPhysicalDeviceIndex = iPhysicalDevice;
selectedQueueFamilyIndex = queueFamilyIndex_Graphics;
/*break;*/ /* Intentionally not breaking here because we want to print all devices, including those we aren't selecting. */
}
}
}
/*
If we couldn't find an appropriate physical device or queue family we'll need to abort. Note that a more complex
program may require multiple queues, so the queue family selection might become a lot more complex.
*/
if (selectedPhysicalDeviceIndex == (uint32_t)-1 || selectedQueueFamilyIndex == (uint32_t)-1) {
vkDestroyInstance(instance, NULL);
return -1;
}
/*
We're going to need these memory properties for when we allocate memory. The way it works is there's basically
different types of memory, the main ones being "host visible" and "device local". Host visible basically system RAM
whereas device local is GPU memory. There's other flags to consider, but they aren't important while you're just
getting started. These memory flags are grouped into a memory type, which are referenced by an index. When you
allocate memory, you need to specify the index of an appropriate memory type which you select by iterating over the
available memory types and checking if they have the appropriate flags. The memory types are retrieved by calling
the vkGetPhysicalDeviceMemoryProperties() function.
You'll see an example on how to iterate over these memory types later on. Since we're going to be doing this
multiple times, I'm just going to retrieve the memory types once at the top right here rather than retrieving them
multiple times. This process of iterating over memory types to find an appropriate index will probably be one of
the first things you'll want to wrap in a helper function. We're not doing that in this example, however, because
the point is to keep this completely flat.
When you allocate memory, you first get the memory requirements (VkMemoryRequirements) of the relevant object which
will be a buffer or an image. In the returned object, there will be a memoryTypesBits variable. The index of each
set bit, starting from the least significant bit, defines which memory type in the VkPhysicalDeviceMemoryProperties
object can be used for the memory allocation. From there, you inspect the memory type's property flags which will
define whether or not the memory type is host visible and/or device local (among others). This will provide you
with enough information to determine the memory type index. When we allocate memory later on for vertex buffers and
textures you'll see more clearly how to choose an appropriate memory type.
*/
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProps;
vkGetPhysicalDeviceMemoryProperties(pPhysicalDevices[selectedPhysicalDeviceIndex], &physicalDeviceMemoryProps);
/*
Now that we have our list of physical devices we can create a logical device. The logical device is the what's used
for interfacing with almost all Vulkan APIs. To create the device we need to specify the queues (and their families)
that we need.
*/
/*
Queue priorities are in the range of [0..1] and work the way you would expect where 0 is lowest priority and 1 is
highest priority. We're only using a single queue, so just setting this to 1 is fine.
*/
float pQueuePriorities[1];
pQueuePriorities[0] = 1;
/*
This is where we define how many queues we want to initialize with this device. Queues are not created dynamically;
they're instead created statically with the device. Queues are grouped by queue families, so you need to specify
the index of the queue family, and then the number of queues you want to create for that queue family.
*/
VkDeviceQueueCreateInfo pQueueInfos[1]; /* <-- Set this to the number of queue families being used. */
pQueueInfos[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
pQueueInfos[0].pNext = NULL;
pQueueInfos[0].flags = 0;
pQueueInfos[0].queueFamilyIndex = selectedQueueFamilyIndex;
pQueueInfos[0].queueCount = 1; /* <-- We're only using a single queue for this example. */
pQueueInfos[0].pQueuePriorities = pQueuePriorities;
/*
Now we're back to extensions. Some extensions are specific to devices. This is relevant for us because we're going
to need one - the swapchain extension. The swapchain is a critical concept for displaying content on the screen and
will be explained in a bit. For now, just trust me that you'll need it. This is a mandatory extension for us, so we
can use a simplified system for this.
*/
const char* ppEnabledDeviceExtensionNames[] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME /* <-- Mandatory if we're displaying to a window. */
};
uint32_t enabledDeviceExtensionCount = sizeof(ppEnabledDeviceExtensionNames) / sizeof(ppEnabledDeviceExtensionNames[0]);
/*
When we initialize the device we need to specify a set of features that need to be enabled. If we enable a certain
feature and that feature is not supported, device creation will fail. This is useful if your application has a hard
requirement for specific features. For our purposes, however, we don't really have that concern since we're just
doing basic stuff.
One way to do this is to manually specify the features you need. However, for the purposes of this example, this is
too tedious. Instead we are going to retrieve the supported features from the physical device and just pass that
straight through. Since this example is only using a very basic feature set, this will work fine for us.
*/
VkPhysicalDeviceFeatures physicalDeviceFeatures;
vkGetPhysicalDeviceFeatures(pPhysicalDevices[selectedPhysicalDeviceIndex], &physicalDeviceFeatures);
/* We now have enough information to create the device. */
VkDeviceCreateInfo deviceInfo;
deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceInfo.pNext = NULL;
deviceInfo.flags = 0;
deviceInfo.queueCreateInfoCount = sizeof(pQueueInfos) / sizeof(pQueueInfos[0]);
deviceInfo.pQueueCreateInfos = pQueueInfos;
deviceInfo.enabledLayerCount = 0;
deviceInfo.ppEnabledLayerNames = NULL;
deviceInfo.enabledExtensionCount = enabledDeviceExtensionCount;
deviceInfo.ppEnabledExtensionNames = ppEnabledDeviceExtensionNames;
deviceInfo.pEnabledFeatures = &physicalDeviceFeatures; /* <-- Setting this to NULL is equivalent to disabling all features. */
/*
We now have all the information we need to create a device. The device is created from a physical device which we
enumerated over earlier.
*/
VkDevice device;
result = vkCreateDevice(pPhysicalDevices[selectedPhysicalDeviceIndex], &deviceInfo, NULL, &device);
if (result != VK_SUCCESS) {
vkDestroyInstance(instance, NULL);
printf("Failed to create logical device.");
return -1;
}
/*
The next concept to introduce is that of the swapchain. The swapchain is closely related to the surface. Indeed,
you need a surface before you can create a swapchain. A swapchain is made up of a number of images which, as the
name suggests, are swapped with each other at display time.
In a double buffered environment, there will be two images in the swapchain. At any given moment, one of those
images will be displayed on the window, while the other one, which is off-screen, is being drawn to by the graphics
driver. When the off-screen image is ready to be displayed, the two images are swapped and their roles reversed.
To create a swapchain, you'll first need a surface which we've already created. You'll also need to determine how
many images you need in the swap chain. If you're using double buffering you'll need two which is what we'll be
using in this example. Triple buffering will require three images.
Since the swapchain is made up of a number of images, we'll also need to specify the format and size of the images.
If we try specifying an unsupported image format, creation of the swapchain will fail. We'll need to first
enumerate over each of our supported formats. While you're just getting started, just use either VK_R8G8B8A8_UNORM
or VK_B8G8R8A8_UNORM and move on. From there you can start experimenting with sRGB formats if that's important for
you. For robustness you may want to check for available formats beforehand which is what this example does.
*/
VkSurfaceFormatKHR supportedSwapchainImageFormats[256];
uint32_t supportedFormatsCount = sizeof(supportedSwapchainImageFormats) / sizeof(supportedSwapchainImageFormats[0]);
result = vkGetPhysicalDeviceSurfaceFormatsKHR(pPhysicalDevices[selectedPhysicalDeviceIndex], surface, &supportedFormatsCount, supportedSwapchainImageFormats);
if (result != VK_SUCCESS) {
printf("Failed to retrieve physical device surface formats.");
return -1;
}
uint32_t swapchainImageFormatIndex = (uint32_t)-1;
for (uint32_t i = 0; i < supportedFormatsCount; ++i) {
if (supportedSwapchainImageFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM || supportedSwapchainImageFormats[i].format == VK_FORMAT_B8G8R8A8_UNORM) { /* <-- Can also use VK_FORMAT_*_SRGB */
swapchainImageFormatIndex = i;
break;
}
}
if (swapchainImageFormatIndex == (uint32_t)-1) {
printf("Could not find suitable display format.");
return -1;
}
/*
A this point we'll have our format selected, but there's just a few more pieces of information we'll need to
retrieve real quick. The swapchain CreateInfo structure will ask for the size of the images and a transform, which
is 90 degree rotations and flips. These can be retrieved from the current state of the surface. It's not entirely
necessary to do this, but it's an easy way to get suitable values.
*/
VkSurfaceCapabilitiesKHR surfaceCaps;
result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(pPhysicalDevices[selectedPhysicalDeviceIndex], surface, &surfaceCaps);
if (result != VK_SUCCESS) {
printf("Failed to retrieve surface capabilities.");
return -1;
}
VkSwapchainCreateInfoKHR swapchainInfo;
swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchainInfo.pNext = NULL;
swapchainInfo.flags = 0;
swapchainInfo.surface = surface;
swapchainInfo.minImageCount = 2; /* Set this to 2 for double buffering. Triple buffering would be 3, etc. */
swapchainInfo.imageFormat = supportedSwapchainImageFormats[swapchainImageFormatIndex].format; /* The format we selected earlier. */
swapchainInfo.imageColorSpace = supportedSwapchainImageFormats[swapchainImageFormatIndex].colorSpace; /* The color space we selected earlier. */
swapchainInfo.imageExtent = surfaceCaps.currentExtent; /* The size of the images of the swapchain. Keep this the same size as the surface. */
swapchainInfo.imageArrayLayers = 1; /* I'm not sure in what situation you would ever want to set this to anything other than 1. */
swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchainInfo.queueFamilyIndexCount = 0; /* Only used when imageSharingMode is VK_SHARING_MODE_CONCURRENT. */
swapchainInfo.pQueueFamilyIndices = NULL; /* Only used when imageSharingMode is VK_SHARING_MODE_CONCURRENT. */
swapchainInfo.preTransform = surfaceCaps.currentTransform; /* Rotations (90 degree increments) and flips. Just use the current transform from the surface and move on. */
swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchainInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR; /* This is what controls vsync. FIFO must always be supported, so use it by default. */
swapchainInfo.clipped = VK_TRUE; /* Set this to true if you're only displaying to a window. */
swapchainInfo.oldSwapchain = VK_NULL_HANDLE; /* You would set this if you're creating a new swapchain to replace an old one, such as when resizing a window. */
VkSwapchainKHR swapchain;
result = vkCreateSwapchainKHR(device, &swapchainInfo, NULL, &swapchain);
if (result != VK_SUCCESS) {
printf("Failed to create swapchain.");
return -2;
}
/*
At this point the swapchain has been created, but there's a little bit more to do. Later on we're going to be
creating a framebuffer for each of the swapchain images. Framebuffers interact with swapchain images through an
image view so we'll need to create those too.
We'll first determine the number of images making up the swapchain. When you created the swapchain you specified
the *minimum* number of images making up the swapchain. That doesn't mean the driver didn't give you more. You'll
need to handle this if you want a robust program. In practice, my testing has yielded an identical image count as
specified in minImageCount for 2 (double buffered) and 3 (triple buffered) which will meet the needs of the vast
majority of cases. When minImageCount is set to 1, my NVIDIA driver always allocates 2 images. I have not been
able to do single-buffered rendering in Vulkan.
I'm allocating the image and image view objects statically on the stack for simplicity and to avoid cluttering the
code with non-Vulkan code. Also, the validation layer likes us to explicitly call vkGetSwapchainImagesKHR() with
pSwapchainImages set to NULL in order to get the image count before retrieving the actual images.
*/
uint32_t swapchainImageCount;
result = vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, NULL); /* Set the output buffer to NULL to just retrieve a count. */
if (result != VK_SUCCESS) {
printf("Failed to retrieve swapchain image count.");
return -1;
}
VkImage swapchainImages[16]; /* <-- Overkill. Consider allocating this dynamically. */
result = vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, swapchainImages);
if (result != VK_SUCCESS) {
printf("Failed to retrieve swapchain image count.");
return -1;
}
/* Once we have the swapchain images we can create the views. The views will be used with the framebuffers later. */
VkImageView swapchainImageViews[16];
for (uint32_t iSwapchainImage = 0; iSwapchainImage < swapchainImageCount; iSwapchainImage += 1) {
VkImageViewCreateInfo imageViewInfo;
imageViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewInfo.pNext = NULL;
imageViewInfo.flags = 0;
imageViewInfo.image = swapchainImages[iSwapchainImage];
imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewInfo.format = supportedSwapchainImageFormats[swapchainImageFormatIndex].format;
imageViewInfo.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewInfo.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewInfo.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewInfo.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewInfo.subresourceRange.baseMipLevel = 0;
imageViewInfo.subresourceRange.levelCount = 1;
imageViewInfo.subresourceRange.baseArrayLayer = 0;
imageViewInfo.subresourceRange.layerCount = 1;
result = vkCreateImageView(device, &imageViewInfo, NULL, &swapchainImageViews[iSwapchainImage]);
if (result != VK_SUCCESS) {
printf("Failed to create image views for swapchain images.");
return -2;
}
}
/*
There's one last bit of prep work we're needing to do for the swapchain. Swapping images within the swapchain need
to be synchronized which we achieve by using a semaphore which is passed in to vkAcquireNextImageKHR() and then
waited for in the call to vkQueuePresentKHR() by adding it to the pWaitSemaphore member. This'll be explained later
in the main loop, but we'll create the semapahore now in preparation.
Semaphores are deleted with vkDestroySemaphore().
*/
VkSemaphoreCreateInfo semaphoreInfo;
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
semaphoreInfo.pNext = 0;
semaphoreInfo.flags = 0;
VkSemaphore swapchainSemaphore;
vkCreateSemaphore(device, &semaphoreInfo, NULL, &swapchainSemaphore);
/*
Pipelines. To put it simply, a pipeline object defines the settings to use when drawing something, such as the
structure of the vertex buffer, which shaders to use, shader inputs, whether or not depth testing is enabled, etc.
Most programs will have many pipeline objects - you'll likely want to wrap this in a function for anything real-
world.
The creation of a pipeline object has a lot of dependencies. I'm not going to explain it all here, but will explain
it as we go. The order in which I do things below is unimportant and you can do it in whatever order you'd like,
but the way I do it here is intuitive to me.
*/
/*
Shaders. The first thing we'll define are the necessary shaders. We're just displaying a simple textured quad so
all well need is a vertex and fragment shader. There are additional types of shaders for different stages of the
pipeline, but that's an excersise for later. All real-world graphics projects will need a vertex and fragment
shader, however.
Shaders are specified in a binary format called SPIR-V. In this example we compile shaders from GLSL to SPIR-V
using an offline tool called glslangValidator. The vfs_map_file() function is just some auto-generated code used by
this example so we can embed the SPIR-V data directly into the program and avoid the need to load files and worry
about startup paths and all that.
*/
VkShaderModuleCreateInfo vertexShaderInfo;
vertexShaderInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
vertexShaderInfo.pNext = NULL;
vertexShaderInfo.flags = 0;
vertexShaderInfo.pCode = (const uint32_t*)vfs_map_file("shaders/01_Fundamentals.glsl.vert.spirv", &vertexShaderInfo.codeSize);
VkShaderModule vertexShaderModule;
result = vkCreateShaderModule(device, &vertexShaderInfo, NULL, &vertexShaderModule);
if (result != VK_SUCCESS) {
printf("Failed to create shader module.");
return -2;
}
VkShaderModuleCreateInfo fragmentShaderInfo;
fragmentShaderInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
fragmentShaderInfo.pNext = NULL;
fragmentShaderInfo.flags = 0;
fragmentShaderInfo.pCode = (const uint32_t*)vfs_map_file("shaders/01_Fundamentals.glsl.frag.spirv", &fragmentShaderInfo.codeSize);
VkShaderModule fragmentShaderModule;
result = vkCreateShaderModule(device, &fragmentShaderInfo, NULL, &fragmentShaderModule);
if (result != VK_SUCCESS) {
printf("Failed to create shader module.");
return -2;
}
VkPipelineShaderStageCreateInfo pipelineStages[2];
pipelineStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineStages[0].pNext = NULL;
pipelineStages[0].flags = 0;
pipelineStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
pipelineStages[0].module = vertexShaderModule;
pipelineStages[0].pName = "main";
pipelineStages[0].pSpecializationInfo = NULL;
pipelineStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineStages[1].pNext = NULL;
pipelineStages[1].flags = 0;
pipelineStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
pipelineStages[1].module = fragmentShaderModule;
pipelineStages[1].pName = "main";
pipelineStages[1].pSpecializationInfo = NULL;
/*
Vertex formats. Here is where we define the format of the data as passed to the vertex shader.
There's two concepts to consider - bindings and attributes. Think of a binding as a grouping of related vertex
attributes inside a single, interleaved buffer. A common example is interleaved vertex data. With this setup, which
we're using in this example, the position, color, texture coordinate and whatever else you want to group together
are part of a single binding. The position will be one attribute, the color will be another, etc. If, however, you
were wanting to keep your individual vertex attributes (position, color, etc.) in separate buffers, you would have
one binding for each buffer. So to summarize, binding = vertex buffer; attributes = individual elements (position,
color, etc.) within a vertex buffer.
Attributes are associated with a location which is just a number. This is an important concept to understand
because it's how Vulkan is able to map vertex attribute to inputs into the vertex shader. It's important that
locations map properly with how they're specified in the shader. In the vertex shader, you'll have vertex input
declarations that look like this:
layout(location = 0) in vec3 VERT_Position;
layout(location = 1) in vec3 VERT_Color;
layout(location = 2) in vec2 VERT_TexCoord;
The locations you see specified in the vertex shader are specified in the code segment below. The "location" member
of VkVertexInputAttributeDescription needs to map with how you've defined it in the shader. You'll note that you
don't need to specify the binding in the shader. Instead, the binding is specified when we bind the vertex buffer
with vkCmdBindVertexBuffers() which we do before issuing a draw command.
*/
/*
This is where we define our bindings. Remember: a binding is a vertex buffer. When interleaving vertex attributes
such as position and color, we just have a single buffer. If we were *not* interleaving, we'd have a separate
buffer, and therefore separate bindings, for each attribute.
*/
VkVertexInputBindingDescription vertexInputBindingDescriptions[1]; /* <-- Just one binding since we're using a single, interleaved buffer. */
vertexInputBindingDescriptions[0].binding = 0;
vertexInputBindingDescriptions[0].stride = sizeof(float)*3 + sizeof(float)*3 + sizeof(float)*2;
vertexInputBindingDescriptions[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
/*
This is where we specify the individual vertex attributes (position, color, etc.), and it's here where the location
will be specified. In addition to the location, a binding is also required. The binding is an index into the array
we just declared above (vertexInputBindingDescriptions[]). Since we're only using a single binding, we set this to
0 for all of our vertex attributes.
The format of the vertex attribute is also required. In this example, everything uses floating point. The position
is defined in 3 dimensions. So as an example, the position attribute will be set to VK_FORMAT_R32G32B32_SFLOAT
which should be simple enough to understand, albeit a little unintuitive due to it looking more like a texture
format rather than a vertex format. The "SFLOAT" part means signed floating point. The "R", "G" and "B" parts
represent "X", "Y" and "Z" respectively. The "32" means 32-bit.
The last thing you need to specify is the offset in bytes of the start of the data for that attribute within the
buffer. In the example below, the position is the first element which means it'll have no offset. The color comes
immediately after the position, so therefore the offset needs to be set to the size of a single position element
which is 3 floating point numbers, or sizeof(float)*3. Texture coordinates come immediately after color, so that
will need to be set to sizeof(float)*3 (position) plus sizeof(float)*3 (color).
*/
VkVertexInputAttributeDescription vertexInputAttributeDescriptions[3];
/*
Position.
Shader Declaration: layout(location = 0) in vec3 VERT_Position;
*/
vertexInputAttributeDescriptions[0].location = 0; /* layout(location = 0) in the vertex shader. */
vertexInputAttributeDescriptions[0].binding = 0; /* Maps to a binding in vertexInputBindingDescriptions[]. Referenced in vkCmdBindVertexBuffers() */
vertexInputAttributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
vertexInputAttributeDescriptions[0].offset = 0;
/*
Color.
Shader Declaration: layout(location = 1) in vec3 VERT_Color;
*/
vertexInputAttributeDescriptions[1].location = 1; /* layout(location = 1) in the vertex shader.*/
vertexInputAttributeDescriptions[1].binding = 0; /* Maps to a binding in vertexInputBindingDescriptions[]. Referenced in vkCmdBindVertexBuffers() */
vertexInputAttributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
vertexInputAttributeDescriptions[1].offset = sizeof(float)*3;
/*
Texture Coordinates.
Shader Declaration: layout(location = 2) in vec3 VERT_TexCoord;
*/
vertexInputAttributeDescriptions[2].location = 2; /* layout(location = 2) in the vertex shader. */
vertexInputAttributeDescriptions[2].binding = 0; /* Maps to a binding in vertexInputBindingDescriptions[]. Referenced in vkCmdBindVertexBuffers() */
vertexInputAttributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
vertexInputAttributeDescriptions[2].offset = sizeof(float)*3 + sizeof(float)*3;
/*
The VkPipelineVertexInputStateCreateInfo object is where we put the vertex format defined above all together which
will eventually be passed to the pipeline CreateInfo object.
*/
VkPipelineVertexInputStateCreateInfo vertexInputState;
vertexInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputState.pNext = NULL;
vertexInputState.flags = 0;
vertexInputState.vertexBindingDescriptionCount = sizeof(vertexInputBindingDescriptions)/sizeof(vertexInputBindingDescriptions[0]);
vertexInputState.pVertexBindingDescriptions = vertexInputBindingDescriptions;
vertexInputState.vertexAttributeDescriptionCount = sizeof(vertexInputAttributeDescriptions)/sizeof(vertexInputAttributeDescriptions[0]);
vertexInputState.pVertexAttributeDescriptions = vertexInputAttributeDescriptions;
/*
The input assembly state basically controls the topology of the vertex data (whether or not the rasterizer should
treat the vertex data as triangles, lines, etc.). Where the section above defined the structure of the vertex
buffer(s), this defines how the rasterizer should interpret the vertex buffer(s) when rasterizing.
*/
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState;
inputAssemblyState.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssemblyState.pNext = NULL;
inputAssemblyState.flags = 0;
inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssemblyState.primitiveRestartEnable = VK_FALSE;
/*
Viewport state. This is the glViewport() and glScissor() of Vulkan. These can actually be set dynamically rather
than statically. We're going to use this property in this example. By setting pViewports and pScissors to NULL,
we're telling Vulkan that we'll set these dynamically with vkCmdSetViewport() and vkCmdSetScissor() respectively.
*/
VkPipelineViewportStateCreateInfo viewportState;
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.pNext = NULL;
viewportState.flags = 0;
viewportState.viewportCount = 1;
viewportState.pViewports = NULL; /* <-- Set to NULL because we are using dynamic viewports. Set with vkCmdSetViewport(). */
viewportState.scissorCount = 1;
viewportState.pScissors = NULL; /* <-- Set to NULL because we are using dynamic scissor rectangles. Set with vkCmdSetScissor(). */
/*
Rasterization state. This is where you set your fill modes, backface culling, polygon winding, etc.
*/
VkPipelineRasterizationStateCreateInfo rasterizationState;
rasterizationState.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizationState.pNext = NULL;
rasterizationState.flags = 0;
rasterizationState.depthClampEnable = VK_FALSE;
rasterizationState.rasterizerDiscardEnable = VK_FALSE;
rasterizationState.polygonMode = VK_POLYGON_MODE_FILL;
rasterizationState.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizationState.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; /* <-- This is the polygon winding. */
rasterizationState.depthBiasEnable = VK_FALSE;
rasterizationState.depthBiasConstantFactor = 0;
rasterizationState.depthBiasClamp = 1;
rasterizationState.depthBiasSlopeFactor = 0;
rasterizationState.lineWidth = 1;
/*
Multisample state. We're not doing multisample anti-aliasing in this example, so we're just setting this to basic
values. Note that rasterizationSamples should be set to VK_SAMPLE_COUNT_1_BIT to disable MSAA.
*/
VkPipelineMultisampleStateCreateInfo multisampleState;
multisampleState.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampleState.pNext = NULL;
multisampleState.flags = 0;
multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
multisampleState.sampleShadingEnable = VK_FALSE;
multisampleState.minSampleShading = 1;
multisampleState.pSampleMask = NULL;
multisampleState.alphaToCoverageEnable = VK_FALSE;
multisampleState.alphaToOneEnable = VK_FALSE;
/*
Depth/stencil state.
*/
VkPipelineDepthStencilStateCreateInfo depthStencilState;
depthStencilState.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
depthStencilState.pNext = NULL;
depthStencilState.flags = 0;
depthStencilState.depthTestEnable = VK_TRUE; /* This example will be using depth testing. */
depthStencilState.depthWriteEnable = VK_TRUE; /* We'll want to write to the depth buffer. */
depthStencilState.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
depthStencilState.depthBoundsTestEnable = VK_FALSE;
depthStencilState.stencilTestEnable = VK_FALSE; /* No stencil testing in this example. The "front" and "back" settings don't matter here. */
depthStencilState.front.failOp = VK_STENCIL_OP_KEEP;
depthStencilState.front.passOp = VK_STENCIL_OP_KEEP;
depthStencilState.front.depthFailOp = VK_STENCIL_OP_KEEP;
depthStencilState.front.compareOp = VK_COMPARE_OP_ALWAYS;
depthStencilState.front.compareMask = 0xFFFFFFFF;
depthStencilState.front.writeMask = 0xFFFFFFFF;
depthStencilState.front.reference = 0;
depthStencilState.back = depthStencilState.front; /* We're not doing stencil testing, so set to whatever you want (but make sure it's valid for correctness sake). */
depthStencilState.minDepthBounds = 0;
depthStencilState.maxDepthBounds = 1;
/*
Color blend state. We have one color blend attachment state for each color attachment in the subpass. This'll be
explained below in when creating the render pass.
*/
VkPipelineColorBlendAttachmentState colorBlendAttachmentStates[1]; /* <-- One for each color attachment used by the subpass. */
colorBlendAttachmentStates[0].blendEnable = VK_FALSE;
colorBlendAttachmentStates[0].srcColorBlendFactor = VK_BLEND_FACTOR_ZERO;
colorBlendAttachmentStates[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
colorBlendAttachmentStates[0].colorBlendOp = VK_BLEND_OP_ADD;
colorBlendAttachmentStates[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
colorBlendAttachmentStates[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
colorBlendAttachmentStates[0].alphaBlendOp = VK_BLEND_OP_ADD;
colorBlendAttachmentStates[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
VkPipelineColorBlendStateCreateInfo colorBlendState;
colorBlendState.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlendState.pNext = NULL;
colorBlendState.flags = 0;
colorBlendState.logicOpEnable = VK_FALSE;
colorBlendState.logicOp = VK_LOGIC_OP_CLEAR;
colorBlendState.attachmentCount = sizeof(colorBlendAttachmentStates)/sizeof(colorBlendAttachmentStates[0]);
colorBlendState.pAttachments = colorBlendAttachmentStates;
colorBlendState.blendConstants[0] = 0;
colorBlendState.blendConstants[1] = 0;
colorBlendState.blendConstants[2] = 0;
colorBlendState.blendConstants[3] = 0;
/*
Dynamic state. Vulkan allows for some state to be dynamically set instead of statically. We're using a dynamic
viewport and scissor in this example, mainly just to demonstrate how to use it. This requires us to call
vkCmdSetViewport() and vkCmdSetScissor() at some point when building the command queue.
*/
VkDynamicState dynamicStates[2];
dynamicStates[0] = VK_DYNAMIC_STATE_VIEWPORT;
dynamicStates[1] = VK_DYNAMIC_STATE_SCISSOR;
VkPipelineDynamicStateCreateInfo dynamicState;
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
dynamicState.flags = 0;
dynamicState.dynamicStateCount = sizeof(dynamicStates)/sizeof(dynamicStates[0]);
dynamicState.pDynamicStates = dynamicStates;
/*
Pipeline layout. This defines descriptor set layouts and push constants. Descriptor set layouts basically define the
uniform variables in your shaders. Example shader:
layout(set = 0, binding = 0) uniform sampler FRAG_Sampler;
layout(set = 0, binding = 1) uniform texture2D FRAG_Texture;
The declarations above declare a sampler and a 2D texture. The "set" element in the layout decoration represent the
descriptor set layout defined below. Each set can be associated with multiple bindings. You bind data at the level
of a descriptor set, so it makes sense to group shader resources by the frequency at which they're updated. For
example, you may want to have one descriptor set for global data that is updated once per frame, and then another
descriptor set for data that is updated per object.
*/
/*
This example is using only a single texture. Vulkan supports separate textures and samplers (multiple samplers to 1 texture, for example). Since this
is the more complicated way of doing textures, that's what we're going to do. You can also use a combined image/sampler which might be more useful in
many situations, but that is easy to figure out on your own (hint: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER).
*/
VkDescriptorSetLayoutBinding descriptorSetLayoutBindings_Set0[2];
descriptorSetLayoutBindings_Set0[0].binding = 0; /* The "binding" in "layout(set = 0, binding = 0)" */
descriptorSetLayoutBindings_Set0[0].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER; /* The "sampler" in "uniform sampler FRAG_Sampler" */
descriptorSetLayoutBindings_Set0[0].descriptorCount = 1; /* If you had an array of samplers defined in the shader, you would set this to the size of the array. */
descriptorSetLayoutBindings_Set0[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; /* We're only going to be accessing the sampler from the fragment shader. */
descriptorSetLayoutBindings_Set0[0].pImmutableSamplers = NULL; /* We'll use dynamic samplers for this example, but immutable samplers could be really useful in which case you'd set them here. */
descriptorSetLayoutBindings_Set0[1].binding = 1; /* The "binding" in "layout(set = 0, binding = 1)" */
descriptorSetLayoutBindings_Set0[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; /* The "texture2D" in "uniform texture2D FRAG_Texture". Same thing for texture1D, texture3D and textureCube. */
descriptorSetLayoutBindings_Set0[1].descriptorCount = 1; /* If you had an array of textures defined in the shader, you would set this to the size of the array. */
descriptorSetLayoutBindings_Set0[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; /* We're only going to be accessing the image from the fragment shader. */
descriptorSetLayoutBindings_Set0[1].pImmutableSamplers = NULL; /* Always NULL for images. */
VkDescriptorSetLayoutBinding descriptorSetLayoutBindings_Set1[1];
descriptorSetLayoutBindings_Set1[0].binding = 0; /* The "binding" in "layout(set = 1, binding = 0)" */
descriptorSetLayoutBindings_Set1[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; /* Self explanatory - we're updating a uniform buffer. */
descriptorSetLayoutBindings_Set1[0].descriptorCount = 1; /* Not an array, so set to 1. */
descriptorSetLayoutBindings_Set1[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; /* Descriptor set 1 is only accessed via the vertex buffer. */
descriptorSetLayoutBindings_Set1[0].pImmutableSamplers = NULL; /* No textures are being used in descriptor set 1. */
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo;
descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptorSetLayoutCreateInfo.pNext = NULL;
descriptorSetLayoutCreateInfo.flags = 0;
descriptorSetLayoutCreateInfo.bindingCount = sizeof(descriptorSetLayoutBindings_Set0) / sizeof(descriptorSetLayoutBindings_Set0[0]);
descriptorSetLayoutCreateInfo.pBindings = descriptorSetLayoutBindings_Set0;
VkDescriptorSetLayout descriptorSetLayouts[2];
result = vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCreateInfo, NULL, &descriptorSetLayouts[0]); /* layout(set = 0 ...) */
if (result != VK_SUCCESS) {
printf("Failed to create descriptor set layout 0.");
return -1;
}
descriptorSetLayoutCreateInfo.bindingCount = sizeof(descriptorSetLayoutBindings_Set1) / sizeof(descriptorSetLayoutBindings_Set1[0]);
descriptorSetLayoutCreateInfo.pBindings = descriptorSetLayoutBindings_Set1;
result = vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCreateInfo, NULL, &descriptorSetLayouts[1]); /* layout(set = 1 ...) */
if (result != VK_SUCCESS) {
printf("Failed to create descriptor set layout 1.");
return -1;
}
VkPipelineLayoutCreateInfo pipelineLayoutInfo;
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.pNext = NULL;
pipelineLayoutInfo.flags = 0;
pipelineLayoutInfo.setLayoutCount = sizeof(descriptorSetLayouts) / sizeof(descriptorSetLayouts[0]);
pipelineLayoutInfo.pSetLayouts = descriptorSetLayouts;
pipelineLayoutInfo.pushConstantRangeCount = 0;
pipelineLayoutInfo.pPushConstantRanges = NULL;
VkPipelineLayout pipelineLayout;
result = vkCreatePipelineLayout(device, &pipelineLayoutInfo, NULL, &pipelineLayout);
if (result != VK_SUCCESS) {
printf("Failed to create pipeline layout.");
return 2;
}
/*
Render pass.
*/
VkAttachmentDescription attachmentDesc[2]; /* 1 color attachment, 1 depth/stencil attachment. */
/* Color attachment. */
attachmentDesc[0].flags = 0;
attachmentDesc[0].format = supportedSwapchainImageFormats[swapchainImageFormatIndex].format; /* <-- This needs to be the same as our swapchain image format. */
attachmentDesc[0].samples = VK_SAMPLE_COUNT_1_BIT;
attachmentDesc[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachmentDesc[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentDesc[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachmentDesc[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentDesc[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachmentDesc[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
/* Depth/stencil attachment. */
attachmentDesc[1].flags = 0;
attachmentDesc[1].format = VK_FORMAT_D24_UNORM_S8_UINT;
attachmentDesc[1].samples = VK_SAMPLE_COUNT_1_BIT;
attachmentDesc[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachmentDesc[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentDesc[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachmentDesc[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentDesc[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachmentDesc[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkAttachmentReference colorAttachment;
colorAttachment.attachment = 0; /* Index into attachmentDesc[] */
colorAttachment.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference depthStencilAttachment;
depthStencilAttachment.attachment = 1; /* Index into attachmentDesc[] */
depthStencilAttachment.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpassDesc;
subpassDesc.flags = 0;
subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpassDesc.inputAttachmentCount = 0;
subpassDesc.pInputAttachments = NULL;
subpassDesc.colorAttachmentCount = 1;
subpassDesc.pColorAttachments = &colorAttachment;
subpassDesc.pResolveAttachments = NULL;
subpassDesc.pDepthStencilAttachment = &depthStencilAttachment;
subpassDesc.preserveAttachmentCount = 0; /* Only attachments that are *not* used by this subpass can be specified here. */
subpassDesc.pPreserveAttachments = NULL;
VkRenderPassCreateInfo renderpassInfo;
renderpassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderpassInfo.pNext = NULL;
renderpassInfo.flags = 0;
renderpassInfo.attachmentCount = sizeof(attachmentDesc) / sizeof(attachmentDesc[0]);
renderpassInfo.pAttachments = attachmentDesc;
renderpassInfo.subpassCount = 1;
renderpassInfo.pSubpasses = &subpassDesc;
renderpassInfo.dependencyCount = 0;
renderpassInfo.pDependencies = NULL;
VkRenderPass renderPass;
result = vkCreateRenderPass(device, &renderpassInfo, NULL, &renderPass);
if (result != VK_SUCCESS) {
printf("Failed to create render pass.");
return -2;
}
/*
At this point we finally have everything we need to create the pipeline object. Creating a pipeline object is
slightly different to the creation of most other Vulkan objects. For pipelines, you can actually create multiple
pipeline objects with a single call. In this example we're only using a single pipeline object, but most real-world
projects will require multiple.
*/
VkGraphicsPipelineCreateInfo pipelineInfo;
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.pNext = NULL;
pipelineInfo.flags = 0;
pipelineInfo.stageCount = sizeof(pipelineStages) / sizeof(pipelineStages[0]);
pipelineInfo.pStages = pipelineStages;
pipelineInfo.pVertexInputState = &vertexInputState;
pipelineInfo.pInputAssemblyState = &inputAssemblyState;
pipelineInfo.pTessellationState = NULL; /* <-- Not using tessellation shaders here, so set to NULL. */
pipelineInfo.pViewportState = &viewportState;
pipelineInfo.pRasterizationState = &rasterizationState;
pipelineInfo.pMultisampleState = &multisampleState;
pipelineInfo.pDepthStencilState = &depthStencilState;
pipelineInfo.pColorBlendState = &colorBlendState;
pipelineInfo.pDynamicState = &dynamicState;
pipelineInfo.layout = pipelineLayout;
pipelineInfo.renderPass = renderPass;
pipelineInfo.subpass = 0;
pipelineInfo.basePipelineHandle = 0;
pipelineInfo.basePipelineIndex = 0;
VkPipeline pipeline;
result = vkCreateGraphicsPipelines(device, 0, 1, &pipelineInfo, NULL, &pipeline);
if (result != VK_SUCCESS) {
printf("Failed to create graphics pipeline.");
return -2;
}
/*
In order for Vulkan to know which images to draw to and which images to use for the depth and stencil buffers, we
use a VkFramebuffer object. We need to create one for each swapchain image. In our particular example, we can get
away with just a single depth/stencil buffer. If you were using triple buferring you'd need two (one for each of
the in-progress back buffers).
Since we don't have a depth/stencil buffer yet, we'll need to create one. Fortunately this is a bit simpler than
the creation of a texture which you'll see below because we don't need to worry about copying data.
*/
/*
Like swapchain images, the depth/stencil buffer is made up of both a VkImage and a VkImageView. We'll need to
create the VkImage first, followed by the VkImageView.
*/
VkImageCreateInfo depthStencilImageCreateInfo;
depthStencilImageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
depthStencilImageCreateInfo.pNext = NULL;
depthStencilImageCreateInfo.flags = 0;
depthStencilImageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
depthStencilImageCreateInfo.format = VK_FORMAT_D24_UNORM_S8_UINT; /* <-- Typical depth/stencil format. Should be supported most everywhere. */
depthStencilImageCreateInfo.extent.width = surfaceCaps.currentExtent.width;
depthStencilImageCreateInfo.extent.height = surfaceCaps.currentExtent.height;
depthStencilImageCreateInfo.extent.depth = 1;
depthStencilImageCreateInfo.mipLevels = 1;
depthStencilImageCreateInfo.arrayLayers = 1;
depthStencilImageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
depthStencilImageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
depthStencilImageCreateInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
depthStencilImageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
depthStencilImageCreateInfo.queueFamilyIndexCount = 0;
depthStencilImageCreateInfo.pQueueFamilyIndices = NULL;
depthStencilImageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; /* <-- Will be transitioned to VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL by the render pass. */
VkImage depthStencilImage;
result = vkCreateImage(device, &depthStencilImageCreateInfo, NULL, &depthStencilImage);
if (result != VK_SUCCESS) {
printf("Failed to create depth/stencil image.");
return -1;
}
/*
The image object for the depth/stencil image has been created, but it doesn't yet have any memory allocated for it.
This will be explained in more detail when we get to creating a texture.
*/
VkMemoryRequirements depthStencilImageMemoryReqs;
vkGetImageMemoryRequirements(device, depthStencilImage, &depthStencilImageMemoryReqs);
VkMemoryAllocateInfo depthStencilImageMemoryAllocateInfo;
depthStencilImageMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
depthStencilImageMemoryAllocateInfo.pNext = NULL;
depthStencilImageMemoryAllocateInfo.allocationSize = depthStencilImageMemoryReqs.size;
depthStencilImageMemoryAllocateInfo.memoryTypeIndex = (uint32_t)-1; /* <-- Set to a proper value in the loop below. */
for (uint32_t iMemoryType = 0; iMemoryType < physicalDeviceMemoryProps.memoryTypeCount; iMemoryType += 1) { /* Check each supported memory type. */
if ((depthStencilImageMemoryReqs.memoryTypeBits & (1 << iMemoryType)) != 0) { /* Check if the image memory can be allocated by this memory type. */
if ((physicalDeviceMemoryProps.memoryTypes[iMemoryType].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { /* Check that this memory type supports GPU-side memory (device local). */
depthStencilImageMemoryAllocateInfo.memoryTypeIndex = iMemoryType;
break;
}
}
}
VkDeviceMemory depthStencilImageMemory;
result = vkAllocateMemory(device, &depthStencilImageMemoryAllocateInfo, NULL, &depthStencilImageMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate memory for depth/stencil image.");
return -1;
}
result = vkBindImageMemory(device, depthStencilImage, depthStencilImageMemory, 0);
if (result != VK_SUCCESS) {
printf("Failed to bind memory for depth/stencil image.");
return -1;
}
/*
The image view can only be created after allocating and binding memory for the depth/stencil image. Not doing this
will result in a crash.
*/
VkImageViewCreateInfo depthStencilImageViewCreateInfo;
depthStencilImageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
depthStencilImageViewCreateInfo.pNext = NULL;
depthStencilImageViewCreateInfo.flags = 0;
depthStencilImageViewCreateInfo.image = depthStencilImage;
depthStencilImageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
depthStencilImageViewCreateInfo.format = VK_FORMAT_D24_UNORM_S8_UINT;
depthStencilImageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_R;
depthStencilImageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_G;
depthStencilImageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_B;
depthStencilImageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_A;
depthStencilImageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
depthStencilImageViewCreateInfo.subresourceRange.baseMipLevel = 0;
depthStencilImageViewCreateInfo.subresourceRange.levelCount = 1;
depthStencilImageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
depthStencilImageViewCreateInfo.subresourceRange.layerCount = 1;
VkImageView depthStencilImageView;
result = vkCreateImageView(device, &depthStencilImageViewCreateInfo, NULL, &depthStencilImageView);
if (result != VK_SUCCESS) {
printf("Failed to create depth/stencil image view.");
return -1;
}
/*
We need one framebuffer for each swapchain image, but we can use the same depth/stencil buffer.
*/
VkFramebuffer swapchainFramebuffers[16];
for (uint32_t iSwapchainImage = 0; iSwapchainImage < swapchainImageCount; ++iSwapchainImage) {
VkImageView framebufferAttachments[2];
framebufferAttachments[0] = swapchainImageViews[iSwapchainImage];
framebufferAttachments[1] = depthStencilImageView;
VkFramebufferCreateInfo framebufferInfo;
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.pNext = NULL;
framebufferInfo.flags = 0;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = sizeof(framebufferAttachments)/sizeof(framebufferAttachments[0]);
framebufferInfo.pAttachments = framebufferAttachments;
framebufferInfo.width = surfaceCaps.currentExtent.width;
framebufferInfo.height = surfaceCaps.currentExtent.height;
framebufferInfo.layers = 1; /* <-- I'm not sure in what situation you would set to anything other than 1. */
result = vkCreateFramebuffer(device, &framebufferInfo, NULL, &swapchainFramebuffers[iSwapchainImage]);
if (result != VK_SUCCESS) {
printf("Failed to create framebuffer.");
return -2;
}
}
/*
Here is where we introduce command buffers. We need this before we create our vertex and index buffer and texture
because we need to execute a command for copying memory from system memory to GPU memory (explained later).
This example is only simple so we can get away with using only a single command buffer. Command buffers are created
from a pool called VkCommandPool. When you draw stuff, you first record a list of commands into a command buffer.
These commands are not executed immediately - they're executed later when you submit the command buffer to a queue.
This design allows you to pre-record command buffers at an earlier stage (perhaps at load time) and reuse them
without needing to incur the cost of re-issuing the drawing commands. This system, however, isn't always practical
and sometimes you will want the command buffer to be reset so you can reuse them. This option needs to be specified
at the level of the command pool, which is what we do in this example.
You've probably seen or heard that one of the main points of difference between Vulkan and OpenGL is Vulkan's well
specified multithreading support. Command buffers are where this really starts to become apparent. With Vulkan, you
can record multiple command buffers across different threads. When allocating command buffers across different
threads you would have separate command pools available on a per-thread basis.
*/
VkCommandPoolCreateInfo commandPoolCreateInfo;
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.pNext = NULL;
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; /* <-- Allows us to reuse the same command buffer (though not strictly necessary for this example). */
commandPoolCreateInfo.queueFamilyIndex = selectedQueueFamilyIndex; /* <-- The dreaded queue family needs to be specified for command pools... */
VkCommandPool commandPool;
result = vkCreateCommandPool(device, &commandPoolCreateInfo, NULL, &commandPool);
if (result != VK_SUCCESS) {
printf("Failed to create command pool.");
return -2;
}
/*
Once we have the command pool we can create our command buffers. In our example we only need a single command
which we'll be recording dynamically each frame. You don't need to do it like that - you can instead pre-record
your command buffers and reuse them without being reset, but those command buffers will need to be allocated from
a separate command pool that was created without the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag.
Command buffers can be primary or secondary. Basically, primary command buffers are submitted directly to the queue
whereas secondary command buffers are submitted to a primary command buffer. We're not using secondary command
buffers here, but if you were wanting to use them, you'd use vkCmdExecuteCommands() to record them to a primary
command buffer. There's other details with secondary command buffers which make them particularly useful in
certain situations, such as being able to be used simultaneously by multiple primary command buffers (provided the
necessary flag has been set on the secondary command buffer - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT). I'll
leave this an excercise for you.
*/
VkCommandBufferAllocateInfo commandBufferCreateInfo;
commandBufferCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferCreateInfo.pNext = NULL;
commandBufferCreateInfo.commandPool = commandPool;
commandBufferCreateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferCreateInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
result = vkAllocateCommandBuffers(device, &commandBufferCreateInfo, &commandBuffer);
if (result != VK_SUCCESS) {
printf("Failed to allocate command buffer.");
return -2;
}
/*
Since we are using a reusable command buffer we need to use a fence to synchronize access to it. We cannot be
trying to record some fresh commands into the buffer while it is still in a pending state from the previous frame.
The fence that we create below will be passed into the vkQueueSubmit() which will signal the fence once the buffer
has finished processing.
*/
VkFenceCreateInfo commandBufferFenceCreateInfo;
commandBufferFenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
commandBufferFenceCreateInfo.pNext = NULL;
commandBufferFenceCreateInfo.flags = 0;
VkFence commandBufferFence;
result = vkCreateFence(device, &commandBufferFenceCreateInfo, NULL, &commandBufferFence);
if (result != VK_SUCCESS) {
printf("Failed to create command buffer fence.");
return -1;
}
/*
We'll need a queue before we'll be able to execute any commands. When we created the logical device (VkDevice)
we specified how many queues to make available. Here is were we retrieve it. Note that conceptually these queues
were created internally when we created the device. Here we just retrieve it by an index rather than creating it.
*/
VkQueue queue;
vkGetDeviceQueue(device, selectedQueueFamilyIndex, 0, &queue); /* 0 = queue index. Only using a single queue in this example so will never be anything other than zero. */
/*
Vertex and index buffers.
In this example we'll be storing vertex and index buffers in GPU memory which is probably where you'll want to
store this data in most situations. This involves the use of an intermediary buffer which is allocated to system
memory. Then, a command is used to transfer memory from the intermediary buffer to a device local buffer (GPU
memory). This transfer is why we were needing to allocate a command buffer first. In my testing, vertex and index
buffers don't actually need to be stored in GPU memory, but since it'll be a common thing to do, I'll demonstrate
it in this example.
In this example we're going to use a single VkBuffer for both vertex and index data. The idea is that both can be
used with only a single memory allocation.
The format of your vertex buffer and index buffers must match the format specified when you created the pipeline.
*/
/*
This is our geometry data. This needs to match the format we specified when we created the pipeline. These are the
attributes used for each vertex which are interleaved.
- Position: 3xfloat32
- Color: 3xfloat32
- Texture Coord: 2xfloat32
*/
float geometryVertexData[] = {
-0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, /* Vertex 0 */
-0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, /* Vertex 1 */
0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, /* Vertex 2 */
0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f /* Vertex 3 */
};
/*
This is our index data. These are specified based on the topology that was specified when we created the pipeline,
which in this example is a triangle list. That means each group of 3 indices specify a triangle. Another thing to
consider is the winding, which was also specified when we created the pipeline, which in this example is counter
clockwise.
*/
uint32_t geometryIndexData[] = {
0, 1, 2, 2, 3, 0
};
/*
Before we can copy out vertex and index data over to the GPU we first need to copy it into a staging buffer. The
staging buffer is used as the intermediary between system memory and GPU memory and is just a normal buffer, but
with the appropriate usage mode and a host visible memory allocation.
*/
VkBufferCreateInfo vertexIndexStagingBufferCreateInfo;
vertexIndexStagingBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
vertexIndexStagingBufferCreateInfo.pNext = NULL;
vertexIndexStagingBufferCreateInfo.flags = 0;
vertexIndexStagingBufferCreateInfo.size = sizeof(geometryVertexData) + sizeof(geometryIndexData);
vertexIndexStagingBufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; /* We're going to be using this buffer as the transfer source. */
vertexIndexStagingBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
vertexIndexStagingBufferCreateInfo.queueFamilyIndexCount = 0; /* <-- Ignored when sharingMode is not VK_SHARING_MODE_CONCURRENT. */
vertexIndexStagingBufferCreateInfo.pQueueFamilyIndices = NULL;
VkBuffer vertexIndexStagingBuffer;
result = vkCreateBuffer(device, &vertexIndexStagingBufferCreateInfo, NULL, &vertexIndexStagingBuffer);
if (result != VK_SUCCESS) {
printf("Failed to create vertex/index staging buffer.");
return -1;
}
VkMemoryRequirements vertexIndexStagingBufferMemoryReqs;
vkGetBufferMemoryRequirements(device, vertexIndexStagingBuffer, &vertexIndexStagingBufferMemoryReqs);
VkMemoryAllocateInfo vertexIndexStagingBufferMemoryInfo;
vertexIndexStagingBufferMemoryInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
vertexIndexStagingBufferMemoryInfo.pNext = NULL;
vertexIndexStagingBufferMemoryInfo.allocationSize = vertexIndexStagingBufferMemoryReqs.size;
vertexIndexStagingBufferMemoryInfo.memoryTypeIndex = (uint32_t)-1; /* <-- Set to a proper value below. */
for (uint32_t iMemoryType = 0; iMemoryType < physicalDeviceMemoryProps.memoryTypeCount; ++iMemoryType) {
if ((vertexIndexStagingBufferMemoryReqs.memoryTypeBits & (1 << iMemoryType)) != 0) {
if ((physicalDeviceMemoryProps.memoryTypes[iMemoryType].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) { /* <-- Staging buffer must be host visible. */
vertexIndexStagingBufferMemoryInfo.memoryTypeIndex = iMemoryType;
break;
}
}
}
VkDeviceMemory vertexIndexStagingBufferMemory;
result = vkAllocateMemory(device, &vertexIndexStagingBufferMemoryInfo, NULL, &vertexIndexStagingBufferMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate vertex/index staging buffer memory.");
return -2;
}
result = vkBindBufferMemory(device, vertexIndexStagingBuffer, vertexIndexStagingBufferMemory, 0);
if (result != VK_SUCCESS) {
printf("Failed to bind vertex/index staging buffer memory.");
return -2;
}
/* To get the data from our regular old C buffer into the VkBuffer we just need to map the VkBuffer, memcpy(), then unmap. */
void* pMappedBufferData;
result = vkMapMemory(device, vertexIndexStagingBufferMemory, 0, vertexIndexStagingBufferMemoryReqs.size, 0, &pMappedBufferData);
if (result != VK_SUCCESS) {
printf("Failed to map vertex/index staging buffer.");
return -2;
}
memcpy(pMappedBufferData, geometryVertexData, sizeof(geometryVertexData));
memcpy((void*)(((char*)pMappedBufferData) + sizeof(geometryVertexData)), geometryIndexData, sizeof(geometryIndexData));
vkUnmapMemory(device, vertexIndexStagingBufferMemory);
/* At this point the staging buffer has been set up, so now we need to create the actual GPU-side buffer. */
VkBufferCreateInfo vertexIndexBufferCreateInfo;
vertexIndexBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
vertexIndexBufferCreateInfo.pNext = NULL;
vertexIndexBufferCreateInfo.flags = 0;
vertexIndexBufferCreateInfo.size = sizeof(geometryVertexData) + sizeof(geometryIndexData);
vertexIndexBufferCreateInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
vertexIndexBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
vertexIndexBufferCreateInfo.queueFamilyIndexCount = 0; /* <-- Ignored when sharingMode is not VK_SHARING_MODE_CONCURRENT. */
vertexIndexBufferCreateInfo.pQueueFamilyIndices = NULL;
VkBuffer vertexIndexBuffer;
result = vkCreateBuffer(device, &vertexIndexBufferCreateInfo, NULL, &vertexIndexBuffer);
if (result != VK_SUCCESS) {
printf("Failed to create buffer for geometry.");
return -2;
}
VkMemoryRequirements vertexIndexBufferMemoryReqs;
vkGetBufferMemoryRequirements(device, vertexIndexBuffer, &vertexIndexBufferMemoryReqs);
VkMemoryAllocateInfo vertexIndexBufferMemoryInfo;
vertexIndexBufferMemoryInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
vertexIndexBufferMemoryInfo.pNext = NULL;
vertexIndexBufferMemoryInfo.allocationSize = vertexIndexBufferMemoryReqs.size;
vertexIndexBufferMemoryInfo.memoryTypeIndex = (uint32_t)-1; /* <-- Set to a proper value below. */
for (uint32_t iMemoryType = 0; iMemoryType < physicalDeviceMemoryProps.memoryTypeCount; ++iMemoryType) {
if ((vertexIndexBufferMemoryReqs.memoryTypeBits & (1 << iMemoryType)) != 0) {
if ((physicalDeviceMemoryProps.memoryTypes[iMemoryType].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
vertexIndexBufferMemoryInfo.memoryTypeIndex = iMemoryType;
break;
}
}
}
VkDeviceMemory vertexIndexBufferMemory;
result = vkAllocateMemory(device, &vertexIndexBufferMemoryInfo, NULL, &vertexIndexBufferMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate memory.");
return -2;
}
result = vkBindBufferMemory(device, vertexIndexBuffer, vertexIndexBufferMemory, 0);
if (result != VK_SUCCESS) {
printf("Failed to bind buffer memory.");
return -2;
}
/*
We've created both the staging buffer and the actual buffer, so now we need to transfer. This will be our first use
of the command buffer we created earlier. With the way we're doing things in this example we don't need to worry
about pipeline barriers, however in a real program you'll need to consider this for things such as making sure the
vertex stage of the pipeline does not start until the transfer has completed. Pipeline barriers will be shown when
we get to textures.
*/
{
VkCommandBufferBeginInfo beginInfo;
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.pNext = NULL;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
beginInfo.pInheritanceInfo = NULL;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
{
VkBufferCopy region;
region.srcOffset = 0;
region.dstOffset = 0;
region.size = vertexIndexStagingBufferCreateInfo.size;
vkCmdCopyBuffer(commandBuffer, vertexIndexStagingBuffer, vertexIndexBuffer, 1, ®ion);
}
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = NULL;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = NULL;
submitInfo.pWaitDstStageMask = NULL;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = NULL;
result = vkQueueSubmit(queue, 1, &submitInfo, 0);
if (result != VK_SUCCESS) {
printf("Failed to submit buffer.");
return -2;
}
vkQueueWaitIdle(queue);
}
/* The staging buffer is no longer needed. */
vkDestroyBuffer(device, vertexIndexStagingBuffer, NULL);
vkFreeMemory(device, vertexIndexStagingBufferMemory, NULL);
/*
Textures. Prepare yourself.
In Vulkan, textures are referred to as an Image. In order to apply a texture to a piece of geometry and display it, there's three concepts
to be aware of:
1) Images - Think of this as a handle to the raw image data.
2) Image Views - This is used to retrieve and reinterpret image data.
3) Samplers - This is used by the shader to determine how to apply filtering to the image for display.
Before you can create an image view, you'll need to create the image. Before you can do anything with the image, you need to allocate memory
for it. Once you've allocated the image's memory, you need to fill it with image data which you can do using a staging buffer with host visible
memory. To copy the data from the staging buffer to the image's memory, you need to run a command.
*/
VkImageCreateInfo imageCreateInfo;
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.pNext = NULL;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
imageCreateInfo.extent.width = g_TextureSizeX;
imageCreateInfo.extent.height = g_TextureSizeY;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = 1; /* We're not doing mipmapping in this example, but if we were you'd want to set this to > 1. */
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; /* SAMPLED for shader access, TRANSFER_DST because it'll be the destination for the filling from the staging buffer. */
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.pQueueFamilyIndices = NULL; /* <-- Only used when sharingMode = VK_SHARING_MODE_CONCURRENT. */
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImage image;
result = vkCreateImage(device, &imageCreateInfo, NULL, &image);
if (result != VK_SUCCESS) {
printf("Failed to create image.");
return -1;
}
/*
With the image created we can now allocate some memory for the actual image data and then bind it to the image handle. Not doing this will
result in a crash when creating the image view (and probably anything else that tries to reference the image). Note that allocating memory
does not actually fill it with any meaningful data. That needs to be done afterwards with the use of a staging buffer.
*/
VkMemoryRequirements imageMemoryRequirements;
vkGetImageMemoryRequirements(device, image, &imageMemoryRequirements);
VkMemoryAllocateInfo imageAllocateInfo;
imageAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
imageAllocateInfo.pNext = NULL;
imageAllocateInfo.allocationSize = imageMemoryRequirements.size;
imageAllocateInfo.memoryTypeIndex = (uint32_t)-1; // <-- Set to a proper value below.
for (uint32_t i = 0; i < physicalDeviceMemoryProps.memoryTypeCount; ++i) {
if ((imageMemoryRequirements.memoryTypeBits & (1U << i)) != 0) {
if ((physicalDeviceMemoryProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { /* DEVICE_LOCAL = GPU memory. */
imageAllocateInfo.memoryTypeIndex = i;
break;
}
}
}
VkDeviceMemory imageMemory;
result = vkAllocateMemory(device, &imageAllocateInfo, NULL, &imageMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate image memory.");
return -1;
}
result = vkBindImageMemory(device, image, imageMemory, 0);
if (result != VK_SUCCESS) {
printf("Failed to bind iamge memory.");
return -1;
}
/*
At this point we have created the image handle and allocated some memory for it. We now need to fill the memory with actual image data. To do this
we use a staging buffer and then copy it over using a command.
*/
VkBufferCreateInfo imageStagingBufferCreateInfo;
imageStagingBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
imageStagingBufferCreateInfo.pNext = NULL;
imageStagingBufferCreateInfo.flags = 0;
imageStagingBufferCreateInfo.size = imageAllocateInfo.allocationSize;
imageStagingBufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; /* Will be the source of a transfer. */
imageStagingBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageStagingBufferCreateInfo.queueFamilyIndexCount = 0;
imageStagingBufferCreateInfo.pQueueFamilyIndices = NULL;
VkBuffer imageStagingBuffer;
result = vkCreateBuffer(device, &imageStagingBufferCreateInfo, NULL, &imageStagingBuffer);
if (result != VK_SUCCESS) {
printf("Failed to create staging buffer.");
return -1;
}
/* Allocate memory for the staging buffer. */
vkGetBufferMemoryRequirements(device, imageStagingBuffer, &imageMemoryRequirements);
VkMemoryAllocateInfo imageStagingBufferAllocateInfo;
imageStagingBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
imageStagingBufferAllocateInfo.pNext = NULL;
imageStagingBufferAllocateInfo.allocationSize = imageMemoryRequirements.size;
imageStagingBufferAllocateInfo.memoryTypeIndex = (uint32_t)-1; // <-- Set to a proper value below.
for (uint32_t i = 0; i < physicalDeviceMemoryProps.memoryTypeCount; ++i) {
if ((imageMemoryRequirements.memoryTypeBits & (1U << i)) != 0) {
if ((physicalDeviceMemoryProps.memoryTypes[i].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) == (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
imageStagingBufferAllocateInfo.memoryTypeIndex = i;
break;
}
}
}
VkDeviceMemory imageStagingBufferMemory;
result = vkAllocateMemory(device, &imageStagingBufferAllocateInfo, NULL, &imageStagingBufferMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate memory.");
return -2;
}
/* Memory is allocated for the staging buffer. Now copy our image data into it. */
void* pImageStagedBufferData;
result = vkMapMemory(device, imageStagingBufferMemory, 0, imageMemoryRequirements.size, 0, &pImageStagedBufferData);
if (result != VK_SUCCESS) {
printf("Failed to map staging buffer memory.");
return -2;
}
memcpy(pImageStagedBufferData, g_TextureDataRGBA, sizeof(g_TextureDataRGBA));
vkUnmapMemory(device, imageStagingBufferMemory);
/* The member can now be bound to the buffer. We could have also done this before the map/unmap part. */
vkBindBufferMemory(device, imageStagingBuffer, imageStagingBufferMemory, 0);
/*
At this point we have our image data in our staging buffer. Now we need to copy the data from the staging buffer into the texture. The texture's data
is stored on the GPU (device local), which means we need to do this by running a command (can't just copy from host memory to device memory using
memcpy()). I'm just using the same command object we created earlier.
*/
{
VkCommandBufferBeginInfo beginInfo;
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.pNext = NULL;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
beginInfo.pInheritanceInfo = NULL;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
{
VkImageMemoryBarrier imageMemoryBarrier;
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageMemoryBarrier.pNext = NULL;
imageMemoryBarrier.srcAccessMask = 0; /* <-- Don't need to wait for any memory to be avaialable before starting the transfer. */
imageMemoryBarrier.dstAccessMask = 0; /* <-- As above. */
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.srcQueueFamilyIndex = selectedQueueFamilyIndex;
imageMemoryBarrier.dstQueueFamilyIndex = selectedQueueFamilyIndex;
imageMemoryBarrier.image = image;
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, /* <-- Wait for nothing. */
VK_PIPELINE_STAGE_TRANSFER_BIT, /* <-- Block the transfer stage until our layout transition is complete. */
0,
0, NULL,
0, NULL,
1, &imageMemoryBarrier
);
VkBufferImageCopy region;
region.bufferOffset = 0;
region.bufferRowLength = g_TextureSizeX;
region.bufferImageHeight = g_TextureSizeY;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset.x = 0;
region.imageOffset.y = 0;
region.imageOffset.z = 0;
region.imageExtent.width = g_TextureSizeX;
region.imageExtent.height = g_TextureSizeY;
region.imageExtent.depth = 1;
vkCmdCopyBufferToImage(commandBuffer, imageStagingBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
/*
When the command above has been executed, the image data should have been copied. We now need to transition the image to a layout
usable by the fragment shader.
*/
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; /* <-- Wait for transfer writes to become available. */
imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; /* <-- Make sure memory is available for reading by shaders at the end of the barrier. */
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
imageMemoryBarrier.srcQueueFamilyIndex = selectedQueueFamilyIndex;
imageMemoryBarrier.dstQueueFamilyIndex = selectedQueueFamilyIndex;
imageMemoryBarrier.image = image;
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, /* <-- Wait for the transfer stage to complete. */
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, /* <-- We access this image via the fragment shader, so don't start fragment shading until the transition is complete. This doesn't actually matter for this example, but good practice. */
0,
0, NULL,
0, NULL,
1, &imageMemoryBarrier
);
}
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = NULL;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = NULL;
submitInfo.pWaitDstStageMask = NULL;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = NULL;
result = vkQueueSubmit(queue, 1, &submitInfo, 0);
if (result != VK_SUCCESS) {
printf("Failed to submit buffer.");
return -2;
}
vkQueueWaitIdle(queue);
}
/* The image staging buffer is no longer needed and can be freed. */
vkDestroyBuffer(device, imageStagingBuffer, NULL);
vkFreeMemory(device, imageStagingBufferMemory, NULL);
VkImageViewCreateInfo imageViewCreateInfo;
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.pNext = NULL;
imageViewCreateInfo.flags = 0;
imageViewCreateInfo.image = image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
imageViewCreateInfo.subresourceRange.layerCount = 1;
VkImageView imageView;
result = vkCreateImageView(device, &imageViewCreateInfo, NULL, &imageView);
if (result != VK_SUCCESS) {
printf("Failed to create image view.");
return -1;
}
/* The sampler can be created independently of the image and image view, but we'll need it in order to see the texture when drawing. */
VkSamplerCreateInfo samplerCreateInfo;
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.pNext = NULL;
samplerCreateInfo.flags = 0;
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; /* We're using a low resolution texture of 2x2 so we'll want to use point filtering rather than linear. */
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerCreateInfo.mipLodBias = 0;
samplerCreateInfo.anisotropyEnable = VK_FALSE; /* We're not using anisotropic filtering for this example. */
samplerCreateInfo.maxAnisotropy = 1;
samplerCreateInfo.compareEnable = VK_FALSE;
samplerCreateInfo.compareOp = VK_COMPARE_OP_ALWAYS;
samplerCreateInfo.minLod = 0;
samplerCreateInfo.maxLod = 0;
samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
samplerCreateInfo.unnormalizedCoordinates = VK_FALSE; /* Set to VK_FALSE for [0, 1) range. Set to VK_TRUE for [0, texture width) range. */
VkSampler sampler;
result = vkCreateSampler(device, &samplerCreateInfo, NULL, &sampler);
if (result != VK_SUCCESS) {
printf("Failed to create sampler.");
return -1;
}
/*
Our scene is going to require the use of some uniform variables. This is basically how we pass in application
defined data into shaders. This is an important concept, so I'm including it in this example for completeness.
For uniform buffers to work, you guessed it, we need to allocate another buffer. However, this time it's a bit
simpler (finally!) because we don't need to worry about uploading this to the GPU. In fact, what we're going to
do is permanently map a host visible buffer and make sure it's configured as coherent so that writes to that
memory are immediately visible.
Also, we're going to use dynamic uniform buffers. For each object in the scene, we're just going to use a single
descriptor set, but use a different offset. This simplifies the management of descriptor sets, but does make
alignment a little bit more complicated because we need to ensure uniform buffers are aligned based on the
minUniformBufferOffsetAlignment member of the physical device limits.
*/
VkPhysicalDeviceProperties physicalDeviceProperties;
vkGetPhysicalDeviceProperties(pPhysicalDevices[selectedPhysicalDeviceIndex], &physicalDeviceProperties);
VkDeviceSize uniformBufferSizePerObject = sizeof(float)*4; /* The per-object uniform buffer size is only a 4 dimensional floating point vector. */
VkDeviceSize uniformBufferSizePerObjectAligned = uniformBufferSizePerObject / physicalDeviceProperties.limits.minUniformBufferOffsetAlignment;
if (uniformBufferSizePerObject % physicalDeviceProperties.limits.minUniformBufferOffsetAlignment > 0) {
uniformBufferSizePerObjectAligned += 1;
}
uniformBufferSizePerObjectAligned *= physicalDeviceProperties.limits.minUniformBufferOffsetAlignment;
VkBufferCreateInfo uniformBufferCreateInfo;
uniformBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
uniformBufferCreateInfo.pNext = NULL;
uniformBufferCreateInfo.flags = 0;
uniformBufferCreateInfo.size = uniformBufferSizePerObjectAligned * 2; /* Multiply by two since we are using the same buffer for two objects. */
uniformBufferCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
uniformBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
uniformBufferCreateInfo.queueFamilyIndexCount = 0;
uniformBufferCreateInfo.pQueueFamilyIndices = NULL;
VkBuffer uniformBuffer;
result = vkCreateBuffer(device, &uniformBufferCreateInfo, NULL, &uniformBuffer);
if (result != VK_SUCCESS) {
printf("Failed to create uniform buffer.");
return -1;
}
/*
The backing memory for our uniform buffer can be host visible and coherent. We'll keep this permanently mapped.
*/
VkMemoryRequirements uniformBufferMemoryReqs;
vkGetBufferMemoryRequirements(device, uniformBuffer, &uniformBufferMemoryReqs);
VkMemoryAllocateInfo uniformBufferMemoryAllocateInfo;
uniformBufferMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
uniformBufferMemoryAllocateInfo.pNext = NULL;
uniformBufferMemoryAllocateInfo.allocationSize = uniformBufferMemoryReqs.size;
uniformBufferMemoryAllocateInfo.memoryTypeIndex = (uint32_t)-1; /* Set to a proper value in the loop below. */
for (uint32_t i = 0; i < physicalDeviceMemoryProps.memoryTypeCount; ++i) {
if ((uniformBufferMemoryReqs.memoryTypeBits & (1U << i)) != 0) {
if ((physicalDeviceMemoryProps.memoryTypes[i].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) == (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) {
uniformBufferMemoryAllocateInfo.memoryTypeIndex = i;
break;
}
}
}
VkDeviceMemory uniformBufferMemory;
result = vkAllocateMemory(device, &uniformBufferMemoryAllocateInfo, NULL, &uniformBufferMemory);
if (result != VK_SUCCESS) {
printf("Failed to allocate uniform buffer memory.");
return -1;
}
result = vkBindBufferMemory(device, uniformBuffer, uniformBufferMemory, 0);
if (result != VK_SUCCESS) {
printf("Failed to bind uniform buffer memory.");
return -1;
}
/* Now we can create our permanent mapping. */
void* pUniformBufferData;
result = vkMapMemory(device, uniformBufferMemory, 0, uniformBufferMemoryReqs.size, 0, &pUniformBufferData);
if (result != VK_SUCCESS) {
printf("Failed to map uniform buffer memory.");
return -1;
}
/* We will now declare some pointers for the per-object uniform data. This example has two objects in the scene. */
float* pObjectUniformBuffer[2];
for (size_t iObject = 0; iObject < sizeof(pObjectUniformBuffer) / sizeof(pObjectUniformBuffer[0]); iObject += 1) {
pObjectUniformBuffer[iObject] = (float*)((char*)pUniformBufferData + (iObject * uniformBufferSizePerObjectAligned));
}
/* Set up some per-object data. */
pObjectUniformBuffer[0][0] = -0.4f;
pObjectUniformBuffer[0][1] = -0.4f;
pObjectUniformBuffer[0][2] = 0.0f;
pObjectUniformBuffer[0][3] = 0.0f;
pObjectUniformBuffer[1][0] = 0.4f;
pObjectUniformBuffer[1][1] = 0.4f;
pObjectUniformBuffer[1][2] = 1.0f; /* Put this one (bottom right) behind the other. */
pObjectUniformBuffer[1][3] = 0.0f;
/*
At this point we have the image and the sampler, but we're still not done. We need to actually create the descriptor sets which will eventually be
bound with vkCmdBindDescriptorSets() before we draw our geometry. When we created the pipeline, we specified the *layout* of the descriptor sets,
but now we need to create the actual descriptor sets.
To create the descriptor sets we first need a descritor pool. The descriptor pool is where the descriptor sets are allocated.
*/
VkDescriptorPoolSize descriptorPoolSizes[3];
descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_SAMPLER;
descriptorPoolSizes[0].descriptorCount = 1; /* This example only has 1 sampler. */
descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
descriptorPoolSizes[1].descriptorCount = 1; /* This example only has 1 image. */
descriptorPoolSizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
descriptorPoolSizes[2].descriptorCount = 1; /* This example only has 1 uniform buffer. */
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo;
descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptorPoolCreateInfo.pNext = NULL;
descriptorPoolCreateInfo.flags = 0; /* Could set this to VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT if we wanted to be able to free an individual descriptor set, but we're not doing that in this example. */
descriptorPoolCreateInfo.maxSets = 2; /* We're only going to be allocating two descriptor sets. */
descriptorPoolCreateInfo.poolSizeCount = sizeof(descriptorPoolSizes) / sizeof(descriptorPoolSizes[0]);
descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;
VkDescriptorPool descriptorPool;
result = vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, NULL, &descriptorPool);
if (result != VK_SUCCESS) {
printf("Failed to create descriptor pool.");
return -1;
}
/* We have the descriptor pool, so now we can create our descriptor set. */
VkDescriptorSetLayout descriptorSetLayoutsToAllocate[2]; /* 1 descriptor set for textures, 1 descriptor set for dynamic uniform buffer. */
descriptorSetLayoutsToAllocate[0] = descriptorSetLayouts[0];
descriptorSetLayoutsToAllocate[1] = descriptorSetLayouts[1];
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo;
descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
descriptorSetAllocateInfo.pNext = NULL;
descriptorSetAllocateInfo.descriptorPool = descriptorPool;
descriptorSetAllocateInfo.descriptorSetCount = sizeof(descriptorSetLayoutsToAllocate) / sizeof(descriptorSetLayoutsToAllocate[0]);
descriptorSetAllocateInfo.pSetLayouts = descriptorSetLayoutsToAllocate;
VkDescriptorSet descriptorSets[2];
result = vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, descriptorSets);
if (result != VK_SUCCESS) {
printf("Failed to create descriptor sets.");
return -1;
}
/* We have the descriptor sets, so now we need to associate the images with them. */
VkDescriptorImageInfo descriptorSamplerInfo;
descriptorSamplerInfo.sampler = sampler;
descriptorSamplerInfo.imageView = VK_NULL_HANDLE;
descriptorSamplerInfo.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkDescriptorImageInfo descriptorImageInfo;
descriptorImageInfo.sampler = VK_NULL_HANDLE;
descriptorImageInfo.imageView = imageView;
descriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkWriteDescriptorSet descriptorSetWrites[2];
descriptorSetWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorSetWrites[0].pNext = NULL;
descriptorSetWrites[0].dstSet = descriptorSets[0];
descriptorSetWrites[0].dstBinding = 0;
descriptorSetWrites[0].dstArrayElement = 0;
descriptorSetWrites[0].descriptorCount = 1;
descriptorSetWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
descriptorSetWrites[0].pImageInfo = &descriptorSamplerInfo;
descriptorSetWrites[0].pBufferInfo = NULL;
descriptorSetWrites[0].pTexelBufferView = NULL;
descriptorSetWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorSetWrites[1].pNext = NULL;
descriptorSetWrites[1].dstSet = descriptorSets[0];
descriptorSetWrites[1].dstBinding = 1;
descriptorSetWrites[1].dstArrayElement = 0;
descriptorSetWrites[1].descriptorCount = 1;
descriptorSetWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
descriptorSetWrites[1].pImageInfo = &descriptorImageInfo;
descriptorSetWrites[1].pBufferInfo = NULL;
descriptorSetWrites[1].pTexelBufferView = NULL;
vkUpdateDescriptorSets(device, sizeof(descriptorSetWrites) / sizeof(descriptorSetWrites[0]), descriptorSetWrites, 0, NULL);
VkDescriptorBufferInfo descriptorBufferInfo;
descriptorBufferInfo.buffer = uniformBuffer;
descriptorBufferInfo.offset = 0;
descriptorBufferInfo.range = sizeof(float)*4;
VkWriteDescriptorSet descriptorSetWrites_UBO[1];
descriptorSetWrites_UBO[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorSetWrites_UBO[0].pNext = NULL;
descriptorSetWrites_UBO[0].dstSet = descriptorSets[1];
descriptorSetWrites_UBO[0].dstBinding = 0;
descriptorSetWrites_UBO[0].dstArrayElement = 0;
descriptorSetWrites_UBO[0].descriptorCount = 1;
descriptorSetWrites_UBO[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
descriptorSetWrites_UBO[0].pImageInfo = NULL;
descriptorSetWrites_UBO[0].pBufferInfo = &descriptorBufferInfo;
descriptorSetWrites_UBO[0].pTexelBufferView = NULL;
vkUpdateDescriptorSets(device, sizeof(descriptorSetWrites_UBO) / sizeof(descriptorSetWrites_UBO[0]), descriptorSetWrites_UBO, 0, NULL);
/* Main loop. */
for (;;) {
#ifdef _WIN32
MSG msg;
if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) {
break; /* Received a quit message. */
}
TranslateMessage(&msg);
DispatchMessageA(&msg);
}
#else
/* X11 event handling */
XEvent event;
if (XPending(pDisplay)) {
XNextEvent(pDisplay, &event);
if (event.type == ClientMessage) {
if ((Atom)event.xclient.data.l[0] == wmDeleteMessage) {
break; /* Received a quit message. */
}
} else if (event.type == DestroyNotify) {
break; /* Window was destroyed, probably by the window manager. */
}
}
#endif
uint32_t swapchainImageIndex;
result = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, swapchainSemaphore, VK_NULL_HANDLE, &swapchainImageIndex);
if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
return -1;
}
if (result == VK_ERROR_OUT_OF_DATE_KHR) {
/*
Here is where you might want to recreate the swapchain. I'm not doing this in this here because I want to
keep the code flat and this would require function-izing the swapchain initialization stuff which I don't
want to do in this example.
You may get this error when you try resizing the window. This happens on Nvidia, but not Intel. I have not
tested AMD.
*/
}
VkCommandBufferBeginInfo beginInfo;
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.pNext = NULL;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
beginInfo.pInheritanceInfo = NULL;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
{
VkClearValue clearValues[2];
/* Color attachment. */
clearValues[0].color.float32[0] = 0.2f;
clearValues[0].color.float32[1] = 0;
clearValues[0].color.float32[2] = 0;
clearValues[0].color.float32[3] = 1;
/* Depth/stencil attachment. */
clearValues[1].depthStencil.depth = 1; /* 0 = closer to viewer; 1 = further away. */
clearValues[1].depthStencil.stencil = 0;
VkRenderPassBeginInfo renderpassBeginInfo;
renderpassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderpassBeginInfo.pNext = NULL;
renderpassBeginInfo.renderPass = renderPass;
renderpassBeginInfo.framebuffer = swapchainFramebuffers[swapchainImageIndex];
renderpassBeginInfo.renderArea.offset.x = 0;
renderpassBeginInfo.renderArea.offset.y = 0;
renderpassBeginInfo.renderArea.extent = surfaceCaps.currentExtent;
renderpassBeginInfo.clearValueCount = sizeof(clearValues) / sizeof(clearValues[0]);
renderpassBeginInfo.pClearValues = clearValues;
vkCmdBeginRenderPass(commandBuffer, &renderpassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
{
VkViewport viewport;
viewport.x = 0;
viewport.y = 0;
viewport.width = (float)surfaceCaps.currentExtent.width;
viewport.height = (float)surfaceCaps.currentExtent.height;
viewport.minDepth = 0; /* Careful here. Vulkan does not use the same coordinate system as OpenGL. Requires a clipping matrix to be applied to the projection matrix to get this in the [0..1] range. */
viewport.maxDepth = 1;
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
VkRect2D scissor;
scissor.offset.x = 0;
scissor.offset.y = 0;
scissor.extent.width = surfaceCaps.currentExtent.width;
scissor.extent.height = surfaceCaps.currentExtent.height;
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
/* Bind the pipeline first. You can bind descriptor sets, vertex buffers and index buffers before binding the pipeline, but I like to do the pipeline first. */
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
/* Vertex and index buffers need to be bound before drawing. */
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertexIndexBuffer, &offset);
vkCmdBindIndexBuffer(commandBuffer, vertexIndexBuffer, sizeof(geometryVertexData), VK_INDEX_TYPE_UINT32);
/* We need to bind the descriptor sets before we'll be able to use the texture in the shader. */
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[0], 0, NULL);
/* Object 1. */
uint32_t uniformOffset1 = 0;
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 1, 1, &descriptorSets[1], 1, &uniformOffset1);
/* Only draw once the necessary things have been bound (pipeline, descriptor sets, vertex buffers, index buffers) */
vkCmdDrawIndexed(commandBuffer, sizeof(geometryIndexData) / sizeof(geometryIndexData[0]), 1, 0, 0, 0);
/* Object 2. */
uint32_t uniformOffset2 = (uint32_t)uniformBufferSizePerObjectAligned;
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 1, 1, &descriptorSets[1], 1, &uniformOffset2);
/* Only draw once the necessary things have been bound (pipeline, descriptor sets, vertex buffers, index buffers) */
vkCmdDrawIndexed(commandBuffer, sizeof(geometryIndexData) / sizeof(geometryIndexData[0]), 1, 0, 0, 0);
}
vkCmdEndRenderPass(commandBuffer);
}
result = vkEndCommandBuffer(commandBuffer);
if (result != VK_SUCCESS) {
printf("Command buffer recording failed.");
return -2;
}
VkPipelineStageFlags pWaitDstStageMask[1];
pWaitDstStageMask[0] = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = NULL;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &swapchainSemaphore;
submitInfo.pWaitDstStageMask = pWaitDstStageMask;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &swapchainSemaphore;
result = vkQueueSubmit(queue, 1, &submitInfo, commandBufferFence);
if (result != VK_SUCCESS) {
printf("Failed to submit buffer.");
return -2;
}
/*
In the call above to vkQueueSubmit() we specified a fence that will be signalled when the command buffer has
completed processing. We need to wait on that now so that the next call to vkBeginCommandBuffer() does not
complain about the command buffer being in a pending state. This is only required in our case because we're
reusing the same command buffer.
*/
vkWaitForFences(device, 1, &commandBufferFence, VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &commandBufferFence);
VkPresentInfoKHR info;
info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
info.pNext = NULL;
info.waitSemaphoreCount = 1;
info.pWaitSemaphores = &swapchainSemaphore;
info.swapchainCount = 1;
info.pSwapchains = &swapchain;
info.pImageIndices = &swapchainImageIndex;
info.pResults = NULL;
vkQueuePresentKHR(queue, &info);
}
/*
Teardown. This isn't a complete teardown - you would need to destroy anything that was created with vkCreate*()
and free any memory that was created with vkAllocateMemory() with vkFreeMemory(). Unfortunately the flat nature of
this example just makes this too annoying to deal with so I'm not doing a complete teardown for the sake of
simplicity. Note that the validation layer will result in a bunch of errors being reported at this point due to
devices being uninitialized while other objects are still active. To avoid this, uninitialize your objects in the
correct order.
*/
vkDestroySwapchainKHR(device, swapchain, NULL);
vkDestroyDevice(device, NULL);
vkDestroySurfaceKHR(instance, surface, NULL);
vkDestroyInstance(instance, NULL);
return 0;
}
================================================
FILE: examples/01_Fundamentals/01_Fundamentals.cpp
================================================
#include "01_Fundamentals.c"
================================================
FILE: examples/01_Fundamentals/01_Fundamentals_VFS.c
================================================
#include <string.h>
#include <stdlib.h>
static unsigned char g_vfsFileData[] = {
0x23, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x34, 0x35, 0x30, 0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6F, 0x72, 0x20, 0x73, 0x65, 0x74, 0x73,
0x2E, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x20, 0x75, 0x73, 0x65, 0x73, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x20, 0x74, 0x65, 0x78,
0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x73, 0x2C, 0x20, 0x62, 0x75, 0x74, 0x20, 0x79, 0x6F, 0x75, 0x20, 0x63, 0x61, 0x6E, 0x20,
0x61, 0x6C, 0x73, 0x6F, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x20, 0x63, 0x6F, 0x6D, 0x62, 0x69, 0x6E, 0x65, 0x64, 0x0A, 0x2F, 0x2F, 0x20, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x2F, 0x73,
0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x20, 0x69, 0x66, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x75, 0x69, 0x74, 0x73, 0x20, 0x79, 0x6F, 0x75, 0x72, 0x20, 0x73, 0x63, 0x65, 0x6E, 0x61, 0x72,
0x69, 0x6F, 0x20, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x2E, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x73, 0x65, 0x74, 0x20, 0x3D, 0x20, 0x30, 0x2C, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69,
0x6E, 0x67, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x20, 0x20, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x53,
0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x3B, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x73, 0x65, 0x74, 0x20, 0x3D, 0x20, 0x30, 0x2C, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20,
0x3D, 0x20, 0x31, 0x29, 0x20, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x44, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x74,
0x75, 0x72, 0x65, 0x3B, 0x0A, 0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x46, 0x72, 0x61, 0x67, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x49, 0x6E, 0x70, 0x75, 0x74, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28,
0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x69, 0x6E, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72,
0x3B, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x31, 0x29, 0x20, 0x69, 0x6E, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x46,
0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x3B, 0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x46, 0x72, 0x61, 0x67, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x4F, 0x75, 0x74, 0x70, 0x75,
0x74, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x76, 0x65, 0x63, 0x34, 0x20,
0x4F, 0x55, 0x54, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x3B, 0x0A, 0x0A, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x6D, 0x61, 0x69, 0x6E, 0x28, 0x29, 0x0A, 0x7B, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x4F, 0x55,
0x54, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x20, 0x3D, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x2C, 0x20, 0x31, 0x29, 0x20, 0x2A, 0x20,
0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x28, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x32, 0x44, 0x28, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x2C, 0x20,
0x46, 0x52, 0x41, 0x47, 0x5F, 0x53, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x29, 0x2C, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x29, 0x3B, 0x0A, 0x7D,
0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x06, 0x00,
0x01, 0x00, 0x00, 0x00, 0x47, 0x4C, 0x53, 0x4C, 0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x0F, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00,
0x10, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x00, 0xC2, 0x01, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4F, 0x55, 0x54, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00,
0x0C, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78,
0x74, 0x75, 0x72, 0x65, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x53, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00,
0x05, 0x00, 0x06, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00,
0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x00, 0x00,
0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x0B, 0x00, 0x00, 0x00,
0x0C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x19, 0x00, 0x09, 0x00, 0x13, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x02, 0x00,
0x17, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x20, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00,
0x0A, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x0D, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x0E, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x13, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00,
0x19, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x1D, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x57, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00,
0x07, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00,
0x38, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x34, 0x35, 0x30, 0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x20,
0x49, 0x6E, 0x70, 0x75, 0x74, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x69, 0x6E, 0x20, 0x76, 0x65,
0x63, 0x33, 0x20, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x3B, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F,
0x6E, 0x20, 0x3D, 0x20, 0x31, 0x29, 0x20, 0x69, 0x6E, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x3B, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75,
0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x32, 0x29, 0x20, 0x69, 0x6E, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x54, 0x65, 0x78,
0x43, 0x6F, 0x6F, 0x72, 0x64, 0x3B, 0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x20, 0x4F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x2F, 0x20, 0x46, 0x72, 0x61, 0x67, 0x6D,
0x65, 0x6E, 0x74, 0x20, 0x49, 0x6E, 0x70, 0x75, 0x74, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x6F,
0x75, 0x74, 0x20, 0x76, 0x65, 0x63, 0x33, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x3B, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x6C, 0x6F, 0x63, 0x61, 0x74,
0x69, 0x6F, 0x6E, 0x20, 0x3D, 0x20, 0x31, 0x29, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x76, 0x65, 0x63, 0x32, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x3B,
0x0A, 0x0A, 0x2F, 0x2F, 0x20, 0x55, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, 0x73, 0x0A, 0x6C, 0x61, 0x79, 0x6F, 0x75, 0x74, 0x28, 0x73, 0x65, 0x74, 0x20, 0x3D, 0x20, 0x31, 0x2C, 0x20, 0x62, 0x69,
0x6E, 0x64, 0x69, 0x6E, 0x67, 0x20, 0x3D, 0x20, 0x30, 0x29, 0x20, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72, 0x6D, 0x20, 0x55, 0x42, 0x4F, 0x0A, 0x7B, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63,
0x34, 0x20, 0x4F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x3B, 0x0A, 0x7D, 0x20, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x66, 0x6F, 0x72, 0x6D, 0x3B, 0x0A, 0x0A, 0x76, 0x6F, 0x69, 0x64, 0x20, 0x6D, 0x61, 0x69,
0x6E, 0x28, 0x29, 0x0A, 0x7B, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x20, 0x20, 0x3D, 0x20, 0x76, 0x65, 0x63, 0x34, 0x28, 0x56,
0x45, 0x52, 0x54, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2C, 0x20, 0x31, 0x29, 0x20, 0x2B, 0x20, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x66, 0x6F, 0x72, 0x6D, 0x2E, 0x4F, 0x66, 0x66,
0x73, 0x65, 0x74, 0x3B, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x20, 0x20, 0x20, 0x20, 0x3D, 0x20, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x43, 0x6F,
0x6C, 0x6F, 0x72, 0x3B, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x20, 0x3D, 0x20, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x54, 0x65,
0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x3B, 0x0A, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x2C, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x4C, 0x53, 0x4C, 0x2E, 0x73, 0x74, 0x64, 0x2E, 0x34, 0x35, 0x30,
0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E,
0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00,
0x02, 0x00, 0x00, 0x00, 0xC2, 0x01, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x0B, 0x00, 0x00, 0x00,
0x67, 0x6C, 0x5F, 0x50, 0x65, 0x72, 0x56, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50,
0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x06, 0x00, 0x07, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x50, 0x6F, 0x69, 0x6E, 0x74, 0x53, 0x69, 0x7A, 0x65,
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x43, 0x6C, 0x69, 0x70, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x00,
0x06, 0x00, 0x07, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x67, 0x6C, 0x5F, 0x43, 0x75, 0x6C, 0x6C, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6E, 0x63, 0x65, 0x00, 0x05, 0x00, 0x03, 0x00,
0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x50, 0x6F, 0x73, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x00, 0x00,
0x05, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00, 0x55, 0x42, 0x4F, 0x00, 0x06, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x00, 0x00,
0x05, 0x00, 0x05, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x66, 0x6F, 0x72, 0x6D, 0x00, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x23, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47,
0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x24, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x54, 0x5F, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00,
0x28, 0x00, 0x00, 0x00, 0x46, 0x52, 0x41, 0x47, 0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x54,
0x5F, 0x54, 0x65, 0x78, 0x43, 0x6F, 0x6F, 0x72, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x48, 0x00, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
0x0B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
0x0B, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x19, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1B, 0x00, 0x00, 0x00,
0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00,
0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00,
0x1E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x06, 0x00, 0x0B, 0x00, 0x00, 0x00,
0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
0x3B, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x2B, 0x00, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
0x20, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x2B, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x1E, 0x00, 0x03, 0x00, 0x19, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x1A, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x1C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x22, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00,
0x11, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x27, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
0x29, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x04, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
0x13, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x41, 0x00, 0x05, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00,
0x1D, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00,
0x21, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00,
0x2A, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x03, 0x00, 0x28, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
};
typedef struct
{
const char* pFilePath;
size_t sizeInBytes;
size_t dataOffsetInBytes;
} vfs_file_data;
static vfs_file_data g_vfsCentralDirectory[] = {
{"shaders/01_Fundamentals.glsl.frag", 576, 0},
{"shaders/01_Fundamentals.glsl.frag.spirv", 932, 576},
{"shaders/01_Fundamentals.glsl.vert", 513, 1512},
{"shaders/01_Fundamentals.glsl.vert.spirv", 1416, 2032}
};
static size_t vfs_find_file(const char* pFilePath)
{
size_t iFile;
if (pFilePath == NULL) {
return (size_t)-1;
}
for (iFile = 0; iFile < sizeof(g_vfsCentralDirectory)/sizeof(g_vfsCentralDirectory[0]); iFile += 1) {
int cmpresult = strcmp(g_vfsCentralDirectory[iFile].pFilePath, pFilePath);
if (cmpresult == 0) {
return iFile;
}
}
return (size_t)-1;
}
const void* vfs_map_file(const char* pFilePath, size_t* pFileSizeInBytes)
{
size_t iFile;
if (pFileSizeInBytes != NULL) {
*pFileSizeInBytes = 0;
}
iFile = vfs_find_file(pFilePath);
if (iFile == (size_t)-1) {
return NULL;
}
if (pFileSizeInBytes != NULL) {
*pFileSizeInBytes = g_vfsCentralDirectory[iFile].sizeInBytes;
}
return &g_vfsFileData[g_vfsCentralDirectory[iFile].dataOffsetInBytes];
}
================================================
FILE: examples/01_Fundamentals/resources/shaders/01_Fundamentals.glsl.frag
================================================
#version 450
// Descriptor sets. This example uses separate textures and samplers, but you can also use a combined
// texture/sampler if that suits your scenario better.
layout(set = 0, binding = 0) uniform sampler FRAG_Sampler;
layout(set = 0, binding = 1) uniform texture2D FRAG_Texture;
// Fragment Input
layout(location = 0) in vec3 FRAG_Color;
layout(location = 1) in vec2 FRAG_TexCoord;
// Fragment Output
layout(location = 0) out vec4 OUT_Color;
void main()
{
OUT_Color = vec4(FRAG_Color, 1) * texture(sampler2D(FRAG_Texture, FRAG_Sampler), FRAG_TexCoord);
}
================================================
FILE: examples/01_Fundamentals/resources/shaders/01_Fundamentals.glsl.vert
================================================
#version 450
// Vertex Input
layout(location = 0) in vec3 VERT_Position;
layout(location = 1) in vec3 VERT_Color;
layout(location = 2) in vec2 VERT_TexCoord;
// Vertex Output / Fragment Input
layout(location = 0) out vec3 FRAG_Color;
layout(location = 1) out vec2 FRAG_TexCoord;
// Uniforms
layout(set = 1, binding = 0) uniform UBO
{
vec4 Offset;
} Transform;
void main()
{
gl_Position = vec4(VERT_Position, 1) + Transform.Offset;
FRAG_Color = VERT_Color;
FRAG_TexCoord = VERT_TexCoord;
}
================================================
FILE: resources/README.md
================================================
Vulkan XML: https://github.com/KhronosGroup/Vulkan-Docs/blob/master/xml/vk.xml
================================================
FILE: source/external/tinyxml2.cpp
================================================
/*
Original code by Lee Thomason (www.grinninglizard.com)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
#include "tinyxml2.h"
#include <new> // yes, this one new style header, is in the Android SDK.
#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
# include <stddef.h>
# include <stdarg.h>
#else
# include <cstddef>
# include <cstdarg>
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
// Microsoft Visual Studio, version 2005 and higher. Not WinCE.
/*int _snprintf_s(
char *buffer,
size_t sizeOfBuffer,
size_t count,
const char *format [,
argument] ...
);*/
static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
{
va_list va;
va_start( va, format );
int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
va_end( va );
return result;
}
static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
{
int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
return result;
}
#define TIXML_VSCPRINTF _vscprintf
#define TIXML_SSCANF sscanf_s
#elif defined _MSC_VER
// Microsoft Visual Studio 2003 and earlier or WinCE
#define TIXML_SNPRINTF _snprintf
#define TIXML_VSNPRINTF _vsnprintf
#define TIXML_SSCANF sscanf
#if (_MSC_VER < 1400 ) && (!defined WINCE)
// Microsoft Visual Studio 2003 and not WinCE.
#define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
#else
// Microsoft Visual Studio 2003 and earlier or WinCE.
static inline int TIXML_VSCPRINTF( const char* format, va_list va )
{
int len = 512;
for (;;) {
len = len*2;
char* str = new char[len]();
const int required = _vsnprintf(str, len, format, va);
delete[] str;
if ( required != -1 ) {
TIXMLASSERT( required >= 0 );
len = required;
break;
}
}
TIXMLASSERT( len >= 0 );
return len;
}
#endif
#else
// GCC version 3 and higher
//#warning( "Using sn* functions." )
#define TIXML_SNPRINTF snprintf
#define TIXML_VSNPRINTF vsnprintf
static inline int TIXML_VSCPRINTF( const char* format, va_list va )
{
int len = vsnprintf( 0, 0, format, va );
TIXMLASSERT( len >= 0 );
return len;
}
#define TIXML_SSCANF sscanf
#endif
static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF
static const char LF = LINE_FEED;
static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out
static const char CR = CARRIAGE_RETURN;
static const char SINGLE_QUOTE = '\'';
static const char DOUBLE_QUOTE = '\"';
// Bunch of unicode info at:
// http://www.unicode.org/faq/utf_bom.html
// ef bb bf (Microsoft "lead bytes") - designates UTF-8
static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
namespace tinyxml2
{
struct Entity {
const char* pattern;
int length;
char value;
};
static const int NUM_ENTITIES = 5;
static const Entity entities[NUM_ENTITIES] = {
{ "quot", 4, DOUBLE_QUOTE },
{ "amp", 3, '&' },
{ "apos", 4, SINGLE_QUOTE },
{ "lt", 2, '<' },
{ "gt", 2, '>' }
};
StrPair::~StrPair()
{
Reset();
}
void StrPair::TransferTo( StrPair* other )
{
if ( this == other ) {
return;
}
// This in effect implements the assignment operator by "moving"
// ownership (as in auto_ptr).
TIXMLASSERT( other != 0 );
TIXMLASSERT( other->_flags == 0 );
TIXMLASSERT( other->_start == 0 );
TIXMLASSERT( other->_end == 0 );
other->Reset();
other->_flags = _flags;
other->_start = _start;
other->_end = _end;
_flags = 0;
_start = 0;
_end = 0;
}
void StrPair::Reset()
{
if ( _flags & NEEDS_DELETE ) {
delete [] _start;
}
_flags = 0;
_start = 0;
_end = 0;
}
void StrPair::SetStr( const char* str, int flags )
{
TIXMLASSERT( str );
Reset();
size_t len = strlen( str );
TIXMLASSERT( _start == 0 );
_start = new char[ len+1 ];
memcpy( _start, str, len+1 );
_end = _start + len;
_flags = flags | NEEDS_DELETE;
}
char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
{
TIXMLASSERT( p );
TIXMLASSERT( endTag && *endTag );
TIXMLASSERT(curLineNumPtr);
char* start = p;
char endChar = *endTag;
size_t length = strlen( endTag );
// Inner loop of text parsing.
while ( *p ) {
if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
Set( start, p, strFlags );
return p + length;
} else if (*p == '\n') {
++(*curLineNumPtr);
}
++p;
TIXMLASSERT( p );
}
return 0;
}
char* StrPair::ParseName( char* p )
{
if ( !p || !(*p) ) {
return 0;
}
if ( !XMLUtil::IsNameStartChar( *p ) ) {
return 0;
}
char* const start = p;
++p;
while ( *p && XMLUtil::IsNameChar( *p ) ) {
++p;
}
Set( start, p, 0 );
return p;
}
void StrPair::CollapseWhitespace()
{
// Adjusting _start would cause undefined behavior on delete[]
TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
// Trim leading space.
_start = XMLUtil::SkipWhiteSpace( _start, 0 );
if ( *_start ) {
const char* p = _start; // the read pointer
char* q = _start; // the write pointer
while( *p ) {
if ( XMLUtil::IsWhiteSpace( *p )) {
p = XMLUtil::SkipWhiteSpace( p, 0 );
if ( *p == 0 ) {
break; // don't write to q; this trims the trailing space.
}
*q = ' ';
++q;
}
*q = *p;
++q;
++p;
}
*q = 0;
}
}
const char* StrPair::GetStr()
{
TIXMLASSERT( _start );
TIXMLASSERT( _end );
if ( _flags & NEEDS_FLUSH ) {
*_end = 0;
_flags ^= NEEDS_FLUSH;
if ( _flags ) {
const char* p = _start; // the read pointer
char* q = _start; // the write pointer
while( p < _end ) {
if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
// CR-LF pair becomes LF
// CR alone becomes LF
// LF-CR becomes LF
if ( *(p+1) == LF ) {
p += 2;
}
else {
++p;
}
*q = LF;
++q;
}
else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
if ( *(p+1) == CR ) {
p += 2;
}
else {
++p;
}
*q = LF;
++q;
}
else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
// Entities handled by tinyXML2:
// - special entities in the entity table [in/out]
// - numeric character reference [in]
// 中 or 中
if ( *(p+1) == '#' ) {
const int buflen = 10;
char buf[buflen] = { 0 };
int len = 0;
char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
if ( adjusted == 0 ) {
*q = *p;
++p;
++q;
}
else {
TIXMLASSERT( 0 <= len && len <= buflen );
TIXMLASSERT( q + len <= adjusted );
p = adjusted;
memcpy( q, buf, len );
q += len;
}
}
else {
bool entityFound = false;
for( int i = 0; i < NUM_ENTITIES; ++i ) {
const Entity& entity = entities[i];
if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
&& *( p + entity.length + 1 ) == ';' ) {
// Found an entity - convert.
*q = entity.value;
++q;
p += entity.length + 2;
entityFound = true;
break;
}
}
if ( !entityFound ) {
// fixme: treat as error?
++p;
++q;
}
}
}
else {
*q = *p;
++p;
++q;
}
}
*q = 0;
}
// The loop below has plenty going on, and this
// is a less useful mode. Break it out.
if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
CollapseWhitespace();
}
_flags = (_flags & NEEDS_DELETE);
}
TIXMLASSERT( _start );
return _start;
}
// --------- XMLUtil ----------- //
const char* XMLUtil::writeBoolTrue = "true";
const char* XMLUtil::writeBoolFalse = "false";
void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
{
static const char* defTrue = "true";
static const char* defFalse = "false";
writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
}
const char* XMLUtil::ReadBOM( const char* p, bool* bom )
{
TIXMLASSERT( p );
TIXMLASSERT( bom );
*bom = false;
const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
// Check for BOM:
if ( *(pu+0) == TIXML_UTF_LEAD_0
&& *(pu+1) == TIXML_UTF_LEAD_1
&& *(pu+2) == TIXML_UTF_LEAD_2 ) {
*bom = true;
p += 3;
}
TIXMLASSERT( p );
return p;
}
void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
{
const unsigned long BYTE_MASK = 0xBF;
const unsigned long BYTE_MARK = 0x80;
const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
if (input < 0x80) {
*length = 1;
}
else if ( input < 0x800 ) {
*length = 2;
}
else if ( input < 0x10000 ) {
*length = 3;
}
else if ( input < 0x200000 ) {
*length = 4;
}
else {
*length = 0; // This code won't convert this correctly anyway.
return;
}
output += *length;
// Scary scary fall throughs are annotated with carefully designed comments
// to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
switch (*length) {
case 4:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
//fall through
case 3:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
//fall through
case 2:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
//fall through
case 1:
--output;
*output = (char)(input | FIRST_BYTE_MARK[*length]);
break;
default:
TIXMLASSERT( false );
}
}
const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
{
// Presume an entity, and pull it out.
*length = 0;
if ( *(p+1) == '#' && *(p+2) ) {
unsigned long ucs = 0;
TIXMLASSERT( sizeof( ucs ) >= 4 );
ptrdiff_t delta = 0;
unsigned mult = 1;
static const char SEMICOLON = ';';
if ( *(p+2) == 'x' ) {
// Hexadecimal.
const char* q = p+3;
if ( !(*q) ) {
return 0;
}
q = strchr( q, SEMICOLON );
if ( !q ) {
return 0;
}
TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
while ( *q != 'x' ) {
unsigned int digit = 0;
if ( *q >= '0' && *q <= '9' ) {
digit = *q - '0';
}
else if ( *q >= 'a' && *q <= 'f' ) {
digit = *q - 'a' + 10;
}
else if ( *q >= 'A' && *q <= 'F' ) {
digit = *q - 'A' + 10;
}
else {
return 0;
}
TIXMLASSERT( digit < 16 );
TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
const unsigned int digitScaled = mult * digit;
TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
ucs += digitScaled;
TIXMLASSERT( mult <= UINT_MAX / 16 );
mult *= 16;
--q;
}
}
else {
// Decimal.
const char* q = p+2;
if ( !(*q) ) {
return 0;
}
q = strchr( q, SEMICOLON );
if ( !q ) {
return 0;
}
TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
while ( *q != '#' ) {
if ( *q >= '0' && *q <= '9' ) {
const unsigned int digit = *q - '0';
TIXMLASSERT( digit < 10 );
TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
const unsigned int digitScaled = mult * digit;
TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
ucs += digitScaled;
}
else {
return 0;
}
TIXMLASSERT( mult <= UINT_MAX / 10 );
mult *= 10;
--q;
}
}
// convert the UCS to UTF-8
ConvertUTF32ToUTF8( ucs, value, length );
return p + delta + 1;
}
return p+1;
}
void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
}
void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
}
void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
}
/*
ToStr() of a number is a very tricky topic.
https://github.com/leethomason/tinyxml2/issues/106
*/
void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
}
void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
}
void XMLUtil::ToStr(int64_t v, char* buffer, int bufferSize)
{
// horrible syntax trick to make the compiler happy about %lld
TIXML_SNPRINTF(buffer, bufferSize, "%lld", (long long)v);
}
bool XMLUtil::ToInt( const char* str, int* value )
{
if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
{
if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToBool( const char* str, bool* value )
{
int ival = 0;
if ( ToInt( str, &ival )) {
*value = (ival==0) ? false : true;
return true;
}
if ( StringEqual( str, "true" ) ) {
*value = true;
return true;
}
else if ( StringEqual( str, "false" ) ) {
*value = false;
return true;
}
return false;
}
bool XMLUtil::ToFloat( const char* str, float* value )
{
if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToDouble( const char* str, double* value )
{
if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToInt64(const char* str, int64_t* value)
{
long long v = 0; // horrible syntax trick to make the compiler happy about %lld
if (TIXML_SSCANF(str, "%lld", &v) == 1) {
*value = (int64_t)v;
return true;
}
return false;
}
char* XMLDocument::Identify( char* p, XMLNode** node )
{
TIXMLASSERT( node );
TIXMLASSERT( p );
char* const start = p;
int const startLine = _parseCurLineNum;
p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
if( !*p ) {
*node = 0;
TIXMLASSERT( p );
return p;
}
// These strings define the matching patterns:
static const char* xmlHeader = { "<?" };
static const char* commentHeader = { "<!--" };
static const char* cdataHeader = { "<![CDATA[" };
static const char* dtdHeader = { "<!" };
static const char* elementHeader = { "<" }; // and a header for everything else; check last.
static const int xmlHeaderLen = 2;
static const int commentHeaderLen = 4;
static const int cdataHeaderLen = 9;
static const int dtdHeaderLen = 2;
static const int elementHeaderLen = 1;
TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool
TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
XMLNode* returnNode = 0;
if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += xmlHeaderLen;
}
else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += commentHeaderLen;
}
else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
returnNode = text;
returnNode->_parseLineNum = _parseCurLineNum;
p += cdataHeaderLen;
text->SetCData( true );
}
else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += dtdHeaderLen;
}
else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += elementHeaderLen;
}
else {
returnNode = CreateUnlinkedNode<XMLText>( _textPool );
returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
p = start; // Back it up, all the text counts.
_parseCurLineNum = startLine;
}
TIXMLASSERT( returnNode );
TIXMLASSERT( p );
*node = returnNode;
return p;
}
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
if ( visitor->VisitEnter( *this ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
break;
}
}
}
return visitor->VisitExit( *this );
}
// --------- XMLNode ----------- //
XMLNode::XMLNode( XMLDocument* doc ) :
_document( doc ),
_parent( 0 ),
_value(),
_parseLineNum( 0 ),
_firstChild( 0 ), _lastChild( 0 ),
_prev( 0 ), _next( 0 ),
_userData( 0 ),
_memPool( 0 )
{
}
XMLNode::~XMLNode()
{
DeleteChildren();
if ( _parent ) {
_parent->Unlink( this );
}
}
const char* XMLNode::Value() const
{
// Edge case: XMLDocuments don't have a Value. Return null.
if ( this->ToDocument() )
return 0;
return _value.GetStr();
}
void XMLNode::SetValue( const char* str, bool staticMem )
{
if ( staticMem ) {
_value.SetInternedStr( str );
}
else {
_value.SetStr( str );
}
}
XMLNode* XMLNode::DeepClone(XMLDocument* target) const
{
XMLNode* clone = this->ShallowClone(target);
if (!clone) return 0;
for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
XMLNode* childClone = child->DeepClone(target);
TIXMLASSERT(childClone);
clone->InsertEndChild(childClone);
}
return clone;
}
void XMLNode::DeleteChildren()
{
while( _firstChild ) {
TIXMLASSERT( _lastChild );
DeleteChild( _firstChild );
}
_firstChild = _lastChild = 0;
}
void XMLNode::Unlink( XMLNode* child )
{
TIXMLASSERT( child );
TIXMLASSERT( child->_document == _document );
TIXMLASSERT( child->_parent == this );
if ( child == _firstChild ) {
_firstChild = _firstChild->_next;
}
if ( child == _lastChild ) {
_lastChild = _lastChild->_prev;
}
if ( child->_prev ) {
child->_prev->_next = child->_next;
}
if ( child->_next ) {
child->_next->_prev = child->_prev;
}
child->_next = 0;
child->_prev = 0;
child->_parent = 0;
}
void XMLNode::DeleteChild( XMLNode* node )
{
TIXMLASSERT( node );
TIXMLASSERT( node->_document == _document );
TIXMLASSERT( node->_parent == this );
Unlink( node );
TIXMLASSERT(node->_prev == 0);
TIXMLASSERT(node->_next == 0);
TIXMLASSERT(node->_parent == 0);
DeleteNode( node );
}
XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
InsertChildPreamble( addThis );
if ( _lastChild ) {
TIXMLASSERT( _firstChild );
TIXMLASSERT( _lastChild->_next == 0 );
_lastChild->_next = addThis;
addThis->_prev = _lastChild;
_lastChild = addThis;
addThis->_next = 0;
}
else {
TIXMLASSERT( _firstChild == 0 );
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
addThis->_next = 0;
}
addThis->_parent = this;
return addThis;
}
XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
InsertChildPreamble( addThis );
if ( _firstChild ) {
TIXMLASSERT( _lastChild );
TIXMLASSERT( _firstChild->_prev == 0 );
_firstChild->_prev = addThis;
addThis->_next = _firstChild;
_firstChild = addThis;
addThis->_prev = 0;
}
else {
TIXMLASSERT( _lastChild == 0 );
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
addThis->_next = 0;
}
addThis->_parent = this;
return addThis;
}
XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
TIXMLASSERT( afterThis );
if ( afterThis->_parent != this ) {
TIXMLASSERT( false );
return 0;
}
if ( afterThis == addThis ) {
// Current state: BeforeThis -> AddThis -> OneAfterAddThis
// Now AddThis must disappear from it's location and then
// reappear between BeforeThis and OneAfterAddThis.
// So just leave it where it is.
return addThis;
}
if ( afterThis->_next == 0 ) {
// The last node or the only node.
return InsertEndChild( addThis );
}
InsertChildPreamble( addThis );
addThis->_prev = afterThis;
addThis->_next = afterThis->_next;
afterThis->_next->_prev = addThis;
afterThis->_next = addThis;
addThis->_parent = this;
return addThis;
}
const XMLElement* XMLNode::FirstChildElement( const char* name ) const
{
for( const XMLNode* node = _firstChild; node; node = node->_next ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::LastChildElement( const char* name ) const
{
for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
{
for( const XMLNode* node = _next; node; node = node->_next ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
{
for( const XMLNode* node = _prev; node; node = node->_prev ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
{
// This is a recursive method, but thinking about it "at the current level"
// it is a pretty simple flat list:
// <foo/>
// <!-- comment -->
//
// With a special case:
// <foo>
// </foo>
// <!-- comment -->
//
// Where the closing element (/foo) *must* be the next thing after the opening
// element, and the names must match. BUT the tricky bit is that the closing
// element will be read by the child.
//
// 'endTag' is the end tag for this node, it is returned by a call to a child.
// 'parentEnd' is the end tag for the parent, which is filled in and returned.
XMLDocument::DepthTracker tracker(_document);
if (_document->Error())
return 0;
while( p && *p ) {
XMLNode* node = 0;
p = _document->Identify( p, &node );
TIXMLASSERT( p );
if ( node == 0 ) {
break;
}
int initialLineNum = node->_parseLineNum;
StrPair endTag;
p = node->ParseDeep( p, &endTag, curLineNumPtr );
if ( !p ) {
DeleteNode( node );
if ( !_document->Error() ) {
_document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
}
break;
}
XMLDeclaration* decl = node->ToDeclaration();
if ( decl ) {
// Declarations are only allowed at document level
//
// Multiple declarations are allowed but all declarations
// must occur before anything else.
//
// Optimized due to a security test case. If the first node is
// a declaration, and the last node is a declaration, then only
// declarations have so far been addded.
bool wellLocated = false;
if (ToDocument()) {
if (FirstChild()) {
wellLocated =
FirstChild() &&
FirstChild()->ToDeclaration() &&
LastChild() &&
LastChild()->ToDeclaration();
}
else {
wellLocated = true;
}
}
if ( !wellLocated ) {
_document->SetError( XML_ERROR_PARSING_DECLARATION,
gitextract_0dzrcb8h/ ├── .gitignore ├── CMakeLists.txt ├── README.md ├── examples/ │ └── 01_Fundamentals/ │ ├── 01_Fundamentals.c │ ├── 01_Fundamentals.cpp │ ├── 01_Fundamentals_VFS.c │ └── resources/ │ └── shaders/ │ ├── 01_Fundamentals.glsl.frag │ └── 01_Fundamentals.glsl.vert ├── resources/ │ └── README.md ├── source/ │ ├── external/ │ │ ├── tinyxml2.cpp │ │ └── tinyxml2.h │ ├── vkbind_build.cpp │ └── vkbind_template.h └── vkbind.h
Showing preview only (434K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4124 symbols across 7 files)
FILE: examples/01_Fundamentals/01_Fundamentals.c
function LRESULT (line 102) | static LRESULT DefaultWindowProcWin32(HWND hWnd, UINT msg, WPARAM wParam...
function VKAPI_CALL (line 122) | VKAPI_CALL OnDebugReport(VkDebugReportFlagsEXT flags, VkDebugReportObjec...
function main (line 142) | int main(int argc, char** argv)
FILE: examples/01_Fundamentals/01_Fundamentals_VFS.c
type vfs_file_data (line 115) | typedef struct
function vfs_find_file (line 129) | static size_t vfs_find_file(const char* pFilePath)
FILE: source/external/tinyxml2.cpp
function TIXML_SNPRINTF (line 44) | static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char*...
function TIXML_VSNPRINTF (line 53) | static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char...
function TIXML_VSCPRINTF (line 71) | static inline int TIXML_VSCPRINTF( const char* format, va_list va )
function TIXML_VSCPRINTF (line 94) | static inline int TIXML_VSCPRINTF( const char* format, va_list va )
type tinyxml2 (line 119) | namespace tinyxml2
type Entity (line 122) | struct Entity {
function XMLNode (line 781) | XMLNode* XMLNode::DeepClone(XMLDocument* target) const
function XMLNode (line 841) | XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
function XMLNode (line 871) | XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
function XMLNode (line 902) | XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addTh...
function XMLElement (line 940) | const XMLElement* XMLNode::FirstChildElement( const char* name ) const
function XMLElement (line 952) | const XMLElement* XMLNode::LastChildElement( const char* name ) const
function XMLElement (line 964) | const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
function XMLElement (line 976) | const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) ...
function XMLElement (line 1131) | const XMLElement* XMLNode::ToElementWithName( const char* name ) const
function XMLNode (line 1174) | XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
function XMLNode (line 1223) | XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
function XMLNode (line 1272) | XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
function XMLNode (line 1320) | XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
function XMLError (line 1390) | XMLError XMLAttribute::QueryIntValue( int* value ) const
function XMLError (line 1399) | XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
function XMLError (line 1408) | XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
function XMLError (line 1417) | XMLError XMLAttribute::QueryBoolValue( bool* value ) const
function XMLError (line 1426) | XMLError XMLAttribute::QueryFloatValue( float* value ) const
function XMLError (line 1435) | XMLError XMLAttribute::QueryDoubleValue( double* value ) const
function XMLAttribute (line 1515) | const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
function XMLError (line 1648) | XMLError XMLElement::QueryIntText( int* ival ) const
function XMLError (line 1661) | XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
function XMLError (line 1674) | XMLError XMLElement::QueryInt64Text(int64_t* ival) const
function XMLError (line 1687) | XMLError XMLElement::QueryBoolText( bool* bval ) const
function XMLError (line 1700) | XMLError XMLElement::QueryDoubleText( double* dval ) const
function XMLError (line 1713) | XMLError XMLElement::QueryFloatText( float* fval ) const
function XMLAttribute (line 1768) | XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
function XMLAttribute (line 1884) | XMLAttribute* XMLElement::CreateAttribute()
function XMLNode (line 1927) | XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
function XMLElement (line 2094) | XMLElement* XMLDocument::NewElement( const char* name )
function XMLComment (line 2102) | XMLComment* XMLDocument::NewComment( const char* str )
function XMLText (line 2110) | XMLText* XMLDocument::NewText( const char* str )
function XMLDeclaration (line 2118) | XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
function XMLUnknown (line 2126) | XMLUnknown* XMLDocument::NewUnknown( const char* str )
function FILE (line 2133) | static FILE* callfopen( const char* filepath, const char* mode )
function XMLError (line 2167) | XMLError XMLDocument::LoadFile( const char* filename )
type LongFitsIntoSizeTMinusOne (line 2194) | struct LongFitsIntoSizeTMinusOne {
method Fits (line 2195) | static bool Fits( unsigned long value )
type LongFitsIntoSizeTMinusOne<false> (line 2202) | struct LongFitsIntoSizeTMinusOne<false> {
method Fits (line 2203) | static bool Fits( unsigned long )
function XMLError (line 2209) | XMLError XMLDocument::LoadFile( FILE* fp )
function XMLError (line 2255) | XMLError XMLDocument::SaveFile( const char* filename, bool compact )
function XMLError (line 2274) | XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
function XMLError (line 2285) | XMLError XMLDocument::Parse( const char* p, size_t len )
FILE: source/external/tinyxml2.h
function namespace (line 116) | namespace tinyxml2
function class (line 665) | class TINYXML2_LIB XMLNode
function XMLDocument (line 677) | XMLDocument* GetDocument() {
function virtual (line 683) | virtual XMLElement* ToElement() {
function virtual (line 687) | virtual XMLText* ToText() {
function virtual (line 691) | virtual XMLComment* ToComment() {
function virtual (line 695) | virtual XMLDocument* ToDocument() {
function virtual (line 699) | virtual XMLDeclaration* ToDeclaration() {
function virtual (line 703) | virtual XMLUnknown* ToUnknown() {
function virtual (line 707) | virtual const XMLElement* ToElement() const {
function virtual (line 710) | virtual const XMLText* ToText() const {
function virtual (line 713) | virtual const XMLComment* ToComment() const {
function virtual (line 716) | virtual const XMLDocument* ToDocument() const {
function virtual (line 719) | virtual const XMLDeclaration* ToDeclaration() const {
function virtual (line 722) | virtual const XMLUnknown* ToUnknown() const {
function XMLNode (line 746) | const XMLNode* Parent() const {
function XMLNode (line 750) | XMLNode* Parent() {
function XMLNode (line 760) | const XMLNode* FirstChild() const {
function XMLNode (line 764) | XMLNode* FirstChild() {
function XMLNode (line 778) | const XMLNode* LastChild() const {
function XMLNode (line 782) | XMLNode* LastChild() {
function XMLNode (line 796) | const XMLNode* PreviousSibling() const {
function XMLNode (line 800) | XMLNode* PreviousSibling() {
function XMLNode (line 812) | const XMLNode* NextSibling() const {
function XMLNode (line 816) | XMLNode* NextSibling() {
function XMLNode (line 836) | XMLNode* LinkEndChild( XMLNode* addThis ) {
function SetUserData (line 930) | void SetUserData(void* userData) { _userData = userData; }
function virtual (line 988) | virtual XMLText* ToText() {
function virtual (line 991) | virtual const XMLText* ToText() const {
function SetCData (line 996) | void SetCData( bool isCData ) {
function virtual (line 1009) | virtual ~XMLText() {}
function virtual (line 1029) | virtual const XMLComment* ToComment() const {
function virtual (line 1068) | virtual const XMLDeclaration* ToDeclaration() const {
function virtual (line 1103) | virtual const XMLUnknown* ToUnknown() const {
function class (line 1131) | class TINYXML2_LIB XMLAttribute
function virtual (line 1258) | virtual XMLElement* ToElement() {
function virtual (line 1261) | virtual const XMLElement* ToElement() const {
function XMLError (line 1322) | XMLError QueryIntAttribute( const char* name, int* value ) const {
function XMLError (line 1331) | XMLError QueryUnsignedAttribute( const char* name, unsigned int* value )...
function XMLError (line 1340) | XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
function XMLError (line 1349) | XMLError QueryBoolAttribute( const char* name, bool* value ) const {
function XMLError (line 1357) | XMLError QueryDoubleAttribute( const char* name, double* value ) const {
function XMLError (line 1365) | XMLError QueryFloatAttribute( const char* name, float* value ) const {
function XMLError (line 1374) | XMLError QueryStringAttribute(const char* name, const char** value) const {
function XMLError (line 1402) | XMLError QueryAttribute( const char* name, int* value ) const {
function XMLError (line 1406) | XMLError QueryAttribute( const char* name, unsigned int* value ) const {
function XMLError (line 1410) | XMLError QueryAttribute(const char* name, int64_t* value) const {
function XMLError (line 1414) | XMLError QueryAttribute( const char* name, bool* value ) const {
function XMLError (line 1418) | XMLError QueryAttribute( const char* name, double* value ) const {
function XMLError (line 1422) | XMLError QueryAttribute( const char* name, float* value ) const {
function SetAttribute (line 1427) | void SetAttribute( const char* name, const char* value ) {
function SetAttribute (line 1432) | void SetAttribute( const char* name, int value ) {
function SetAttribute (line 1437) | void SetAttribute( const char* name, unsigned value ) {
function SetAttribute (line 1443) | void SetAttribute(const char* name, int64_t value) {
function SetAttribute (line 1449) | void SetAttribute( const char* name, bool value ) {
function SetAttribute (line 1454) | void SetAttribute( const char* name, double value ) {
function SetAttribute (line 1459) | void SetAttribute( const char* name, float value ) {
function XMLAttribute (line 1470) | const XMLAttribute* FirstAttribute() const {
type ElementClosingType (line 1606) | enum ElementClosingType {
type Whitespace (line 1640) | enum Whitespace {
function virtual (line 1666) | virtual XMLDocument* ToDocument() {
function virtual (line 1670) | virtual const XMLDocument* ToDocument() const {
function SetBOM (line 1738) | void SetBOM( bool useBOM ) {
function XMLElement (line 1745) | XMLElement* RootElement() {
function XMLElement (line 1748) | const XMLElement* RootElement() const {
function ClearError (line 1812) | void ClearError() {
function PrintError (line 1833) | void PrintError() const;
function virtual (line 1862) | virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
function class (line 1901) | class DepthTracker {
function class (line 1988) | class TINYXML2_LIB XMLHandle
function XMLHandle (line 2015) | XMLHandle LastChild() {
function XMLHandle (line 2023) | XMLHandle PreviousSibling() {
function XMLHandle (line 2031) | XMLHandle NextSibling() {
function XMLNode (line 2040) | XMLNode* ToNode() {
function XMLElement (line 2044) | XMLElement* ToElement() {
function XMLText (line 2048) | XMLText* ToText() {
function XMLUnknown (line 2052) | XMLUnknown* ToUnknown() {
function XMLDeclaration (line 2056) | XMLDeclaration* ToDeclaration() {
function class (line 2069) | class TINYXML2_LIB XMLConstHandle
function XMLNode (line 2110) | const XMLNode* ToNode() const {
function XMLElement (line 2113) | const XMLElement* ToElement() const {
function XMLText (line 2116) | const XMLText* ToText() const {
function XMLUnknown (line 2119) | const XMLUnknown* ToUnknown() const {
function XMLDeclaration (line 2122) | const XMLDeclaration* ToDeclaration() const {
function virtual (line 2183) | virtual ~XMLPrinter() {}
function virtual (line 2223) | virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
function ClearBuffer (line 2254) | void ClearBuffer() {
function Write (line 2269) | inline void Write( const char* data ) { Write( data, strlen( d...
FILE: source/vkbind_build.cpp
function vkbLTrim (line 22) | std::string vkbLTrim(const std::string &s)
function vkbRTrim (line 29) | std::string vkbRTrim(const std::string &s)
function vkbTrim (line 36) | std::string vkbTrim(const std::string &s)
function vkbReplaceAll (line 41) | std::string vkbReplaceAll(const std::string &source, const std::string &...
function vkbReplaceAllInline (line 61) | void vkbReplaceAllInline(std::string &source, const std::string &from, c...
function VkbResult (line 69) | VkbResult vkbFOpen(const char* filePath, const char* openMode, FILE** pp...
function VkbResult (line 95) | VkbResult vkbOpenAndReadFileWithExtraData(const char* filePath, size_t* ...
function VkbResult (line 153) | VkbResult vkbOpenAndReadFile(const char* filePath, size_t* pFileSizeOut,...
function VkbResult (line 158) | VkbResult vkbOpenAndReadTextFile(const char* filePath, size_t* pFileSize...
function VkbResult (line 182) | VkbResult vkbOpenAndWriteFile(const char* filePath, const void* pData, s...
function VkbResult (line 207) | VkbResult vkbOpenAndWriteTextFile(const char* filePath, const char* text)
type vkbBuildPlatform (line 220) | struct vkbBuildPlatform
type vkbBuildTag (line 226) | struct vkbBuildTag
type vkbBuildFunctionParameter (line 233) | struct vkbBuildFunctionParameter
type vkbBuildFunctionPointer (line 244) | struct vkbBuildFunctionPointer
type vkbBuildStructMember (line 251) | struct vkbBuildStructMember
type vkbBuildStruct (line 266) | struct vkbBuildStruct
type vkbBuildType (line 271) | struct vkbBuildType
type vkbBuildEnum (line 288) | struct vkbBuildEnum
type vkbBuildEnums (line 296) | struct vkbBuildEnums
type vkbBuildCommand (line 303) | struct vkbBuildCommand
type vkbBuildRequireType (line 315) | struct vkbBuildRequireType
type vkbBuildRequireEnum (line 320) | struct vkbBuildRequireEnum
type vkbBuildRequireCommand (line 333) | struct vkbBuildRequireCommand
type vkbBuildRequire (line 338) | struct vkbBuildRequire
type vkbBuildFeature (line 348) | struct vkbBuildFeature
type vkbBuildExtension (line 357) | struct vkbBuildExtension
type VkbBuild (line 372) | struct VkbBuild
type CodeGenConfig (line 382) | struct CodeGenConfig
method CodeGenConfig (line 384) | CodeGenConfig()
function VkbResult (line 395) | VkbResult vkbBuildParsePlatforms(VkbBuild &context, tinyxml2::XMLElement...
function VkbResult (line 420) | VkbResult vkbBuildParseTags(VkbBuild &context, tinyxml2::XMLElement* pTa...
function VkbResult (line 440) | VkbResult vkbBuildParseTypeNamePair(std::string &typeC, std::string &typ...
function VkbResult (line 507) | VkbResult vkbBuildParseStructMember(vkbBuildStructMember &member, tinyxm...
function VkbResult (line 552) | VkbResult vkbBuildParseTypes(VkbBuild &context, tinyxml2::XMLElement* pT...
function VkbResult (line 712) | VkbResult vkbBuildParseEnums(VkbBuild &context, tinyxml2::XMLElement* pE...
function VkbResult (line 771) | VkbResult vkbBuildParseCommandProto(vkbBuildCommand &command, tinyxml2::...
function VkbResult (line 787) | VkbResult vkbBuildParseCommandParam(vkbBuildFunctionParameter ¶m, ti...
function VkbResult (line 807) | VkbResult vkbBuildParseCommand(vkbBuildCommand &command, tinyxml2::XMLEl...
function VkbResult (line 858) | VkbResult vkbBuildParseCommands(VkbBuild &context, tinyxml2::XMLElement*...
function VkbResult (line 881) | VkbResult vkbBuildParseRequireType(vkbBuildRequireType &type, tinyxml2::...
function VkbResult (line 895) | VkbResult vkbBuildParseRequireEnum(vkbBuildRequireEnum &theEnum, tinyxml...
function VkbResult (line 924) | VkbResult vkbBuildParseRequireCommand(vkbBuildRequireCommand &command, t...
function VkbResult (line 938) | VkbResult vkbBuildParseRequire(vkbBuildRequire &require, tinyxml2::XMLEl...
function VkbResult (line 978) | VkbResult vkbBuildParseFeature(VkbBuild &context, tinyxml2::XMLElement* ...
function VkbResult (line 1014) | VkbResult vkbBuildParseExtension(VkbBuild &context, tinyxml2::XMLElement...
function VkbResult (line 1080) | VkbResult vkbBuildParseExtensions(VkbBuild &context, tinyxml2::XMLElemen...
function vkbBuildFindTypeByName (line 1099) | bool vkbBuildFindTypeByName(VkbBuild &context, const char* name, size_t*...
function vkbBuildFindEnumByName (line 1117) | bool vkbBuildFindEnumByName(VkbBuild &context, const char* name, size_t*...
function vkbBuildFindEnumValue (line 1135) | bool vkbBuildFindEnumValue(VkbBuild &context, const std::string &name, v...
function vkbBuildFindCommandByName (line 1197) | bool vkbBuildFindCommandByName(VkbBuild &context, const char* name, size...
function vkbBuildFindExtensionByName (line 1215) | bool vkbBuildFindExtensionByName(VkbBuild &context, const char* name, si...
function vkbBuildCleanDefineValue (line 1233) | std::string vkbBuildCleanDefineValue(const std::string &value)
function vkbContains (line 1271) | bool vkbContains(const std::vector<T> &list, T value)
function vkbPriorFeatureContainsType (line 1277) | bool vkbPriorFeatureContainsType(std::vector<std::vector<size_t>> &types...
function vkbPriorFeatureContainsEnum (line 1288) | bool vkbPriorFeatureContainsEnum(std::vector<std::vector<size_t>> &enums...
function VkbResult (line 1300) | VkbResult vkbBuildAddEnumDependencies(VkbBuild &context, const char* enu...
function VkbResult (line 1319) | VkbResult vkbBuildAddTypeDependencies(VkbBuild &context, const char* typ...
function VkbResult (line 1386) | VkbResult vkbBuildAddCommandDependencies(VkbBuild &context, const char* ...
function vkbBuildCalculateExtensionEnumValue (line 1407) | std::string vkbBuildCalculateExtensionEnumValue(vkbBuildRequireEnum &req...
function vkbBuildCalculateExtensionEnumValue (line 1417) | std::string vkbBuildCalculateExtensionEnumValue(vkbBuildRequireEnum &req...
function vkbBuildBitPosToHexString (line 1422) | std::string vkbBuildBitPosToHexString(int bitpos)
function vkbBuildBitPosToHexStringEx (line 1437) | std::string vkbBuildBitPosToHexStringEx(int bitpos, const std::string &t...
type vkbBuildCodeGenDependencies (line 1459) | struct vkbBuildCodeGenDependencies
method VkbResult (line 1465) | VkbResult ParseFeatureDependencies(VkbBuild &context, vkbBuildFeature ...
method VkbResult (line 1479) | VkbResult ParseExtensionDependencies(VkbBuild &context, vkbBuildExtens...
method VkbResult (line 1493) | VkbResult ParseRequire(VkbBuild &context, vkbBuildRequire &require)
type vkbBuildCodeGenState (line 1510) | struct vkbBuildCodeGenState
method HasOutputDefine (line 1519) | bool HasOutputDefine(const std::string &name) const
method HasOutputType (line 1524) | bool HasOutputType(const std::string &name) const
method HasOutputCommand (line 1529) | bool HasOutputCommand(const std::string &name) const
method HasOutputInitializer (line 1534) | bool HasOutputInitializer(const std::string &name) const
method MarkDefineAsOutput (line 1540) | void MarkDefineAsOutput(const std::string &name)
method MarkTypeAsOutput (line 1546) | void MarkTypeAsOutput(const std::string &name)
method MarkCommandAsOutput (line 1552) | void MarkCommandAsOutput(const std::string &name)
method MarkInitializerAsOutput (line 1558) | void MarkInitializerAsOutput(const std::string &name)
function VkbResult (line 1565) | VkbResult vkbBuildGenerateCode_C_DependencyIncludes(VkbBuild &context, v...
function VkbResult (line 1608) | VkbResult vkbBuildGenerateCode_C_RequireDefineEnums(VkbBuild &context, v...
function VkbResult (line 1627) | VkbResult vkbBuildGenerateCode_C_Function(const std::string &returnTypeC...
function VkbResult (line 1651) | VkbResult vkbBuildGenerateCode_C_Command(vkbBuildCommand &command, const...
function VkbResult (line 1656) | VkbResult vkbBuildGenerateCode_C_FuncPointer(vkbBuildFunctionPointer &fu...
function VkbResult (line 1661) | VkbResult vkbBuildGenerateCode_C_RequireCommands(VkbBuild &context, vkbB...
function vkbToUpper (line 1690) | std::string vkbToUpper(const std::string &str)
function vkbNameToUpperCaseStyle (line 1702) | std::string vkbNameToUpperCaseStyle(const std::string &name)
function vkbExtractTagFromName (line 1719) | std::string vkbExtractTagFromName(VkbBuild &context, const std::string &...
function vkbGenerateMaxEnumToken (line 1733) | std::string vkbGenerateMaxEnumToken(VkbBuild &context, const std::string...
function VkbResult (line 1752) | VkbResult vkbBuildGenerateCode_C_Dependencies(VkbBuild &context, vkbBuil...
function VkbResult (line 2242) | VkbResult vkbBuildGenerateCode_C_StructInitializers(VkbBuild &context, v...
function VkbResult (line 2279) | VkbResult vkbBuildGenerateCode_C_AllStructInitializers(VkbBuild &context...
function VkbResult (line 2362) | VkbResult vkbBuildGenerateCode_C_Feature(VkbBuild &context, vkbBuildCode...
function VkbResult (line 2403) | VkbResult vkbBuildGenerateCode_C_Extension(VkbBuild &context, vkbBuildCo...
function VkbResult (line 2469) | VkbResult vkbBuildReorderExtensions(VkbBuild &context)
function VkbResult (line 2494) | VkbResult vkbBuildGenerateCode_C_Main(VkbBuild &context, std::string &co...
function VkbResult (line 2586) | VkbResult vkbBuildGenerateCode_C_FuncPointersDeclGlobal(VkbBuild &contex...
function VkbResult (line 2699) | VkbResult vkbBuildGenerateCode_C_LoadVulkanFuncPointers(VkbBuild &contex...
function VkbResult (line 2787) | VkbResult vkbBuildGenerateCode_C_SetStructAPIFromGlobal(VkbBuild &contex...
function VkbResult (line 2876) | VkbResult vkbBuildGenerateCode_C_SetGlobalAPIFromStruct(VkbBuild &contex...
function VkbResult (line 2965) | VkbResult vkbBuildGenerateCode_C_LoadInstanceAPI(VkbBuild &context, std:...
function vkbBuildIsTypeChildOf (line 3051) | bool vkbBuildIsTypeChildOf(VkbBuild &context, const std::string &parentT...
function vkbBuildGetDeviceProcAddressGetterByType (line 3076) | std::string vkbBuildGetDeviceProcAddressGetterByType(VkbBuild &context, ...
function vkbBuildGetDeviceProcAddressGetterByCommand (line 3086) | std::string vkbBuildGetDeviceProcAddressGetterByCommand(VkbBuild &contex...
function vkbBuildIsDeviceLevelCommand (line 3107) | bool vkbBuildIsDeviceLevelCommand(VkbBuild &context, vkbBuildCommand &co...
function vkbBuildIsInstanceLevelCommand (line 3132) | bool vkbBuildIsInstanceLevelCommand(VkbBuild &context, vkbBuildCommand &...
function VkbResult (line 3157) | VkbResult vkbBuildGenerateCode_C_LoadDeviceAPI(VkbBuild &context, std::s...
function VkbResult (line 3243) | VkbResult vkbBuildGenerateCode_C_LoadSafeVulkanAPI(VkbBuild &context, st...
function VkbResult (line 3274) | VkbResult vkbBuildGenerateCode_C_SafeGlobalAPIDocs(VkbBuild &context, st...
function vkbSplitString (line 3316) | std::vector<std::string> vkbSplitString(const std::string &str, const st...
function VkbResult (line 3335) | VkbResult vkbBuildGetVulkanVersion(VkbBuild &context, std::string &versi...
function VkbResult (line 3366) | VkbResult vkbBuildGenerateCode_C_VulkanVersion(VkbBuild &context, std::s...
function VkbResult (line 3379) | VkbResult vkbBuildGenerateCode_C_Revision(VkbBuild &context, std::string...
function VkbResult (line 3445) | VkbResult vkbBuildGenerateCode_C_Date(VkbBuild &context, std::string &co...
function VkbResult (line 3465) | VkbResult vkbBuildGenerateCode_C(VkbBuild &vk, VkbBuild &video, const ch...
function VkbResult (line 3524) | VkbResult vkbBuildGenerateLib_C(VkbBuild &vk, VkbBuild &video, const cha...
function VkbResult (line 3576) | static VkbResult vkbBuildStateInit(const char* pXMLFilePath, VkbBuild &c...
function VkbResult (line 3634) | static VkbResult GenerateHeaders_Video(VkbBuild &context)
function main (line 3663) | int main(int argc, char** argv)
FILE: source/vkbind_template.h
type Display (line 180) | typedef Display vkbind_Display;
type Window (line 181) | typedef Window vkbind_Window;
type VisualID (line 182) | typedef VisualID vkbind_VisualID;
type vkbind_Window (line 185) | typedef unsigned long vkbind_Window;
type vkbind_VisualID (line 186) | typedef unsigned long vkbind_VisualID;
type VkbAPI (line 204) | typedef struct
function VkbHandle (line 290) | static VkbHandle vkb_dlopen(const char* filename)
function vkb_dlclose (line 299) | static void vkb_dlclose(VkbHandle handle)
function VkbProc (line 308) | static VkbProc vkb_dlsym(VkbHandle handle, const char* symbol)
function VkResult (line 328) | static VkResult vkbLoadVulkanSO(void)
function VkResult (line 364) | static VkResult vkbLoadVulkanSymbols(VkbAPI* pAPI)
function vkbInitFromGlobalAPI (line 382) | static void vkbInitFromGlobalAPI(VkbAPI* pAPI)
function VkResult (line 388) | VkResult vkbInit(VkbAPI* pAPI)
function vkbUninit (line 450) | void vkbUninit(void)
function VkResult (line 463) | VkResult vkbInitInstanceAPI(VkInstance instance, VkbAPI* pAPI)
function VkResult (line 494) | VkResult vkbInitDeviceAPI(VkDevice device, VkbAPI* pAPI)
function VkResult (line 523) | VkResult vkbBindAPI(const VkbAPI* pAPI)
FILE: vkbind.h
type Display (line 180) | typedef Display vkbind_Display;
type Window (line 181) | typedef Window vkbind_Window;
type VisualID (line 182) | typedef VisualID vkbind_VisualID;
type vkbind_Window (line 185) | typedef unsigned long vkbind_Window;
type vkbind_VisualID (line 186) | typedef unsigned long vkbind_VisualID;
type StdVideoH264ChromaFormatIdc (line 211) | typedef enum
type StdVideoH264ProfileIdc (line 221) | typedef enum
type StdVideoH264LevelIdc (line 231) | typedef enum
type StdVideoH264PocType (line 256) | typedef enum
type StdVideoH264AspectRatioIdc (line 265) | typedef enum
type StdVideoH264WeightedBipredIdc (line 289) | typedef enum
type StdVideoH264ModificationOfPicNumsIdc (line 298) | typedef enum
type StdVideoH264MemMgmtControlOp (line 308) | typedef enum
type StdVideoH264CabacInitIdc (line 321) | typedef enum
type StdVideoH264DisableDeblockingFilterIdc (line 330) | typedef enum
type StdVideoH264SliceType (line 339) | typedef enum
type StdVideoH264PictureType (line 348) | typedef enum
type StdVideoH264NonVclNaluType (line 358) | typedef enum
type StdVideoH264SpsVuiFlags (line 372) | typedef struct StdVideoH264SpsVuiFlags
type StdVideoH264HrdParameters (line 388) | typedef struct StdVideoH264HrdParameters
type StdVideoH264SequenceParameterSetVui (line 403) | typedef struct StdVideoH264SequenceParameterSetVui
type StdVideoH264SpsFlags (line 423) | typedef struct StdVideoH264SpsFlags
type StdVideoH264ScalingLists (line 443) | typedef struct StdVideoH264ScalingLists
type StdVideoH264SequenceParameterSet (line 451) | typedef struct StdVideoH264SequenceParameterSet
type StdVideoH264PpsFlags (line 480) | typedef struct StdVideoH264PpsFlags
type StdVideoH264PictureParameterSet (line 492) | typedef struct StdVideoH264PictureParameterSet
type StdVideoDecodeH264FieldOrderCount (line 515) | typedef enum
type StdVideoDecodeH264PictureInfoFlags (line 524) | typedef struct StdVideoDecodeH264PictureInfoFlags
type StdVideoDecodeH264PictureInfo (line 534) | typedef struct StdVideoDecodeH264PictureInfo
type StdVideoDecodeH264ReferenceInfoFlags (line 546) | typedef struct StdVideoDecodeH264ReferenceInfoFlags
type StdVideoDecodeH264ReferenceInfo (line 554) | typedef struct StdVideoDecodeH264ReferenceInfo
type StdVideoEncodeH264WeightTableFlags (line 569) | typedef struct StdVideoEncodeH264WeightTableFlags
type StdVideoEncodeH264WeightTable (line 577) | typedef struct StdVideoEncodeH264WeightTable
type StdVideoEncodeH264SliceHeaderFlags (line 592) | typedef struct StdVideoEncodeH264SliceHeaderFlags
type StdVideoEncodeH264PictureInfoFlags (line 599) | typedef struct StdVideoEncodeH264PictureInfoFlags
type StdVideoEncodeH264ReferenceInfoFlags (line 609) | typedef struct StdVideoEncodeH264ReferenceInfoFlags
type StdVideoEncodeH264ReferenceListsInfoFlags (line 615) | typedef struct StdVideoEncodeH264ReferenceListsInfoFlags
type StdVideoEncodeH264RefListModEntry (line 622) | typedef struct StdVideoEncodeH264RefListModEntry
type StdVideoEncodeH264RefPicMarkingEntry (line 629) | typedef struct StdVideoEncodeH264RefPicMarkingEntry
type StdVideoEncodeH264ReferenceListsInfo (line 638) | typedef struct StdVideoEncodeH264ReferenceListsInfo
type StdVideoEncodeH264PictureInfo (line 654) | typedef struct StdVideoEncodeH264PictureInfo
type StdVideoEncodeH264ReferenceInfo (line 668) | typedef struct StdVideoEncodeH264ReferenceInfo
type StdVideoEncodeH264SliceHeader (line 679) | typedef struct StdVideoEncodeH264SliceHeader
type StdVideoH265ChromaFormatIdc (line 719) | typedef enum
type StdVideoH265ProfileIdc (line 729) | typedef enum
type StdVideoH265LevelIdc (line 740) | typedef enum
type StdVideoH265SliceType (line 759) | typedef enum
type StdVideoH265PictureType (line 768) | typedef enum
type StdVideoH265AspectRatioIdc (line 778) | typedef enum
type StdVideoH265DecPicBufMgr (line 803) | typedef struct StdVideoH265DecPicBufMgr
type StdVideoH265SubLayerHrdParameters (line 810) | typedef struct StdVideoH265SubLayerHrdParameters
type StdVideoH265HrdFlags (line 819) | typedef struct StdVideoH265HrdFlags
type StdVideoH265HrdParameters (line 830) | typedef struct StdVideoH265HrdParameters
type StdVideoH265VpsFlags (line 849) | typedef struct StdVideoH265VpsFlags
type StdVideoH265ProfileTierLevelFlags (line 857) | typedef struct StdVideoH265ProfileTierLevelFlags
type StdVideoH265ProfileTierLevel (line 866) | typedef struct StdVideoH265ProfileTierLevel
type StdVideoH265VideoParameterSet (line 873) | typedef struct StdVideoH265VideoParameterSet
type StdVideoH265ScalingLists (line 889) | typedef struct StdVideoH265ScalingLists
type StdVideoH265SpsVuiFlags (line 899) | typedef struct StdVideoH265SpsVuiFlags
type StdVideoH265SequenceParameterSetVui (line 921) | typedef struct StdVideoH265SequenceParameterSetVui
type StdVideoH265PredictorPaletteEntries (line 951) | typedef struct StdVideoH265PredictorPaletteEntries
type StdVideoH265SpsFlags (line 956) | typedef struct StdVideoH265SpsFlags
type StdVideoH265ShortTermRefPicSetFlags (line 990) | typedef struct StdVideoH265ShortTermRefPicSetFlags
type StdVideoH265ShortTermRefPicSet (line 996) | typedef struct StdVideoH265ShortTermRefPicSet
type StdVideoH265LongTermRefPicsSps (line 1014) | typedef struct StdVideoH265LongTermRefPicsSps
type StdVideoH265SequenceParameterSet (line 1020) | typedef struct StdVideoH265SequenceParameterSet
type StdVideoH265PpsFlags (line 1063) | typedef struct StdVideoH265PpsFlags
type StdVideoH265PictureParameterSet (line 1098) | typedef struct StdVideoH265PictureParameterSet
type StdVideoDecodeH265PictureInfoFlags (line 1146) | typedef struct StdVideoDecodeH265PictureInfoFlags
type StdVideoDecodeH265PictureInfo (line 1154) | typedef struct StdVideoDecodeH265PictureInfo
type StdVideoDecodeH265ReferenceInfoFlags (line 1169) | typedef struct StdVideoDecodeH265ReferenceInfoFlags
type StdVideoDecodeH265ReferenceInfo (line 1175) | typedef struct StdVideoDecodeH265ReferenceInfo
type StdVideoEncodeH265WeightTableFlags (line 1188) | typedef struct StdVideoEncodeH265WeightTableFlags
type StdVideoEncodeH265WeightTable (line 1196) | typedef struct StdVideoEncodeH265WeightTable
type StdVideoEncodeH265SliceSegmentHeaderFlags (line 1211) | typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags
type StdVideoEncodeH265SliceSegmentHeader (line 1228) | typedef struct StdVideoEncodeH265SliceSegmentHeader
type StdVideoEncodeH265ReferenceListsInfoFlags (line 1247) | typedef struct StdVideoEncodeH265ReferenceListsInfoFlags
type StdVideoEncodeH265ReferenceListsInfo (line 1254) | typedef struct StdVideoEncodeH265ReferenceListsInfo
type StdVideoEncodeH265PictureInfoFlags (line 1265) | typedef struct StdVideoEncodeH265PictureInfoFlags
type StdVideoEncodeH265LongTermRefPics (line 1279) | typedef struct StdVideoEncodeH265LongTermRefPics
type StdVideoEncodeH265PictureInfo (line 1290) | typedef struct StdVideoEncodeH265PictureInfo
type StdVideoEncodeH265ReferenceInfoFlags (line 1306) | typedef struct StdVideoEncodeH265ReferenceInfoFlags
type StdVideoEncodeH265ReferenceInfo (line 1313) | typedef struct StdVideoEncodeH265ReferenceInfo
type StdVideoVP9Profile (line 1332) | typedef enum
type StdVideoVP9Level (line 1342) | typedef enum
type StdVideoVP9FrameType (line 1362) | typedef enum
type StdVideoVP9ReferenceName (line 1370) | typedef enum
type StdVideoVP9InterpolationFilter (line 1380) | typedef enum
type StdVideoVP9ColorSpace (line 1391) | typedef enum
type StdVideoVP9ColorConfigFlags (line 1406) | typedef struct StdVideoVP9ColorConfigFlags
type StdVideoVP9ColorConfig (line 1412) | typedef struct StdVideoVP9ColorConfig
type StdVideoVP9LoopFilterFlags (line 1422) | typedef struct StdVideoVP9LoopFilterFlags
type StdVideoVP9LoopFilter (line 1429) | typedef struct StdVideoVP9LoopFilter
type StdVideoVP9SegmentationFlags (line 1440) | typedef struct StdVideoVP9SegmentationFlags
type StdVideoVP9Segmentation (line 1449) | typedef struct StdVideoVP9Segmentation
type StdVideoDecodeVP9PictureInfoFlags (line 1465) | typedef struct StdVideoDecodeVP9PictureInfoFlags
type StdVideoDecodeVP9PictureInfo (line 1478) | typedef struct StdVideoDecodeVP9PictureInfo
type StdVideoAV1Profile (line 1524) | typedef enum
type StdVideoAV1Level (line 1533) | typedef enum
type StdVideoAV1FrameType (line 1563) | typedef enum
type StdVideoAV1ReferenceName (line 1573) | typedef enum
type StdVideoAV1InterpolationFilter (line 1587) | typedef enum
type StdVideoAV1TxMode (line 1598) | typedef enum
type StdVideoAV1FrameRestorationType (line 1607) | typedef enum
type StdVideoAV1ColorPrimaries (line 1617) | typedef enum
type StdVideoAV1TransferCharacteristics (line 1636) | typedef enum
type StdVideoAV1MatrixCoefficients (line 1661) | typedef enum
type StdVideoAV1ChromaSamplePosition (line 1682) | typedef enum
type StdVideoAV1ColorConfigFlags (line 1693) | typedef struct StdVideoAV1ColorConfigFlags
type StdVideoAV1ColorConfig (line 1702) | typedef struct StdVideoAV1ColorConfig
type StdVideoAV1TimingInfoFlags (line 1715) | typedef struct StdVideoAV1TimingInfoFlags
type StdVideoAV1TimingInfo (line 1721) | typedef struct StdVideoAV1TimingInfo
type StdVideoAV1LoopFilterFlags (line 1729) | typedef struct StdVideoAV1LoopFilterFlags
type StdVideoAV1LoopFilter (line 1736) | typedef struct StdVideoAV1LoopFilter
type StdVideoAV1QuantizationFlags (line 1747) | typedef struct StdVideoAV1QuantizationFlags
type StdVideoAV1Quantization (line 1754) | typedef struct StdVideoAV1Quantization
type StdVideoAV1Segmentation (line 1768) | typedef struct StdVideoAV1Segmentation
type StdVideoAV1TileInfoFlags (line 1774) | typedef struct StdVideoAV1TileInfoFlags
type StdVideoAV1TileInfo (line 1780) | typedef struct StdVideoAV1TileInfo
type StdVideoAV1CDEF (line 1794) | typedef struct StdVideoAV1CDEF
type StdVideoAV1LoopRestoration (line 1804) | typedef struct StdVideoAV1LoopRestoration
type StdVideoAV1GlobalMotion (line 1810) | typedef struct StdVideoAV1GlobalMotion
type StdVideoAV1FilmGrainFlags (line 1816) | typedef struct StdVideoAV1FilmGrainFlags
type StdVideoAV1FilmGrain (line 1825) | typedef struct StdVideoAV1FilmGrain
type StdVideoAV1SequenceHeaderFlags (line 1854) | typedef struct StdVideoAV1SequenceHeaderFlags
type StdVideoAV1SequenceHeader (line 1878) | typedef struct StdVideoAV1SequenceHeader
type StdVideoDecodeAV1PictureInfoFlags (line 1903) | typedef struct StdVideoDecodeAV1PictureInfoFlags
type StdVideoDecodeAV1PictureInfo (line 1937) | typedef struct StdVideoDecodeAV1PictureInfo
type StdVideoDecodeAV1ReferenceInfoFlags (line 1965) | typedef struct StdVideoDecodeAV1ReferenceInfoFlags
type StdVideoDecodeAV1ReferenceInfo (line 1972) | typedef struct StdVideoDecodeAV1ReferenceInfo
type StdVideoEncodeAV1DecoderModelInfo (line 1988) | typedef struct StdVideoEncodeAV1DecoderModelInfo
type StdVideoEncodeAV1ExtensionHeader (line 1997) | typedef struct StdVideoEncodeAV1ExtensionHeader
type StdVideoEncodeAV1OperatingPointInfoFlags (line 2003) | typedef struct StdVideoEncodeAV1OperatingPointInfoFlags
type StdVideoEncodeAV1OperatingPointInfo (line 2011) | typedef struct StdVideoEncodeAV1OperatingPointInfo
type StdVideoEncodeAV1PictureInfoFlags (line 2022) | typedef struct StdVideoEncodeAV1PictureInfoFlags
type StdVideoEncodeAV1PictureInfo (line 2056) | typedef struct StdVideoEncodeAV1PictureInfo
type StdVideoEncodeAV1ReferenceInfoFlags (line 2087) | typedef struct StdVideoEncodeAV1ReferenceInfoFlags
type StdVideoEncodeAV1ReferenceInfo (line 2094) | typedef struct StdVideoEncodeAV1ReferenceInfo
type VkBool32 (line 2164) | typedef uint32_t VkBool32;
type VkDeviceAddress (line 2165) | typedef uint64_t VkDeviceAddress;
type VkDeviceSize (line 2166) | typedef uint64_t VkDeviceSize;
type VkFlags (line 2167) | typedef uint32_t VkFlags;
type VkStructureType (line 2253) | typedef enum
type VkObjectType (line 3711) | typedef enum
type VkVendorId (line 3779) | typedef enum
type VkSystemAllocationScope (line 3792) | typedef enum
type VkInternalAllocationType (line 3802) | typedef enum
type VkFormat (line 3808) | typedef enum
type VkFormatFeatureFlagBits (line 4169) | typedef enum
type VkFlags (line 4215) | typedef VkFlags VkFormatFeatureFlags;
type VkImageCreateFlagBits (line 4217) | typedef enum
type VkFlags (line 4249) | typedef VkFlags VkImageCreateFlags;
type VkSampleCountFlagBits (line 4251) | typedef enum
type VkFlags (line 4262) | typedef VkFlags VkSampleCountFlags;
type VkImageTiling (line 4263) | typedef enum
type VkImageType (line 4271) | typedef enum
type VkImageUsageFlagBits (line 4280) | typedef enum
type VkFlags (line 4311) | typedef VkFlags VkImageUsageFlags;
type VkInstanceCreateFlagBits (line 4313) | typedef enum
type VkFlags (line 4318) | typedef VkFlags VkInstanceCreateFlags;
type VkMemoryHeapFlagBits (line 4320) | typedef enum
type VkFlags (line 4329) | typedef VkFlags VkMemoryHeapFlags;
type VkMemoryPropertyFlagBits (line 4331) | typedef enum
type VkFlags (line 4344) | typedef VkFlags VkMemoryPropertyFlags;
type VkPhysicalDeviceType (line 4345) | typedef enum
type VkQueueFlagBits (line 4356) | typedef enum
type VkFlags (line 4369) | typedef VkFlags VkQueueFlags;
type VkShaderStageFlagBits (line 4371) | typedef enum
type VkFlags (line 4401) | typedef VkFlags VkShaderStageFlags;
type VkFlags (line 4402) | typedef VkFlags VkDeviceCreateFlags;
type VkDeviceQueueCreateFlagBits (line 4404) | typedef enum
type VkFlags (line 4410) | typedef VkFlags VkDeviceQueueCreateFlags;
type VkPipelineStageFlagBits (line 4412) | typedef enum
type VkFlags (line 4450) | typedef VkFlags VkPipelineStageFlags;
type VkMemoryMapFlagBits (line 4452) | typedef enum
type VkFlags (line 4457) | typedef VkFlags VkMemoryMapFlags;
type VkImageAspectFlagBits (line 4459) | typedef enum
type VkFlags (line 4479) | typedef VkFlags VkImageAspectFlags;
type VkSparseImageFormatFlagBits (line 4481) | typedef enum
type VkFlags (line 4488) | typedef VkFlags VkSparseImageFormatFlags;
type VkSparseMemoryBindFlagBits (line 4490) | typedef enum
type VkFlags (line 4495) | typedef VkFlags VkSparseMemoryBindFlags;
type VkFenceCreateFlagBits (line 4497) | typedef enum
type VkFlags (line 4502) | typedef VkFlags VkFenceCreateFlags;
type VkFlags (line 4503) | typedef VkFlags VkSemaphoreCreateFlags;
type VkQueryPoolCreateFlagBits (line 4505) | typedef enum
type VkFlags (line 4510) | typedef VkFlags VkQueryPoolCreateFlags;
type VkQueryPipelineStatisticFlagBits (line 4512) | typedef enum
type VkFlags (line 4530) | typedef VkFlags VkQueryPipelineStatisticFlags;
type VkQueryType (line 4531) | typedef enum
type VkQueryResultFlagBits (line 4554) | typedef enum
type VkFlags (line 4563) | typedef VkFlags VkQueryResultFlags;
type VkBufferCreateFlagBits (line 4565) | typedef enum
type VkFlags (line 4578) | typedef VkFlags VkBufferCreateFlags;
type VkBufferUsageFlagBits (line 4580) | typedef enum
type VkFlags (line 4615) | typedef VkFlags VkBufferUsageFlags;
type VkSharingMode (line 4616) | typedef enum
type VkImageLayout (line 4623) | typedef enum
type VkComponentSwizzle (line 4670) | typedef enum
type VkImageViewCreateFlagBits (line 4683) | typedef enum
type VkFlags (line 4690) | typedef VkFlags VkImageViewCreateFlags;
type VkImageViewType (line 4691) | typedef enum
type VkAccessFlagBits (line 4704) | typedef enum
type VkFlags (line 4743) | typedef VkFlags VkAccessFlags;
type VkDependencyFlagBits (line 4745) | typedef enum
type VkFlags (line 4757) | typedef VkFlags VkDependencyFlags;
type VkCommandPoolCreateFlagBits (line 4759) | typedef enum
type VkFlags (line 4766) | typedef VkFlags VkCommandPoolCreateFlags;
type VkCommandPoolResetFlagBits (line 4768) | typedef enum
type VkFlags (line 4773) | typedef VkFlags VkCommandPoolResetFlags;
type VkCommandBufferLevel (line 4774) | typedef enum
type VkQueryControlFlagBits (line 4782) | typedef enum
type VkFlags (line 4787) | typedef VkFlags VkQueryControlFlags;
type VkCommandBufferUsageFlagBits (line 4789) | typedef enum
type VkFlags (line 4796) | typedef VkFlags VkCommandBufferUsageFlags;
type VkCommandBufferResetFlagBits (line 4798) | typedef enum
type VkFlags (line 4803) | typedef VkFlags VkCommandBufferResetFlags;
type VkIndexType (line 4804) | typedef enum
type VkExtent2D (line 4817) | typedef struct VkExtent2D
type VkExtent3D (line 4823) | typedef struct VkExtent3D
type VkOffset2D (line 4830) | typedef struct VkOffset2D
type VkOffset3D (line 4836) | typedef struct VkOffset3D
type VkRect2D (line 4843) | typedef struct VkRect2D
type VkBaseInStructure (line 4849) | typedef struct VkBaseInStructure
type VkBaseOutStructure (line 4855) | typedef struct VkBaseOutStructure
type VkAllocationCallbacks (line 4868) | typedef struct VkAllocationCallbacks
type VkApplicationInfo (line 4878) | typedef struct VkApplicationInfo
type VkFormatProperties (line 4889) | typedef struct VkFormatProperties
type VkImageFormatProperties (line 4896) | typedef struct VkImageFormatProperties
type VkInstanceCreateInfo (line 4905) | typedef struct VkInstanceCreateInfo
type VkMemoryHeap (line 4917) | typedef struct VkMemoryHeap
type VkMemoryType (line 4923) | typedef struct VkMemoryType
type VkPhysicalDeviceFeatures (line 4929) | typedef struct VkPhysicalDeviceFeatures
type VkPhysicalDeviceLimits (line 4988) | typedef struct VkPhysicalDeviceLimits
type VkPhysicalDeviceMemoryProperties (line 5098) | typedef struct VkPhysicalDeviceMemoryProperties
type VkPhysicalDeviceSparseProperties (line 5106) | typedef struct VkPhysicalDeviceSparseProperties
type VkPhysicalDeviceProperties (line 5115) | typedef struct VkPhysicalDeviceProperties
type VkQueueFamilyProperties (line 5128) | typedef struct VkQueueFamilyProperties
type VkDeviceQueueCreateInfo (line 5136) | typedef struct VkDeviceQueueCreateInfo
type VkDeviceCreateInfo (line 5146) | typedef struct VkDeviceCreateInfo
type VkExtensionProperties (line 5160) | typedef struct VkExtensionProperties
type VkLayerProperties (line 5166) | typedef struct VkLayerProperties
type VkSubmitInfo (line 5174) | typedef struct VkSubmitInfo
type VkMappedMemoryRange (line 5187) | typedef struct VkMappedMemoryRange
type VkMemoryAllocateInfo (line 5196) | typedef struct VkMemoryAllocateInfo
type VkMemoryRequirements (line 5204) | typedef struct VkMemoryRequirements
type VkImageSubresource (line 5211) | typedef struct VkImageSubresource
type VkSparseImageFormatProperties (line 5218) | typedef struct VkSparseImageFormatProperties
type VkSparseImageMemoryBind (line 5225) | typedef struct VkSparseImageMemoryBind
type VkSparseImageMemoryBindInfo (line 5235) | typedef struct VkSparseImageMemoryBindInfo
type VkSparseImageMemoryRequirements (line 5242) | typedef struct VkSparseImageMemoryRequirements
type VkSparseMemoryBind (line 5251) | typedef struct VkSparseMemoryBind
type VkSparseBufferMemoryBindInfo (line 5260) | typedef struct VkSparseBufferMemoryBindInfo
type VkSparseImageOpaqueMemoryBindInfo (line 5267) | typedef struct VkSparseImageOpaqueMemoryBindInfo
type VkBindSparseInfo (line 5274) | typedef struct VkBindSparseInfo
type VkFenceCreateInfo (line 5290) | typedef struct VkFenceCreateInfo
type VkSemaphoreCreateInfo (line 5297) | typedef struct VkSemaphoreCreateInfo
type VkQueryPoolCreateInfo (line 5304) | typedef struct VkQueryPoolCreateInfo
type VkBufferCreateInfo (line 5314) | typedef struct VkBufferCreateInfo
type VkImageCreateInfo (line 5326) | typedef struct VkImageCreateInfo
type VkSubresourceLayout (line 5345) | typedef struct VkSubresourceLayout
type VkComponentMapping (line 5354) | typedef struct VkComponentMapping
type VkImageSubresourceRange (line 5362) | typedef struct VkImageSubresourceRange
type VkImageViewCreateInfo (line 5371) | typedef struct VkImageViewCreateInfo
type VkCommandPoolCreateInfo (line 5383) | typedef struct VkCommandPoolCreateInfo
type VkCommandBufferAllocateInfo (line 5391) | typedef struct VkCommandBufferAllocateInfo
type VkCommandBufferInheritanceInfo (line 5400) | typedef struct VkCommandBufferInheritanceInfo
type VkCommandBufferBeginInfo (line 5412) | typedef struct VkCommandBufferBeginInfo
type VkBufferCopy (line 5420) | typedef struct VkBufferCopy
type VkImageSubresourceLayers (line 5427) | typedef struct VkImageSubresourceLayers
type VkBufferImageCopy (line 5435) | typedef struct VkBufferImageCopy
type VkImageCopy (line 5445) | typedef struct VkImageCopy
type VkBufferMemoryBarrier (line 5454) | typedef struct VkBufferMemoryBarrier
type VkImageMemoryBarrier (line 5467) | typedef struct VkImageMemoryBarrier
type VkMemoryBarrier (line 5481) | typedef struct VkMemoryBarrier
type const (line 5490) | typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreat...
type VkDeviceCreateInfo (line 5501) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physic...
type const (line 5508) | typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t ...
type VkMemoryAllocateInfo (line 5511) | typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, cons...
type const (line 5515) | typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice dev...
type const (line 5516) | typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevic...
type const (line 5524) | typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint3...
type VkFenceCreateInfo (line 5525) | typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const V...
type const (line 5527) | typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_...
type const (line 5529) | typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint3...
type VkSemaphoreCreateInfo (line 5530) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, con...
type VkQueryPoolCreateInfo (line 5532) | typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, con...
type VkBufferCreateInfo (line 5535) | typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const ...
type VkImageCreateInfo (line 5537) | typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const V...
type VkImageViewCreateInfo (line 5540) | typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, con...
type VkCommandPoolCreateInfo (line 5542) | typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, c...
type VkCommandBufferAllocateInfo (line 5545) | typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice devi...
type VkCommandBufferBeginInfo (line 5547) | typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer c...
function VK_DEFINE_NON_DISPATCHABLE_HANDLE (line 5566) | VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
type VkEventCreateFlagBits (line 5586) | typedef enum
type VkFlags (line 5592) | typedef VkFlags VkEventCreateFlags;
type VkFlags (line 5593) | typedef VkFlags VkBufferViewCreateFlags;
type VkFlags (line 5594) | typedef VkFlags VkShaderModuleCreateFlags;
type VkPipelineCacheCreateFlagBits (line 5596) | typedef enum
type VkFlags (line 5605) | typedef VkFlags VkPipelineCacheCreateFlags;
type VkPipelineCreateFlagBits (line 5607) | typedef enum
type VkFlags (line 5652) | typedef VkFlags VkPipelineCreateFlags;
type VkPipelineLayoutCreateFlagBits (line 5654) | typedef enum
type VkFlags (line 5659) | typedef VkFlags VkPipelineLayoutCreateFlags;
type VkPipelineShaderStageCreateFlagBits (line 5661) | typedef enum
type VkFlags (line 5669) | typedef VkFlags VkPipelineShaderStageCreateFlags;
type VkBorderColor (line 5670) | typedef enum
type VkFilter (line 5683) | typedef enum
type VkSamplerAddressMode (line 5692) | typedef enum
type VkSamplerCreateFlagBits (line 5704) | typedef enum
type VkFlags (line 5713) | typedef VkFlags VkSamplerCreateFlags;
type VkCompareOp (line 5714) | typedef enum
type VkSamplerMipmapMode (line 5727) | typedef enum
type VkDescriptorType (line 5734) | typedef enum
type VkDescriptorPoolCreateFlagBits (line 5761) | typedef enum
type VkFlags (line 5772) | typedef VkFlags VkDescriptorPoolCreateFlags;
type VkFlags (line 5773) | typedef VkFlags VkDescriptorPoolResetFlags;
type VkDescriptorSetLayoutCreateFlagBits (line 5775) | typedef enum
type VkFlags (line 5789) | typedef VkFlags VkDescriptorSetLayoutCreateFlags;
type VkPipelineBindPoint (line 5790) | typedef enum
type VkDispatchIndirectCommand (line 5803) | typedef struct VkDispatchIndirectCommand
type VkPipelineCacheHeaderVersionOne (line 5810) | typedef struct VkPipelineCacheHeaderVersionOne
type VkEventCreateInfo (line 5819) | typedef struct VkEventCreateInfo
type VkBufferViewCreateInfo (line 5826) | typedef struct VkBufferViewCreateInfo
type VkShaderModuleCreateInfo (line 5837) | typedef struct VkShaderModuleCreateInfo
type VkPipelineCacheCreateInfo (line 5846) | typedef struct VkPipelineCacheCreateInfo
type VkSpecializationMapEntry (line 5855) | typedef struct VkSpecializationMapEntry
type VkSpecializationInfo (line 5862) | typedef struct VkSpecializationInfo
type VkPipelineShaderStageCreateInfo (line 5870) | typedef struct VkPipelineShaderStageCreateInfo
type VkComputePipelineCreateInfo (line 5881) | typedef struct VkComputePipelineCreateInfo
type VkPushConstantRange (line 5892) | typedef struct VkPushConstantRange
type VkPipelineLayoutCreateInfo (line 5899) | typedef struct VkPipelineLayoutCreateInfo
type VkSamplerCreateInfo (line 5910) | typedef struct VkSamplerCreateInfo
type VkCopyDescriptorSet (line 5932) | typedef struct VkCopyDescriptorSet
type VkDescriptorBufferInfo (line 5945) | typedef struct VkDescriptorBufferInfo
type VkDescriptorImageInfo (line 5952) | typedef struct VkDescriptorImageInfo
type VkDescriptorPoolSize (line 5959) | typedef struct VkDescriptorPoolSize
type VkDescriptorPoolCreateInfo (line 5965) | typedef struct VkDescriptorPoolCreateInfo
type VkDescriptorSetAllocateInfo (line 5975) | typedef struct VkDescriptorSetAllocateInfo
type VkDescriptorSetLayoutBinding (line 5984) | typedef struct VkDescriptorSetLayoutBinding
type VkDescriptorSetLayoutCreateInfo (line 5993) | typedef struct VkDescriptorSetLayoutCreateInfo
type VkWriteDescriptorSet (line 6002) | typedef struct VkWriteDescriptorSet
type VkClearColorValue (line 6016) | typedef union VkClearColorValue
type VkEventCreateInfo (line 6024) | typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const V...
type VkBufferViewCreateInfo (line 6029) | typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, co...
type VkShaderModuleCreateInfo (line 6031) | typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, ...
type VkPipelineCacheCreateInfo (line 6033) | typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device,...
type const (line 6036) | typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device,...
type const (line 6037) | typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice devi...
type VkPipelineLayoutCreateInfo (line 6039) | typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device...
type VkSamplerCreateInfo (line 6041) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const...
type VkDescriptorSetLayoutCreateInfo (line 6043) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice d...
type VkDescriptorPoolCreateInfo (line 6045) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device...
type VkDescriptorSetAllocateInfo (line 6048) | typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice devi...
type const (line 6049) | typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, ...
type VkSampleMask (line 6066) | typedef uint32_t VkSampleMask;
type VkBlendFactor (line 6068) | typedef enum
type VkBlendOp (line 6092) | typedef enum
type VkColorComponentFlagBits (line 6149) | typedef enum
type VkFlags (line 6157) | typedef VkFlags VkColorComponentFlags;
type VkCullModeFlagBits (line 6159) | typedef enum
type VkFlags (line 6167) | typedef VkFlags VkCullModeFlags;
type VkDynamicState (line 6168) | typedef enum
type VkFrontFace (line 6263) | typedef enum
type VkLogicOp (line 6270) | typedef enum
type VkStencilOp (line 6291) | typedef enum
type VkVertexInputRate (line 6304) | typedef enum
type VkPipelineColorBlendStateCreateFlagBits (line 6312) | typedef enum
type VkFlags (line 6318) | typedef VkFlags VkPipelineColorBlendStateCreateFlags;
type VkPipelineDepthStencilStateCreateFlagBits (line 6320) | typedef enum
type VkFlags (line 6328) | typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
type VkFlags (line 6329) | typedef VkFlags VkPipelineDynamicStateCreateFlags;
type VkFlags (line 6330) | typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
type VkPrimitiveTopology (line 6331) | typedef enum
type VkFlags (line 6347) | typedef VkFlags VkPipelineMultisampleStateCreateFlags;
type VkFlags (line 6348) | typedef VkFlags VkPipelineRasterizationStateCreateFlags;
type VkPolygonMode (line 6349) | typedef enum
type VkFlags (line 6358) | typedef VkFlags VkPipelineTessellationStateCreateFlags;
type VkFlags (line 6359) | typedef VkFlags VkPipelineVertexInputStateCreateFlags;
type VkFlags (line 6360) | typedef VkFlags VkPipelineViewportStateCreateFlags;
type VkAttachmentDescriptionFlagBits (line 6362) | typedef enum
type VkFlags (line 6369) | typedef VkFlags VkAttachmentDescriptionFlags;
type VkAttachmentLoadOp (line 6370) | typedef enum
type VkAttachmentStoreOp (line 6381) | typedef enum
type VkFramebufferCreateFlagBits (line 6393) | typedef enum
type VkFlags (line 6399) | typedef VkFlags VkFramebufferCreateFlags;
type VkRenderPassCreateFlagBits (line 6401) | typedef enum
type VkFlags (line 6407) | typedef VkFlags VkRenderPassCreateFlags;
type VkSubpassDescriptionFlagBits (line 6409) | typedef enum
type VkFlags (line 6427) | typedef VkFlags VkSubpassDescriptionFlags;
type VkStencilFaceFlagBits (line 6429) | typedef enum
type VkFlags (line 6437) | typedef VkFlags VkStencilFaceFlags;
type VkSubpassContents (line 6438) | typedef enum
type VkDrawIndexedIndirectCommand (line 6448) | typedef struct VkDrawIndexedIndirectCommand
type VkDrawIndirectCommand (line 6457) | typedef struct VkDrawIndirectCommand
type VkStencilOpState (line 6465) | typedef struct VkStencilOpState
type VkVertexInputAttributeDescription (line 6476) | typedef struct VkVertexInputAttributeDescription
type VkVertexInputBindingDescription (line 6484) | typedef struct VkVertexInputBindingDescription
type VkViewport (line 6491) | typedef struct VkViewport
type VkPipelineColorBlendAttachmentState (line 6501) | typedef struct VkPipelineColorBlendAttachmentState
type VkPipelineColorBlendStateCreateInfo (line 6513) | typedef struct VkPipelineColorBlendStateCreateInfo
type VkPipelineDepthStencilStateCreateInfo (line 6525) | typedef struct VkPipelineDepthStencilStateCreateInfo
type VkPipelineDynamicStateCreateInfo (line 6541) | typedef struct VkPipelineDynamicStateCreateInfo
type VkPipelineInputAssemblyStateCreateInfo (line 6550) | typedef struct VkPipelineInputAssemblyStateCreateInfo
type VkPipelineMultisampleStateCreateInfo (line 6559) | typedef struct VkPipelineMultisampleStateCreateInfo
type VkPipelineRasterizationStateCreateInfo (line 6572) | typedef struct VkPipelineRasterizationStateCreateInfo
type VkPipelineTessellationStateCreateInfo (line 6589) | typedef struct VkPipelineTessellationStateCreateInfo
type VkPipelineVertexInputStateCreateInfo (line 6597) | typedef struct VkPipelineVertexInputStateCreateInfo
type VkPipelineViewportStateCreateInfo (line 6608) | typedef struct VkPipelineViewportStateCreateInfo
type VkGraphicsPipelineCreateInfo (line 6619) | typedef struct VkGraphicsPipelineCreateInfo
type VkAttachmentDescription (line 6642) | typedef struct VkAttachmentDescription
type VkAttachmentReference (line 6655) | typedef struct VkAttachmentReference
type VkFramebufferCreateInfo (line 6661) | typedef struct VkFramebufferCreateInfo
type VkSubpassDependency (line 6674) | typedef struct VkSubpassDependency
type VkSubpassDescription (line 6685) | typedef struct VkSubpassDescription
type VkRenderPassCreateInfo (line 6699) | typedef struct VkRenderPassCreateInfo
type VkClearDepthStencilValue (line 6712) | typedef struct VkClearDepthStencilValue
type VkClearRect (line 6718) | typedef struct VkClearRect
type VkClearValue (line 6725) | typedef union VkClearValue
type VkClearAttachment (line 6731) | typedef struct VkClearAttachment
type VkImageBlit (line 6738) | typedef struct VkImageBlit
type VkImageResolve (line 6746) | typedef struct VkImageResolve
type VkRenderPassBeginInfo (line 6755) | typedef struct VkRenderPassBeginInfo
type const (line 6767) | typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice dev...
type VkFramebufferCreateInfo (line 6768) | typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, c...
type VkRenderPassCreateInfo (line 6770) | typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, co...
type VkSubgroupFeatureFlagBits (line 6808) | typedef enum
type VkFlags (line 6826) | typedef VkFlags VkSubgroupFeatureFlags;
type VkPointClippingBehavior (line 6827) | typedef enum
type VkPeerMemoryFeatureFlagBits (line 6837) | typedef enum
type VkFlags (line 6849) | typedef VkFlags VkPeerMemoryFeatureFlags;
type VkMemoryAllocateFlagBits (line 6851) | typedef enum
type VkFlags (line 6862) | typedef VkFlags VkMemoryAllocateFlags;
type VkFlags (line 6863) | typedef VkFlags VkCommandPoolTrimFlags;
type VkExternalMemoryHandleTypeFlagBits (line 6865) | typedef enum
type VkFlags (line 6895) | typedef VkFlags VkExternalMemoryHandleTypeFlags;
type VkExternalMemoryFeatureFlagBits (line 6897) | typedef enum
type VkFlags (line 6907) | typedef VkFlags VkExternalMemoryFeatureFlags;
type VkExternalFenceHandleTypeFlagBits (line 6909) | typedef enum
type VkFlags (line 6923) | typedef VkFlags VkExternalFenceHandleTypeFlags;
type VkExternalFenceFeatureFlagBits (line 6925) | typedef enum
type VkFlags (line 6933) | typedef VkFlags VkExternalFenceFeatureFlags;
type VkFenceImportFlagBits (line 6935) | typedef enum
type VkFlags (line 6941) | typedef VkFlags VkFenceImportFlags;
type VkSemaphoreImportFlagBits (line 6943) | typedef enum
type VkFlags (line 6949) | typedef VkFlags VkSemaphoreImportFlags;
type VkExternalSemaphoreHandleTypeFlagBits (line 6951) | typedef enum
type VkFlags (line 6968) | typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
type VkExternalSemaphoreFeatureFlagBits (line 6970) | typedef enum
type VkFlags (line 6978) | typedef VkFlags VkExternalSemaphoreFeatureFlags;
type VkBindBufferMemoryInfo (line 6980) | typedef struct VkBindBufferMemoryInfo
type VkBindImageMemoryInfo (line 6989) | typedef struct VkBindImageMemoryInfo
type VkMemoryDedicatedRequirements (line 6998) | typedef struct VkMemoryDedicatedRequirements
type VkMemoryDedicatedAllocateInfo (line 7006) | typedef struct VkMemoryDedicatedAllocateInfo
type VkMemoryAllocateFlagsInfo (line 7014) | typedef struct VkMemoryAllocateFlagsInfo
type VkDeviceGroupCommandBufferBeginInfo (line 7022) | typedef struct VkDeviceGroupCommandBufferBeginInfo
type VkDeviceGroupSubmitInfo (line 7029) | typedef struct VkDeviceGroupSubmitInfo
type VkDeviceGroupBindSparseInfo (line 7041) | typedef struct VkDeviceGroupBindSparseInfo
type VkBindBufferMemoryDeviceGroupInfo (line 7049) | typedef struct VkBindBufferMemoryDeviceGroupInfo
type VkBindImageMemoryDeviceGroupInfo (line 7057) | typedef struct VkBindImageMemoryDeviceGroupInfo
type VkPhysicalDeviceGroupProperties (line 7067) | typedef struct VkPhysicalDeviceGroupProperties
type VkDeviceGroupDeviceCreateInfo (line 7076) | typedef struct VkDeviceGroupDeviceCreateInfo
type VkBufferMemoryRequirementsInfo2 (line 7084) | typedef struct VkBufferMemoryRequirementsInfo2
type VkImageMemoryRequirementsInfo2 (line 7091) | typedef struct VkImageMemoryRequirementsInfo2
type VkImageSparseMemoryRequirementsInfo2 (line 7098) | typedef struct VkImageSparseMemoryRequirementsInfo2
type VkMemoryRequirements2 (line 7105) | typedef struct VkMemoryRequirements2
type VkSparseImageMemoryRequirements2 (line 7112) | typedef struct VkSparseImageMemoryRequirements2
type VkPhysicalDeviceFeatures2 (line 7119) | typedef struct VkPhysicalDeviceFeatures2
type VkPhysicalDeviceProperties2 (line 7126) | typedef struct VkPhysicalDeviceProperties2
type VkFormatProperties2 (line 7133) | typedef struct VkFormatProperties2
type VkImageFormatProperties2 (line 7140) | typedef struct VkImageFormatProperties2
type VkPhysicalDeviceImageFormatInfo2 (line 7147) | typedef struct VkPhysicalDeviceImageFormatInfo2
type VkQueueFamilyProperties2 (line 7158) | typedef struct VkQueueFamilyProperties2
type VkPhysicalDeviceMemoryProperties2 (line 7165) | typedef struct VkPhysicalDeviceMemoryProperties2
type VkSparseImageFormatProperties2 (line 7172) | typedef struct VkSparseImageFormatProperties2
type VkPhysicalDeviceSparseImageFormatInfo2 (line 7179) | typedef struct VkPhysicalDeviceSparseImageFormatInfo2
type VkImageViewUsageCreateInfo (line 7190) | typedef struct VkImageViewUsageCreateInfo
type VkPhysicalDeviceProtectedMemoryFeatures (line 7197) | typedef struct VkPhysicalDeviceProtectedMemoryFeatures
type VkPhysicalDeviceProtectedMemoryProperties (line 7204) | typedef struct VkPhysicalDeviceProtectedMemoryProperties
type VkDeviceQueueInfo2 (line 7211) | typedef struct VkDeviceQueueInfo2
type VkProtectedSubmitInfo (line 7220) | typedef struct VkProtectedSubmitInfo
type VkBindImagePlaneMemoryInfo (line 7227) | typedef struct VkBindImagePlaneMemoryInfo
type VkImagePlaneMemoryRequirementsInfo (line 7234) | typedef struct VkImagePlaneMemoryRequirementsInfo
type VkExternalMemoryProperties (line 7241) | typedef struct VkExternalMemoryProperties
type VkPhysicalDeviceExternalImageFormatInfo (line 7248) | typedef struct VkPhysicalDeviceExternalImageFormatInfo
type VkExternalImageFormatProperties (line 7255) | typedef struct VkExternalImageFormatProperties
type VkPhysicalDeviceExternalBufferInfo (line 7262) | typedef struct VkPhysicalDeviceExternalBufferInfo
type VkExternalBufferProperties (line 7271) | typedef struct VkExternalBufferProperties
type VkPhysicalDeviceIDProperties (line 7278) | typedef struct VkPhysicalDeviceIDProperties
type VkExternalMemoryImageCreateInfo (line 7289) | typedef struct VkExternalMemoryImageCreateInfo
type VkExternalMemoryBufferCreateInfo (line 7296) | typedef struct VkExternalMemoryBufferCreateInfo
type VkExportMemoryAllocateInfo (line 7303) | typedef struct VkExportMemoryAllocateInfo
type VkPhysicalDeviceExternalFenceInfo (line 7310) | typedef struct VkPhysicalDeviceExternalFenceInfo
type VkExternalFenceProperties (line 7317) | typedef struct VkExternalFenceProperties
type VkExportFenceCreateInfo (line 7326) | typedef struct VkExportFenceCreateInfo
type VkExportSemaphoreCreateInfo (line 7333) | typedef struct VkExportSemaphoreCreateInfo
type VkPhysicalDeviceExternalSemaphoreInfo (line 7340) | typedef struct VkPhysicalDeviceExternalSemaphoreInfo
type VkExternalSemaphoreProperties (line 7347) | typedef struct VkExternalSemaphoreProperties
type const (line 7358) | typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, u...
type const (line 7359) | typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, ui...
type VkPhysicalDeviceImageFormatInfo2 (line 7369) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatPropertie...
function VK_DEFINE_NON_DISPATCHABLE_HANDLE (line 7381) | VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
type VkSamplerYcbcrModelConversion (line 7394) | typedef enum
type VkSamplerYcbcrRange (line 7409) | typedef enum
type VkChromaLocation (line 7418) | typedef enum
type VkPhysicalDeviceSubgroupProperties (line 7428) | typedef struct VkPhysicalDeviceSubgroupProperties
type VkPhysicalDevice16BitStorageFeatures (line 7438) | typedef struct VkPhysicalDevice16BitStorageFeatures
type VkPhysicalDeviceVariablePointersFeatures (line 7448) | typedef struct VkPhysicalDeviceVariablePointersFeatures
type VkPhysicalDeviceVariablePointersFeatures (line 7456) | typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariabl...
type VkDescriptorUpdateTemplateEntry (line 7458) | typedef struct VkDescriptorUpdateTemplateEntry
type VkDescriptorUpdateTemplateCreateInfo (line 7468) | typedef struct VkDescriptorUpdateTemplateCreateInfo
type VkPhysicalDeviceMaintenance3Properties (line 7482) | typedef struct VkPhysicalDeviceMaintenance3Properties
type VkDescriptorSetLayoutSupport (line 7490) | typedef struct VkDescriptorSetLayoutSupport
type VkSamplerYcbcrConversionCreateInfo (line 7497) | typedef struct VkSamplerYcbcrConversionCreateInfo
type VkSamplerYcbcrConversionInfo (line 7511) | typedef struct VkSamplerYcbcrConversionInfo
type VkPhysicalDeviceSamplerYcbcrConversionFeatures (line 7518) | typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
type VkSamplerYcbcrConversionImageFormatProperties (line 7525) | typedef struct VkSamplerYcbcrConversionImageFormatProperties
type VkDescriptorUpdateTemplateCreateInfo (line 7534) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDev...
type VkSamplerYcbcrConversionCreateInfo (line 7538) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevic...
type VkTessellationDomainOrigin (line 7543) | typedef enum
type VkDeviceGroupRenderPassBeginInfo (line 7553) | typedef struct VkDeviceGroupRenderPassBeginInfo
type VkPhysicalDevicePointClippingProperties (line 7562) | typedef struct VkPhysicalDevicePointClippingProperties
type VkInputAttachmentAspectReference (line 7569) | typedef struct VkInputAttachmentAspectReference
type VkRenderPassInputAttachmentAspectCreateInfo (line 7576) | typedef struct VkRenderPassInputAttachmentAspectCreateInfo
type VkPipelineTessellationDomainOriginStateCreateInfo (line 7584) | typedef struct VkPipelineTessellationDomainOriginStateCreateInfo
type VkRenderPassMultiviewCreateInfo (line 7591) | typedef struct VkRenderPassMultiviewCreateInfo
type VkPhysicalDeviceMultiviewFeatures (line 7603) | typedef struct VkPhysicalDeviceMultiviewFeatures
type VkPhysicalDeviceMultiviewProperties (line 7612) | typedef struct VkPhysicalDeviceMultiviewProperties
type VkPhysicalDeviceShaderDrawParametersFeatures (line 7620) | typedef struct VkPhysicalDeviceShaderDrawParametersFeatures
type VkPhysicalDeviceShaderDrawParametersFeatures (line 7627) | typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceSha...
type VkDriverId (line 7641) | typedef enum
type VkShaderFloatControlsIndependence (line 7686) | typedef enum
type VkResolveModeFlagBits (line 7698) | typedef enum
type VkFlags (line 7715) | typedef VkFlags VkResolveModeFlags;
type VkSemaphoreType (line 7716) | typedef enum
type VkSemaphoreWaitFlagBits (line 7726) | typedef enum
type VkFlags (line 7732) | typedef VkFlags VkSemaphoreWaitFlags;
type VkConformanceVersion (line 7734) | typedef struct VkConformanceVersion
type VkPhysicalDeviceDriverProperties (line 7742) | typedef struct VkPhysicalDeviceDriverProperties
type VkPhysicalDeviceVulkan11Features (line 7752) | typedef struct VkPhysicalDeviceVulkan11Features
type VkPhysicalDeviceVulkan11Properties (line 7770) | typedef struct VkPhysicalDeviceVulkan11Properties
type VkPhysicalDeviceVulkan12Features (line 7791) | typedef struct VkPhysicalDeviceVulkan12Features
type VkPhysicalDeviceVulkan12Properties (line 7844) | typedef struct VkPhysicalDeviceVulkan12Properties
type VkImageFormatListCreateInfo (line 7902) | typedef struct VkImageFormatListCreateInfo
type VkPhysicalDeviceVulkanMemoryModelFeatures (line 7910) | typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures
type VkPhysicalDeviceHostQueryResetFeatures (line 7919) | typedef struct VkPhysicalDeviceHostQueryResetFeatures
type VkPhysicalDeviceTimelineSemaphoreFeatures (line 7926) | typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures
type VkPhysicalDeviceTimelineSemaphoreProperties (line 7933) | typedef struct VkPhysicalDeviceTimelineSemaphoreProperties
type VkSemaphoreTypeCreateInfo (line 7940) | typedef struct VkSemaphoreTypeCreateInfo
type VkTimelineSemaphoreSubmitInfo (line 7948) | typedef struct VkTimelineSemaphoreSubmitInfo
type VkSemaphoreWaitInfo (line 7958) | typedef struct VkSemaphoreWaitInfo
type VkSemaphoreSignalInfo (line 7968) | typedef struct VkSemaphoreSignalInfo
type VkPhysicalDeviceBufferDeviceAddressFeatures (line 7976) | typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures
type VkBufferDeviceAddressInfo (line 7985) | typedef struct VkBufferDeviceAddressInfo
type VkBufferOpaqueCaptureAddressCreateInfo (line 7992) | typedef struct VkBufferOpaqueCaptureAddressCreateInfo
type VkMemoryOpaqueCaptureAddressAllocateInfo (line 7999) | typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo
type VkDeviceMemoryOpaqueCaptureAddressInfo (line 8006) | typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo
type VkSemaphoreWaitInfo (line 8016) | typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, cons...
type VkSemaphoreSignalInfo (line 8017) | typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, con...
type VkBufferDeviceAddressInfo (line 8018) | typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevi...
type VkDescriptorBindingFlagBits (line 8025) | typedef enum
type VkFlags (line 8037) | typedef VkFlags VkDescriptorBindingFlags;
type VkSamplerReductionMode (line 8038) | typedef enum
type VkPhysicalDevice8BitStorageFeatures (line 8051) | typedef struct VkPhysicalDevice8BitStorageFeatures
type VkPhysicalDeviceShaderAtomicInt64Features (line 8060) | typedef struct VkPhysicalDeviceShaderAtomicInt64Features
type VkPhysicalDeviceShaderFloat16Int8Features (line 8068) | typedef struct VkPhysicalDeviceShaderFloat16Int8Features
type VkPhysicalDeviceFloatControlsProperties (line 8076) | typedef struct VkPhysicalDeviceFloatControlsProperties
type VkDescriptorSetLayoutBindingFlagsCreateInfo (line 8099) | typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo
type VkPhysicalDeviceDescriptorIndexingFeatures (line 8107) | typedef struct VkPhysicalDeviceDescriptorIndexingFeatures
type VkPhysicalDeviceDescriptorIndexingProperties (line 8133) | typedef struct VkPhysicalDeviceDescriptorIndexingProperties
type VkDescriptorSetVariableDescriptorCountAllocateInfo (line 8162) | typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo
type VkDescriptorSetVariableDescriptorCountLayoutSupport (line 8170) | typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport
type VkPhysicalDeviceScalarBlockLayoutFeatures (line 8177) | typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures
type VkSamplerReductionModeCreateInfo (line 8184) | typedef struct VkSamplerReductionModeCreateInfo
type VkPhysicalDeviceSamplerFilterMinmaxProperties (line 8191) | typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties
type VkPhysicalDeviceUniformBufferStandardLayoutFeatures (line 8199) | typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures
type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures (line 8206) | typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
type VkAttachmentDescription2 (line 8217) | typedef struct VkAttachmentDescription2
type VkAttachmentReference2 (line 8232) | typedef struct VkAttachmentReference2
type VkSubpassDescription2 (line 8241) | typedef struct VkSubpassDescription2
type VkSubpassDependency2 (line 8258) | typedef struct VkSubpassDependency2
type VkSubpassBeginInfo (line 8272) | typedef struct VkSubpassBeginInfo
type VkSubpassEndInfo (line 8279) | typedef struct VkSubpassEndInfo
type VkRenderPassCreateInfo2 (line 8285) | typedef struct VkRenderPassCreateInfo2
type VkSubpassDescriptionDepthStencilResolve (line 8300) | typedef struct VkSubpassDescriptionDepthStencilResolve
type VkPhysicalDeviceDepthStencilResolveProperties (line 8309) | typedef struct VkPhysicalDeviceDepthStencilResolveProperties
type VkImageStencilUsageCreateInfo (line 8319) | typedef struct VkImageStencilUsageCreateInfo
type VkPhysicalDeviceImagelessFramebufferFeatures (line 8326) | typedef struct VkPhysicalDeviceImagelessFramebufferFeatures
type VkFramebufferAttachmentImageInfo (line 8333) | typedef struct VkFramebufferAttachmentImageInfo
type VkRenderPassAttachmentBeginInfo (line 8346) | typedef struct VkRenderPassAttachmentBeginInfo
type VkFramebufferAttachmentsCreateInfo (line 8354) | typedef struct VkFramebufferAttachmentsCreateInfo
type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures (line 8362) | typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
type VkAttachmentReferenceStencilLayout (line 8369) | typedef struct VkAttachmentReferenceStencilLayout
type VkAttachmentDescriptionStencilLayout (line 8376) | typedef struct VkAttachmentDescriptionStencilLayout
type VkRenderPassCreateInfo2 (line 8387) | typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, c...
type VkFlags64 (line 8399) | typedef uint64_t VkFlags64;
type VkFlags (line 8420) | typedef VkFlags VkToolPurposeFlags;
type VkFlags (line 8421) | typedef VkFlags VkPrivateDataSlotCreateFlags;
type VkFlags64 (line 8423) | typedef VkFlags64 VkPipelineStageFlagBits2;
type VkFlags64 (line 8504) | typedef VkFlags64 VkPipelineStageFlags2;
type VkFlags64 (line 8506) | typedef VkFlags64 VkAccessFlagBits2;
type VkFlags64 (line 8584) | typedef VkFlags64 VkAccessFlags2;
type VkSubmitFlagBits (line 8586) | typedef enum
type VkFlags (line 8592) | typedef VkFlags VkSubmitFlags;
type VkFlags64 (line 8594) | typedef VkFlags64 VkFormatFeatureFlagBits2;
type VkFlags64 (line 8677) | typedef VkFlags64 VkFormatFeatureFlags2;
type VkPhysicalDeviceVulkan13Features (line 8679) | typedef struct VkPhysicalDeviceVulkan13Features
type VkPhysicalDeviceVulkan13Properties (line 8700) | typedef struct VkPhysicalDeviceVulkan13Properties
type VkPhysicalDeviceToolProperties (line 8751) | typedef struct VkPhysicalDeviceToolProperties
type VkPhysicalDevicePrivateDataFeatures (line 8762) | typedef struct VkPhysicalDevicePrivateDataFeatures
type VkDevicePrivateDataCreateInfo (line 8769) | typedef struct VkDevicePrivateDataCreateInfo
type VkPrivateDataSlotCreateInfo (line 8776) | typedef struct VkPrivateDataSlotCreateInfo
type VkMemoryBarrier2 (line 8783) | typedef struct VkMemoryBarrier2
type VkBufferMemoryBarrier2 (line 8793) | typedef struct VkBufferMemoryBarrier2
type VkImageMemoryBarrier2 (line 8808) | typedef struct VkImageMemoryBarrier2
type VkDependencyInfo (line 8824) | typedef struct VkDependencyInfo
type VkSemaphoreSubmitInfo (line 8837) | typedef struct VkSemaphoreSubmitInfo
type VkCommandBufferSubmitInfo (line 8847) | typedef struct VkCommandBufferSubmitInfo
type VkSubmitInfo2 (line 8855) | typedef struct VkSubmitInfo2
type VkPhysicalDeviceSynchronization2Features (line 8868) | typedef struct VkPhysicalDeviceSynchronization2Features
type VkBufferCopy2 (line 8875) | typedef struct VkBufferCopy2
type VkCopyBufferInfo2 (line 8884) | typedef struct VkCopyBufferInfo2
type VkImageCopy2 (line 8894) | typedef struct VkImageCopy2
type VkCopyImageInfo2 (line 8905) | typedef struct VkCopyImageInfo2
type VkBufferImageCopy2 (line 8917) | typedef struct VkBufferImageCopy2
type VkCopyBufferToImageInfo2 (line 8929) | typedef struct VkCopyBufferToImageInfo2
type VkCopyImageToBufferInfo2 (line 8940) | typedef struct VkCopyImageToBufferInfo2
type VkPhysicalDeviceTextureCompressionASTCHDRFeatures (line 8951) | typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures
type VkFormatProperties3 (line 8958) | typedef struct VkFormatProperties3
type VkPhysicalDeviceMaintenance4Features (line 8967) | typedef struct VkPhysicalDeviceMaintenance4Features
type VkPhysicalDeviceMaintenance4Properties (line 8974) | typedef struct VkPhysicalDeviceMaintenance4Properties
type VkDeviceBufferMemoryRequirements (line 8981) | typedef struct VkDeviceBufferMemoryRequirements
type VkDeviceImageMemoryRequirements (line 8988) | typedef struct VkDeviceImageMemoryRequirements
type VkPrivateDataSlotCreateInfo (line 8998) | typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice devic...
type const (line 9004) | typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t...
type VkPipelineCreationFeedbackFlagBits (line 9016) | typedef enum
type VkFlags (line 9026) | typedef VkFlags VkPipelineCreationFeedbackFlags;
type VkPipelineCreationFeedback (line 9028) | typedef struct VkPipelineCreationFeedback
type VkPipelineCreationFeedbackCreateInfo (line 9034) | typedef struct VkPipelineCreationFeedbackCreateInfo
type VkPhysicalDeviceShaderTerminateInvocationFeatures (line 9043) | typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures
type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures (line 9050) | typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures
type VkPhysicalDevicePipelineCreationCacheControlFeatures (line 9057) | typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures
type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures (line 9064) | typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
type VkPhysicalDeviceImageRobustnessFeatures (line 9071) | typedef struct VkPhysicalDeviceImageRobustnessFeatures
type VkPhysicalDeviceSubgroupSizeControlFeatures (line 9078) | typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures
type VkPhysicalDeviceSubgroupSizeControlProperties (line 9086) | typedef struct VkPhysicalDeviceSubgroupSizeControlProperties
type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo (line 9096) | typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo
type VkPhysicalDeviceInlineUniformBlockFeatures (line 9103) | typedef struct VkPhysicalDeviceInlineUniformBlockFeatures
type VkPhysicalDeviceInlineUniformBlockProperties (line 9111) | typedef struct VkPhysicalDeviceInlineUniformBlockProperties
type VkWriteDescriptorSetInlineUniformBlock (line 9122) | typedef struct VkWriteDescriptorSetInlineUniformBlock
type VkDescriptorPoolInlineUniformBlockCreateInfo (line 9130) | typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo
type VkPhysicalDeviceShaderIntegerDotProductFeatures (line 9137) | typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures
type VkPhysicalDeviceShaderIntegerDotProductProperties (line 9144) | typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties
type VkPhysicalDeviceTexelBufferAlignmentProperties (line 9180) | typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties
type VkRenderingFlagBits (line 9198) | typedef enum
type VkFlags (line 9215) | typedef VkFlags VkRenderingFlags;
type VkImageBlit2 (line 9217) | typedef struct VkImageBlit2
type VkBlitImageInfo2 (line 9227) | typedef struct VkBlitImageInfo2
type VkImageResolve2 (line 9240) | typedef struct VkImageResolve2
type VkResolveImageInfo2 (line 9251) | typedef struct VkResolveImageInfo2
type VkRenderingAttachmentInfo (line 9263) | typedef struct VkRenderingAttachmentInfo
type VkRenderingInfo (line 9277) | typedef struct VkRenderingInfo
type VkPipelineRenderingCreateInfo (line 9291) | typedef struct VkPipelineRenderingCreateInfo
type VkPhysicalDeviceDynamicRenderingFeatures (line 9302) | typedef struct VkPhysicalDeviceDynamicRenderingFeatures
type VkCommandBufferInheritanceRenderingInfo (line 9309) | typedef struct VkCommandBufferInheritanceRenderingInfo
type VkPipelineRobustnessBufferBehavior (line 9352) | typedef enum
type VkPipelineRobustnessImageBehavior (line 9365) | typedef enum
type VkQueueGlobalPriority (line 9378) | typedef enum
type VkMemoryUnmapFlagBits (line 9396) | typedef enum
type VkFlags (line 9401) | typedef VkFlags VkMemoryUnmapFlags;
type VkFlags64 (line 9403) | typedef VkFlags64 VkBufferUsageFlagBits2;
type VkFlags64 (line 9447) | typedef VkFlags64 VkBufferUsageFlags2;
type VkHostImageCopyFlagBits (line 9449) | typedef enum
type VkFlags (line 9457) | typedef VkFlags VkHostImageCopyFlags;
type VkPhysicalDeviceVulkan14Features (line 9459) | typedef struct VkPhysicalDeviceVulkan14Features
type VkPhysicalDeviceVulkan14Properties (line 9486) | typedef struct VkPhysicalDeviceVulkan14Properties
type VkDeviceQueueGlobalPriorityCreateInfo (line 9517) | typedef struct VkDeviceQueueGlobalPriorityCreateInfo
type VkPhysicalDeviceGlobalPriorityQueryFeatures (line 9524) | typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures
type VkQueueFamilyGlobalPriorityProperties (line 9531) | typedef struct VkQueueFamilyGlobalPriorityProperties
type VkPhysicalDeviceIndexTypeUint8Features (line 9539) | typedef struct VkPhysicalDeviceIndexTypeUint8Features
type VkMemoryMapInfo (line 9546) | typedef struct VkMemoryMapInfo
type VkMemoryUnmapInfo (line 9556) | typedef struct VkMemoryUnmapInfo
type VkPhysicalDeviceMaintenance5Features (line 9564) | typedef struct VkPhysicalDeviceMaintenance5Features
type VkPhysicalDeviceMaintenance5Properties (line 9571) | typedef struct VkPhysicalDeviceMaintenance5Properties
type VkSubresourceLayout2 (line 9583) | typedef struct VkSubresourceLayout2
type VkImageSubresource2 (line 9590) | typedef struct VkImageSubresource2
type VkDeviceImageSubresourceInfo (line 9597) | typedef struct VkDeviceImageSubresourceInfo
type VkBufferUsageFlags2CreateInfo (line 9605) | typedef struct VkBufferUsageFlags2CreateInfo
type VkPhysicalDeviceMaintenance6Features (line 9612) | typedef struct VkPhysicalDeviceMaintenance6Features
type VkPhysicalDeviceMaintenance6Properties (line 9619) | typedef struct VkPhysicalDeviceMaintenance6Properties
type VkBindMemoryStatus (line 9628) | typedef struct VkBindMemoryStatus
type VkPhysicalDeviceHostImageCopyFeatures (line 9635) | typedef struct VkPhysicalDeviceHostImageCopyFeatures
type VkPhysicalDeviceHostImageCopyProperties (line 9642) | typedef struct VkPhysicalDeviceHostImageCopyProperties
type VkMemoryToImageCopy (line 9654) | typedef struct VkMemoryToImageCopy
type VkImageToMemoryCopy (line 9666) | typedef struct VkImageToMemoryCopy
type VkCopyMemoryToImageInfo (line 9678) | typedef struct VkCopyMemoryToImageInfo
type VkCopyImageToMemoryInfo (line 9689) | typedef struct VkCopyImageToMemoryInfo
type VkCopyImageToImageInfo (line 9700) | typedef struct VkCopyImageToImageInfo
type VkHostImageLayoutTransitionInfo (line 9713) | typedef struct VkHostImageLayoutTransitionInfo
type VkSubresourceHostMemcpySize (line 9723) | typedef struct VkSubresourceHostMemcpySize
type VkHostImageCopyDevicePerformanceQuery (line 9730) | typedef struct VkHostImageCopyDevicePerformanceQuery
type VkMemoryMapInfo (line 9739) | typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2)(VkDevice device, const Vk...
type VkMemoryUnmapInfo (line 9740) | typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2)(VkDevice device, const ...
type VkCopyMemoryToImageInfo (line 9743) | typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImage)(VkDevice device, c...
type VkCopyImageToMemoryInfo (line 9744) | typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemory)(VkDevice device, c...
type VkCopyImageToImageInfo (line 9745) | typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImage)(VkDevice device, co...
type const (line 9746) | typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayout)(VkDevice devic...
type VkFlags64 (line 9751) | typedef VkFlags64 VkPipelineCreateFlagBits2;
type VkFlags64 (line 9803) | typedef VkFlags64 VkPipelineCreateFlags2;
type VkPhysicalDeviceShaderSubgroupRotateFeatures (line 9805) | typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures
type VkPhysicalDeviceShaderFloatControls2Features (line 9813) | typedef struct VkPhysicalDeviceShaderFloatControls2Features
type VkPhysicalDeviceShaderExpectAssumeFeatures (line 9820) | typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures
type VkPipelineCreateFlags2CreateInfo (line 9827) | typedef struct VkPipelineCreateFlags2CreateInfo
type VkPhysicalDevicePushDescriptorProperties (line 9834) | typedef struct VkPhysicalDevicePushDescriptorProperties
type VkBindDescriptorSetsInfo (line 9841) | typedef struct VkBindDescriptorSetsInfo
type VkPushConstantsInfo (line 9854) | typedef struct VkPushConstantsInfo
type VkPushDescriptorSetInfo (line 9865) | typedef struct VkPushDescriptorSetInfo
type VkPushDescriptorSetWithTemplateInfo (line 9876) | typedef struct VkPushDescriptorSetWithTemplateInfo
type VkPhysicalDevicePipelineProtectedAccessFeatures (line 9886) | typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures
type VkPhysicalDevicePipelineRobustnessFeatures (line 9893) | typedef struct VkPhysicalDevicePipelineRobustnessFeatures
type VkPhysicalDevicePipelineRobustnessProperties (line 9900) | typedef struct VkPhysicalDevicePipelineRobustnessProperties
type VkPipelineRobustnessCreateInfo (line 9910) | typedef struct VkPipelineRobustnessCreateInfo
type VkLineRasterizationMode (line 9930) | typedef enum
type VkPhysicalDeviceLineRasterizationFeatures (line 9948) | typedef struct VkPhysicalDeviceLineRasterizationFeatures
type VkPhysicalDeviceLineRasterizationProperties (line 9960) | typedef struct VkPhysicalDeviceLineRasterizationProperties
type VkPipelineRasterizationLineStateCreateInfo (line 9967) | typedef struct VkPipelineRasterizationLineStateCreateInfo
type VkPhysicalDeviceVertexAttributeDivisorProperties (line 9977) | typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties
type VkVertexInputBindingDivisorDescription (line 9985) | typedef struct VkVertexInputBindingDivisorDescription
type VkPipelineVertexInputDivisorStateCreateInfo (line 9991) | typedef struct VkPipelineVertexInputDivisorStateCreateInfo
type VkPhysicalDeviceVertexAttributeDivisorFeatures (line 9999) | typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures
type VkRenderingAreaInfo (line 10007) | typedef struct VkRenderingAreaInfo
type VkPhysicalDeviceDynamicRenderingLocalReadFeatures (line 10018) | typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures
type VkRenderingAttachmentLocationInfo (line 10025) | typedef struct VkRenderingAttachmentLocationInfo
type VkRenderingInputAttachmentIndexInfo (line 10033) | typedef struct VkRenderingInputAttachmentIndexInfo
type VkFaultLevel (line 10058) | typedef enum
type VkFaultType (line 10067) | typedef enum
type VkFaultQueryBehavior (line 10079) | typedef enum
type VkPipelineMatchControl (line 10085) | typedef enum
type VkPipelineCacheValidationVersion (line 10091) | typedef enum
type VkPhysicalDeviceVulkanSC10Features (line 10098) | typedef struct VkPhysicalDeviceVulkanSC10Features
type VkPhysicalDeviceVulkanSC10Properties (line 10105) | typedef struct VkPhysicalDeviceVulkanSC10Properties
type VkPipelinePoolSize (line 10129) | typedef struct VkPipelinePoolSize
type VkDeviceObjectReservationCreateInfo (line 10137) | typedef struct VkDeviceObjectReservationCreateInfo
type VkCommandPoolMemoryReservationCreateInfo (line 10184) | typedef struct VkCommandPoolMemoryReservationCreateInfo
type VkCommandPoolMemoryConsumption (line 10192) | typedef struct VkCommandPoolMemoryConsumption
type VkFaultData (line 10201) | typedef struct VkFaultData
type VkFaultCallbackInfo (line 10211) | typedef struct VkFaultCallbackInfo
type VkPipelineOfflineCreateInfo (line 10220) | typedef struct VkPipelineOfflineCreateInfo
type VkPipelineCacheStageValidationIndexEntry (line 10229) | typedef struct VkPipelineCacheStageValidationIndexEntry
type VkPipelineCacheSafetyCriticalIndexEntry (line 10235) | typedef struct VkPipelineCacheSafetyCriticalIndexEntry
type VkPipelineCacheHeaderVersionSafetyCriticalOne (line 10246) | typedef struct VkPipelineCacheHeaderVersionSafetyCriticalOne
type VkColorSpaceKHR (line 10279) | typedef enum
type VkCompositeAlphaFlagBitsKHR (line 10303) | typedef enum
type VkFlags (line 10311) | typedef VkFlags VkCompositeAlphaFlagsKHR;
type VkSurfaceTransformFlagBitsKHR (line 10313) | typedef enum
type VkFlags (line 10326) | typedef VkFlags VkSurfaceTransformFlagsKHR;
type VkSurfaceCapabilitiesKHR (line 10328) | typedef struct VkSurfaceCapabilitiesKHR
type VkSurfaceFormatKHR (line 10342) | typedef struct VkSurfaceFormatKHR
type VkFlags (line 10375) | typedef VkFlags VkSwapchainCreateFlagsKHR;
type VkDeviceGroupPresentModeFlagBitsKHR (line 10377) | typedef enum
type VkFlags (line 10385) | typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
type VkSwapchainCreateInfoKHR (line 10387) | typedef struct VkSwapchainCreateInfoKHR
type VkPresentInfoKHR (line 10409) | typedef struct VkPresentInfoKHR
type VkImageSwapchainCreateInfoKHR (line 10421) | typedef struct VkImageSwapchainCreateInfoKHR
type VkBindImageMemorySwapchainInfoKHR (line 10428) | typedef struct VkBindImageMemorySwapchainInfoKHR
type VkAcquireNextImageInfoKHR (line 10436) | typedef struct VkAcquireNextImageInfoKHR
type VkDeviceGroupPresentCapabilitiesKHR (line 10447) | typedef struct VkDeviceGroupPresentCapabilitiesKHR
type VkDeviceGroupPresentInfoKHR (line 10455) | typedef struct VkDeviceGroupPresentInfoKHR
type VkDeviceGroupSwapchainCreateInfoKHR (line 10464) | typedef struct VkDeviceGroupSwapchainCreateInfoKHR
type VkSwapchainCreateInfoKHR (line 10472) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, ...
type VkPresentInfoKHR (line 10476) | typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const...
type VkAcquireNextImageInfoKHR (line 10480) | typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device...
type VkDisplayPlaneAlphaFlagBitsKHR (line 10492) | typedef enum
type VkFlags (line 10500) | typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
type VkFlags (line 10501) | typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
type VkDisplayModeParametersKHR (line 10503) | typedef struct VkDisplayModeParametersKHR
type VkDisplayModeCreateInfoKHR (line 10509) | typedef struct VkDisplayModeCreateInfoKHR
type VkDisplayModePropertiesKHR (line 10517) | typedef struct VkDisplayModePropertiesKHR
type VkDisplayPlaneCapabilitiesKHR (line 10523) | typedef struct VkDisplayPlaneCapabilitiesKHR
type VkDisplayPlanePropertiesKHR (line 10536) | typedef struct VkDisplayPlanePropertiesKHR
type VkDisplayPropertiesKHR (line 10542) | typedef struct VkDisplayPropertiesKHR
type VkDisplaySurfaceCreateInfoKHR (line 10553) | typedef struct VkDisplaySurfaceCreateInfoKHR
type VkDisplayModeCreateInfoKHR (line 10572) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevic...
type VkDisplaySurfaceCreateInfoKHR (line 10574) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInsta...
type VkDisplayPresentInfoKHR (line 10581) | typedef struct VkDisplayPresentInfoKHR
type const (line 10591) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice d...
type VkRasterizationOrderAMD (line 10618) | typedef enum
type VkPipelineRasterizationStateRasterizationOrderAMD (line 10626) | typedef struct VkPipelineRasterizationStateRasterizationOrderAMD
type VkFlags (line 10664) | typedef VkFlags VkVideoCodecOperationFlagsKHR;
type VkVideoChromaSubsamplingFlagBitsKHR (line 10666) | typedef enum
type VkFlags (line 10675) | typedef VkFlags VkVideoChromaSubsamplingFlagsKHR;
type VkVideoComponentBitDepthFlagBitsKHR (line 10677) | typedef enum
type VkFlags (line 10685) | typedef VkFlags VkVideoComponentBitDepthFlagsKHR;
type VkVideoCapabilityFlagBitsKHR (line 10687) | typedef enum
type VkFlags (line 10693) | typedef VkFlags VkVideoCapabilityFlagsKHR;
type VkVideoSessionCreateFlagBitsKHR (line 10695) | typedef enum
type VkFlags (line 10705) | typedef VkFlags VkVideoSessionCreateFlagsKHR;
type VkVideoSessionParametersCreateFlagBitsKHR (line 10707) | typedef enum
type VkFlags (line 10712) | typedef VkFlags VkVideoSessionParametersCreateFlagsKHR;
type VkFlags (line 10713) | typedef VkFlags VkVideoBeginCodingFlagsKHR;
type VkFlags (line 10714) | typedef VkFlags VkVideoEndCodingFlagsKHR;
type VkVideoCodingControlFlagBitsKHR (line 10716) | typedef enum
type VkFlags (line 10723) | typedef VkFlags VkVideoCodingControlFlagsKHR;
type VkQueryResultStatusKHR (line 10724) | typedef enum
type VkQueueFamilyQueryResultStatusPropertiesKHR (line 10734) | typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR
type VkQueueFamilyVideoPropertiesKHR (line 10741) | typedef struct VkQueueFamilyVideoPropertiesKHR
type VkVideoProfileInfoKHR (line 10748) | typedef struct VkVideoProfileInfoKHR
type VkVideoProfileListInfoKHR (line 10758) | typedef struct VkVideoProfileListInfoKHR
type VkVideoCapabilitiesKHR (line 10766) | typedef struct VkVideoCapabilitiesKHR
type VkPhysicalDeviceVideoFormatInfoKHR (line 10781) | typedef struct VkPhysicalDeviceVideoFormatInfoKHR
type VkVideoFormatPropertiesKHR (line 10788) | typedef struct VkVideoFormatPropertiesKHR
type VkVideoPictureResourceInfoKHR (line 10800) | typedef struct VkVideoPictureResourceInfoKHR
type VkVideoReferenceSlotInfoKHR (line 10810) | typedef struct VkVideoReferenceSlotInfoKHR
type VkVideoSessionMemoryRequirementsKHR (line 10818) | typedef struct VkVideoSessionMemoryRequirementsKHR
type VkBindVideoSessionMemoryInfoKHR (line 10826) | typedef struct VkBindVideoSessionMemoryInfoKHR
type VkVideoSessionCreateInfoKHR (line 10836) | typedef struct VkVideoSessionCreateInfoKHR
type VkVideoSessionParametersCreateInfoKHR (line 10851) | typedef struct VkVideoSessionParametersCreateInfoKHR
type VkVideoSessionParametersUpdateInfoKHR (line 10860) | typedef struct VkVideoSessionParametersUpdateInfoKHR
type VkVideoBeginCodingInfoKHR (line 10867) | typedef struct VkVideoBeginCodingInfoKHR
type VkVideoEndCodingInfoKHR (line 10878) | typedef struct VkVideoEndCodingInfoKHR
type VkVideoCodingControlInfoKHR (line 10885) | typedef struct VkVideoCodingControlInfoKHR
type VkVideoProfileInfoKHR (line 10893) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR...
type VkPhysicalDeviceVideoFormatInfoKHR (line 10894) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertie...
type VkVideoSessionCreateInfoKHR (line 10895) | typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice devic...
type const (line 10898) | typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice d...
type VkVideoSessionParametersCreateInfoKHR (line 10899) | typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDe...
type VkVideoDecodeCapabilityFlagBitsKHR (line 10912) | typedef enum
type VkFlags (line 10918) | typedef VkFlags VkVideoDecodeCapabilityFlagsKHR;
type VkVideoDecodeUsageFlagBitsKHR (line 10920) | typedef enum
type VkFlags (line 10928) | typedef VkFlags VkVideoDecodeUsageFlagsKHR;
type VkFlags (line 10929) | typedef VkFlags VkVideoDecodeFlagsKHR;
type VkVideoDecodeCapabilitiesKHR (line 10931) | typedef struct VkVideoDecodeCapabilitiesKHR
type VkVideoDecodeUsageInfoKHR (line 10938) | typedef struct VkVideoDecodeUsageInfoKHR
type VkVideoDecodeInfoKHR (line 10945) | typedef struct VkVideoDecodeInfoKHR
type VkFlags (line 10972) | typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
type VkPhysicalDeviceTransformFeedbackFeaturesEXT (line 10973) | typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT
type VkPhysicalDeviceTransformFeedbackPropertiesEXT (line 10981) | typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT
type VkPipelineRasterizationStateStreamCreateInfoEXT (line 10997) | typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT
function VK_DEFINE_NON_DISPATCHABLE_HANDLE (line 11018) | VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)
type VkCuModuleTexturingModeCreateInfoNVX (line 11029) | typedef struct VkCuModuleTexturingModeCreateInfoNVX
type VkCuFunctionCreateInfoNVX (line 11036) | typedef struct VkCuFunctionCreateInfoNVX
type VkCuLaunchInfoNVX (line 11044) | typedef struct VkCuLaunchInfoNVX
type VkCuModuleCreateInfoNVX (line 11063) | typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, c...
type VkCuFunctionCreateInfoNVX (line 11064) | typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device,...
type VkImageViewHandleInfoNVX (line 11074) | typedef struct VkImageViewHandleInfoNVX
type VkImageViewAddressPropertiesNVX (line 11083) | typedef struct VkImageViewAddressPropertiesNVX
type VkVideoEncodeH264CapabilityFlagBitsKHR (line 11113) | typedef enum
type VkFlags (line 11128) | typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR;
type VkVideoEncodeH264StdFlagBitsKHR (line 11130) | typedef enum
type VkFlags (line 11154) | typedef VkFlags VkVideoEncodeH264StdFlagsKHR;
type VkVideoEncodeH264RateControlFlagBitsKHR (line 11156) | typedef enum
type VkFlags (line 11165) | typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR;
type VkVideoEncodeH264CapabilitiesKHR (line 11167) | typedef struct VkVideoEncodeH264CapabilitiesKHR
type VkVideoEncodeH264QpKHR (line 11186) | typedef struct VkVideoEncodeH264QpKHR
type VkVideoEncodeH264QualityLevelPropertiesKHR (line 11193) | typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR
type VkVideoEncodeH264SessionCreateInfoKHR (line 11208) | typedef struct VkVideoEncodeH264SessionCreateInfoKHR
type VkVideoEncodeH264SessionParametersAddInfoKHR (line 11216) | typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR
type VkVideoEncodeH264SessionParametersCreateInfoKHR (line 11226) | typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR
type VkVideoEncodeH264SessionParametersGetInfoKHR (line 11235) | typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR
type VkVideoEncodeH264SessionParametersFeedbackInfoKHR (line 11245) | typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR
type VkVideoEncodeH264NaluSliceInfoKHR (line 11253) | typedef struct VkVideoEncodeH264NaluSliceInfoKHR
type VkVideoEncodeH264PictureInfoKHR (line 11261) | typedef struct VkVideoEncodeH264PictureInfoKHR
type VkVideoEncodeH264DpbSlotInfoKHR (line 11271) | typedef struct VkVideoEncodeH264DpbSlotInfoKHR
type VkVideoEncodeH264ProfileInfoKHR (line 11278) | typedef struct VkVideoEncodeH264ProfileInfoKHR
type VkVideoEncodeH264RateControlInfoKHR (line 11285) | typedef struct VkVideoEncodeH264RateControlInfoKHR
type VkVideoEncodeH264FrameSizeKHR (line 11296) | typedef struct VkVideoEncodeH264FrameSizeKHR
type VkVideoEncodeH264RateControlLayerInfoKHR (line 11303) | typedef struct VkVideoEncodeH264RateControlLayerInfoKHR
type VkVideoEncodeH264GopRemainingFrameInfoKHR (line 11315) | typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR
type VkVideoEncodeH265CapabilityFlagBitsKHR (line 11331) | typedef enum
type VkFlags (line 11347) | typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR;
type VkVideoEncodeH265StdFlagBitsKHR (line 11349) | typedef enum
type VkFlags (line 11374) | typedef VkFlags VkVideoEncodeH265StdFlagsKHR;
type VkVideoEncodeH265CtbSizeFlagBitsKHR (line 11376) | typedef enum
type VkFlags (line 11383) | typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR;
type VkVideoEncodeH265TransformBlockSizeFlagBitsKHR (line 11385) | typedef enum
type VkFlags (line 11393) | typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR;
type VkVideoEncodeH265RateControlFlagBitsKHR (line 11395) | typedef enum
type VkFlags (line 11404) | typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR;
type VkVideoEncodeH265CapabilitiesKHR (line 11406) | typedef struct VkVideoEncodeH265CapabilitiesKHR
type VkVideoEncodeH265SessionCreateInfoKHR (line 11428) | typedef struct VkVideoEncodeH265SessionCreateInfoKHR
type VkVideoEncodeH265QpKHR (line 11436) | typedef struct VkVideoEncodeH265QpKHR
type VkVideoEncodeH265QualityLevelPropertiesKHR (line 11443) | typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR
type VkVideoEncodeH265SessionParametersAddInfoKHR (line 11457) | typedef struct VkVideoEncodeH265SessionParametersAddInfoKHR
type VkVideoEncodeH265SessionParametersCreateInfoKHR (line 11469) | typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR
type VkVideoEncodeH265SessionParametersGetInfoKHR (line 11479) | typedef struct VkVideoEncodeH265SessionParametersGetInfoKHR
type VkVideoEncodeH265SessionParametersFeedbackInfoKHR (line 11491) | typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR
type VkVideoEncodeH265NaluSliceSegmentInfoKHR (line 11500) | typedef struct VkVideoEncodeH265NaluSliceSegmentInfoKHR
type VkVideoEncodeH265PictureInfoKHR (line 11508) | typedef struct VkVideoEncodeH265PictureInfoKHR
type VkVideoEncodeH265DpbSlotInfoKHR (line 11517) | typedef struct VkVideoEncodeH265DpbSlotInfoKHR
type VkVideoEncodeH265ProfileInfoKHR (line 11524) | typedef struct VkVideoEncodeH265ProfileInfoKHR
type VkVideoEncodeH265RateControlInfoKHR (line 11531) | typedef struct VkVideoEncodeH265RateControlInfoKHR
type VkVideoEncodeH265FrameSizeKHR (line 11542) | typedef struct VkVideoEncodeH265FrameSizeKHR
type VkVideoEncodeH265RateControlLayerInfoKHR (line 11549) | typedef struct VkVideoEncodeH265RateControlLayerInfoKHR
type VkVideoEncodeH265GopRemainingFrameInfoKHR (line 11561) | typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR
type VkVideoDecodeH264PictureLayoutFlagBitsKHR (line 11577) | typedef enum
type VkFlags (line 11584) | typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR;
type VkVideoDecodeH264ProfileInfoKHR (line 11586) | typedef struct VkVideoDecodeH264ProfileInfoKHR
type VkVideoDecodeH264CapabilitiesKHR (line 11594) | typedef struct VkVideoDecodeH264CapabilitiesKHR
type VkVideoDecodeH264SessionParametersAddInfoKHR (line 11602) | typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR
type VkVideoDecodeH264SessionParametersCreateInfoKHR (line 11612) | typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR
type VkVideoDecodeH264PictureInfoKHR (line 11621) | typedef struct VkVideoDecodeH264PictureInfoKHR
type VkVideoDecodeH264DpbSlotInfoKHR (line 11630) | typedef struct VkVideoDecodeH264DpbSlotInfoKHR
type VkTextureLODGatherFormatPropertiesAMD (line 11642) | typedef struct VkTextureLODGatherFormatPropertiesAMD
type VkShaderInfoTypeAMD (line 11654) | typedef enum
type VkShaderResourceUsageAMD (line 11663) | typedef struct VkShaderResourceUsageAMD
type VkShaderStatisticsInfoAMD (line 11672) | typedef struct VkShaderStatisticsInfoAMD
type VkRenderingFlags (line 11691) | typedef VkRenderingFlags VkRenderingFlagsKHR;
type VkRenderingFlagBits (line 11692) | typedef VkRenderingFlagBits VkRenderingFlagBitsKHR;
type VkRenderingInfo (line 11693) | typedef VkRenderingInfo VkRenderingInfoKHR;
type VkRenderingAttachmentInfo (line 11695) | typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR;
type VkPipelineRenderingCreateInfo (line 11697) | typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR;
type VkPhysicalDeviceDynamicRenderingFeatures (line 11699) | typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamic...
type VkCommandBufferInheritanceRenderingInfo (line 11701) | typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritan...
type VkPhysicalDeviceCornerSampledImageFeaturesNV (line 11716) | typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV
type VkRenderPassMultiviewCreateInfo (line 11733) | typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
type VkPhysicalDeviceMultiviewFeatures (line 11735) | typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeatu...
type VkPhysicalDeviceMultiviewProperties (line 11737) | typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPro...
type VkPhysicalDeviceFeatures2 (line 11749) | typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
type VkPhysicalDeviceProperties2 (line 11751) | typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
type VkFormatProperties2 (line 11753) | typedef VkFormatProperties2 VkFormatProperties2KHR;
type VkImageFormatProperties2 (line 11755) | typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
type VkPhysicalDeviceImageFormatInfo2 (line 11757) | typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo...
type VkQueueFamilyProperties2 (line 11759) | typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
type VkPhysicalDeviceMemoryProperties2 (line 11761) | typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperti...
type VkSparseImageFormatProperties2 (line 11763) | typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
type VkPhysicalDeviceSparseImageFormatInfo2 (line 11765) | typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseIma...
type VkPhysicalDeviceImageFormatInfo2 (line 11770) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatPropertie...
type VkPeerMemoryFeatureFlags (line 11780) | typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
type VkPeerMemoryFeatureFlagBits (line 11781) | typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
type VkMemoryAllocateFlags (line 11782) | typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
type VkMemoryAllocateFlagBits (line 11783) | typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
type VkMemoryAllocateFlagsInfo (line 11784) | typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
type VkDeviceGroupRenderPassBeginInfo (line 11786) | typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInf...
type VkDeviceGroupCommandBufferBeginInfo (line 11788) | typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBe...
type VkDeviceGroupSubmitInfo (line 11790) | typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
type VkDeviceGroupBindSparseInfo (line 11792) | typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
type VkBindBufferMemoryDeviceGroupInfo (line 11794) | typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupI...
type VkBindImageMemoryDeviceGroupInfo (line 11796) | typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInf...
type VkPhysicalDeviceTextureCompressionASTCHDRFeatures (line 11822) | typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDevi...
type VkImageViewASTCDecodeModeEXT (line 11829) | typedef struct VkImageViewASTCDecodeModeEXT
type VkPhysicalDeviceASTCDecodeFeaturesEXT (line 11836) | typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT
type VkPipelineRobustnessBufferBehavior (line 11848) | typedef VkPipelineRobustnessBufferBehavior VkPipelineRobustnessBufferBeh...
type VkPipelineRobustnessImageBehavior (line 11849) | typedef VkPipelineRobustnessImageBehavior VkPipelineRobustnessImageBehav...
type VkPhysicalDevicePipelineRobustnessFeatures (line 11850) | typedef VkPhysicalDevicePipelineRobustnessFeatures VkPhysicalDevicePipel...
type VkPhysicalDevicePipelineRobustnessProperties (line 11852) | typedef VkPhysicalDevicePipelineRobustnessProperties VkPhysicalDevicePip...
type VkPipelineRobustnessCreateInfo (line 11854) | typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT;
type VkCommandPoolTrimFlags (line 11861) | typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
type VkPhysicalDeviceGroupProperties (line 11869) | typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
type VkDeviceGroupDeviceCreateInfo (line 11871) | typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
type VkExternalMemoryHandleTypeFlags (line 11880) | typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
type VkExternalMemoryHandleTypeFlagBits (line 11881) | typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFla...
type VkExternalMemoryFeatureFlags (line 11882) | typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
type VkExternalMemoryFeatureFlagBits (line 11883) | typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
type VkExternalMemoryProperties (line 11884) | typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
type VkPhysicalDeviceExternalImageFormatInfo (line 11886) | typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternal...
type VkExternalImageFormatProperties (line 11888) | typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
type VkPhysicalDeviceExternalBufferInfo (line 11890) | typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBuffe...
type VkExternalBufferProperties (line 11892) | typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
type VkPhysicalDeviceIDProperties (line 11894) | typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
type VkExternalMemoryHandleTypeFlagBitsNV (line 11904) | typedef enum
type VkFlags (line 11912) | typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
type VkExternalMemoryFeatureFlagBitsNV (line 11914) | typedef enum
type VkFlags (line 11921) | typedef VkFlags VkExternalMemoryFeatureFlagsNV;
type VkExternalImageFormatPropertiesNV (line 11923) | typedef struct VkExternalImageFormatPropertiesNV
type VkExternalMemoryImageCreateInfo (line 11939) | typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
type VkExternalMemoryBufferCreateInfo (line 11941) | typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInf...
type VkExportMemoryAllocateInfo (line 11943) | typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
type VkExternalMemoryImageCreateInfoNV (line 11950) | typedef struct VkExternalMemoryImageCreateInfoNV
type VkExportMemoryAllocateInfoNV (line 11957) | typedef struct VkExportMemoryAllocateInfoNV
type VkImportMemoryFdInfoKHR (line 11969) | typedef struct VkImportMemoryFdInfoKHR
type VkMemoryFdPropertiesKHR (line 11977) | typedef struct VkMemoryFdPropertiesKHR
type VkMemoryGetFdInfoKHR (line 11984) | typedef struct VkMemoryGetFdInfoKHR
type VkMemoryGetFdInfoKHR (line 11993) | typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, cons...
type VkExternalSemaphoreHandleTypeFlags (line 12001) | typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleType...
type VkExternalSemaphoreHandleTypeFlagBits (line 12002) | typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleT...
type VkExternalSemaphoreFeatureFlags (line 12003) | typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
type VkExternalSemaphoreFeatureFlagBits (line 12004) | typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFla...
type VkPhysicalDeviceExternalSemaphoreInfo (line 12005) | typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSe...
type VkExternalSemaphoreProperties (line 12007) | typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
type VkSemaphoreImportFlags (line 12016) | typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
type VkSemaphoreImportFlagBits (line 12017) | typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
type VkExportSemaphoreCreateInfo (line 12018) | typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
type VkImportSemaphoreFdInfoKHR (line 12025) | typedef struct VkImportSemaphoreFdInfoKHR
type VkSemaphoreGetFdInfoKHR (line 12035) | typedef struct VkSemaphoreGetFdInfoKHR
type VkImportSemaphoreFdInfoKHR (line 12044) | typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device...
type VkSemaphoreGetFdInfoKHR (line 12045) | typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, c...
type VkPhysicalDevicePushDescriptorProperties (line 12052) | typedef VkPhysicalDevicePushDescriptorProperties VkPhysicalDevicePushDes...
type VkConditionalRenderingFlagBitsEXT (line 12063) | typedef enum
type VkFlags (line 12068) | typedef VkFlags VkConditionalRenderingFlagsEXT;
type VkConditionalRenderingBeginInfoEXT (line 12070) | typedef struct VkConditionalRenderingBeginInfoEXT
type VkPhysicalDeviceConditionalRenderingFeaturesEXT (line 12079) | typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT
type VkCommandBufferInheritanceConditionalRenderingInfoEXT (line 12087) | typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT
type VkPhysicalDeviceShaderFloat16Int8Features (line 12103) | typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShader...
type VkPhysicalDeviceShaderFloat16Int8Features (line 12105) | typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat1...
type VkPhysicalDevice16BitStorageFeatures (line 12117) | typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorag...
type VkRectLayerKHR (line 12124) | typedef struct VkRectLayerKHR
type VkPresentRegionKHR (line 12131) | typedef struct VkPresentRegionKHR
type VkPresentRegionsKHR (line 12137) | typedef struct VkPresentRegionsKHR
type VkDescriptorUpdateTemplate (line 12150) | typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
type VkDescriptorUpdateTemplateCreateFlags (line 12151) | typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplate...
type VkDescriptorUpdateTemplateType (line 12152) | typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
type VkDescriptorUpdateTemplateEntry (line 12153) | typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
type VkDescriptorUpdateTemplateCreateInfo (line 12155) | typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateC...
type VkDescriptorUpdateTemplateCreateInfo (line 12157) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(Vk...
type VkViewportWScalingNV (line 12166) | typedef struct VkViewportWScalingNV
type VkPipelineViewportWScalingStateCreateInfoNV (line 12172) | typedef struct VkPipelineViewportWScalingStateCreateInfoNV
type VkSurfaceCounterFlagBitsEXT (line 12197) | typedef enum
type VkFlags (line 12203) | typedef VkFlags VkSurfaceCounterFlagsEXT;
type VkSurfaceCapabilities2EXT (line 12205) | typedef struct VkSurfaceCapabilities2EXT
type VkDisplayPowerStateEXT (line 12230) | typedef enum
type VkDeviceEventTypeEXT (line 12238) | typedef enum
type VkDisplayEventTypeEXT (line 12244) | typedef enum
type VkDisplayPowerInfoEXT (line 12251) | typedef struct VkDisplayPowerInfoEXT
type VkDeviceEventInfoEXT (line 12258) | typedef struct VkDeviceEventInfoEXT
type VkDisplayEventInfoEXT (line 12265) | typedef struct VkDisplayEventInfoEXT
type VkSwapchainCounterCreateInfoEXT (line 12272) | typedef struct VkSwapchainCounterCreateInfoEXT
type VkDeviceEventInfoEXT (line 12281) | typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice devi...
type const (line 12282) | typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice dev...
type VkRefreshCycleDurationGOOGLE (line 12290) | typedef struct VkRefreshCycleDurationGOOGLE
type VkPastPresentationTimingGOOGLE (line 12295) | typedef struct VkPastPresentationTimingGOOGLE
type VkPresentTimeGOOGLE (line 12304) | typedef struct VkPresentTimeGOOGLE
type VkPresentTimesInfoGOOGLE (line 12310) | typedef struct VkPresentTimesInfoGOOGLE
type VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX (line 12342) | typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
type VkMultiviewPerViewAttributesInfoNVX (line 12349) | typedef struct VkMultiviewPerViewAttributesInfoNVX
type VkViewportCoordinateSwizzleNV (line 12362) | typedef enum
type VkFlags (line 12375) | typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
type VkViewportSwizzleNV (line 12377) | typedef struct VkViewportSwizzleNV
type VkPipelineViewportSwizzleStateCreateInfoNV (line 12385) | typedef struct VkPipelineViewportSwizzleStateCreateInfoNV
type VkFlags (line 12399) | typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
type VkDiscardRectangleModeEXT (line 12400) | typedef enum
type VkPhysicalDeviceDiscardRectanglePropertiesEXT (line 12408) | typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT
type VkPipelineDiscardRectangleStateCreateInfoEXT (line 12415) | typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT
type VkFlags (line 12435) | typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
type VkConservativeRasterizationModeEXT (line 12436) | typedef enum
type VkPhysicalDeviceConservativeRasterizationPropertiesEXT (line 12445) | typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT
type VkPipelineRasterizationConservativeStateCreateInfoEXT (line 12460) | typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT
type VkFlags (line 12474) | typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
type VkPhysicalDeviceDepthClipEnableFeaturesEXT (line 12475) | typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT
type VkPipelineRasterizationDepthClipStateCreateInfoEXT (line 12482) | typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT
type VkXYColorEXT (line 12500) | typedef struct VkXYColorEXT
type VkHdrMetadataEXT (line 12506) | typedef struct VkHdrMetadataEXT
type VkPhysicalDeviceImagelessFramebufferFeatures (line 12528) | typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceIma...
type VkFramebufferAttachmentsCreateInfo (line 12530) | typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreat...
type VkFramebufferAttachmentImageInfo (line 12532) | typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInf...
type VkRenderPassAttachmentBeginInfo (line 12534) | typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
type VkRenderPassCreateInfo2 (line 12541) | typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
type VkAttachmentDescription2 (line 12543) | typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
type VkAttachmentReference2 (line 12545) | typedef VkAttachmentReference2 VkAttachmentReference2KHR;
type VkSubpassDescription2 (line 12547) | typedef VkSubpassDescription2 VkSubpassDescription2KHR;
type VkSubpassDependency2 (line 12549) | typedef VkSubpassDependency2 VkSubpassDependency2KHR;
type VkSubpassBeginInfo (line 12551) | typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
type VkSubpassEndInfo (line 12553) | typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
type VkRenderPassCreateInfo2 (line 12555) | typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device...
type VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG (line 12565) | typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG
type VkSharedPresentSurfaceCapabilitiesKHR (line 12577) | typedef struct VkSharedPresentSurfaceCapabilitiesKHR
type VkExternalFenceHandleTypeFlags (line 12592) | typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
type VkExternalFenceHandleTypeFlagBits (line 12593) | typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagB...
type VkExternalFenceFeatureFlags (line 12594) | typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
type VkExternalFenceFeatureFlagBits (line 12595) | typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
type VkPhysicalDeviceExternalFenceInfo (line 12596) | typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceI...
type VkExternalFenceProperties (line 12598) | typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
type VkFenceImportFlags (line 12607) | typedef VkFenceImportFlags VkFenceImportFlagsKHR;
type VkFenceImportFlagBits (line 12608) | typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
type VkExportFenceCreateInfo (line 12609) | typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
type VkImportFenceFdInfoKHR (line 12616) | typedef struct VkImportFenceFdInfoKHR
type VkFenceGetFdInfoKHR (line 12626) | typedef struct VkFenceGetFdInfoKHR
type VkImportFenceFdInfoKHR (line 12635) | typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, co...
type VkFenceGetFdInfoKHR (line 12636) | typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const...
type VkPerformanceCounterUnitKHR (line 12643) | typedef enum
type VkPerformanceCounterScopeKHR (line 12659) | typedef enum
type VkPerformanceCounterStorageKHR (line 12670) | typedef enum
type VkPerformanceCounterDescriptionFlagBitsKHR (line 12682) | typedef enum
type VkFlags (line 12690) | typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
type VkAcquireProfilingLockFlagBitsKHR (line 12692) | typedef enum
type VkFlags (line 12696) | typedef VkFlags VkAcquireProfilingLockFlagsKHR;
type VkPhysicalDevicePerformanceQueryFeaturesKHR (line 12698) | typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR
type VkPhysicalDevicePerformanceQueryPropertiesKHR (line 12706) | typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR
type VkPerformanceCounterKHR (line 12713) | typedef struct VkPerformanceCounterKHR
type VkPerformanceCounterDescriptionKHR (line 12723) | typedef struct VkPerformanceCounterDescriptionKHR
type VkQueryPoolPerformanceCreateInfoKHR (line 12733) | typedef struct VkQueryPoolPerformanceCreateInfoKHR
type VkPerformanceCounterResultKHR (line 12742) | typedef union VkPerformanceCounterResultKHR
type VkAcquireProfilingLockInfoKHR (line 12752) | typedef struct VkAcquireProfilingLockInfoKHR
type VkPerformanceQuerySubmitInfoKHR (line 12760) | typedef struct VkPerformanceQuerySubmitInfoKHR
type VkPerformanceQueryReservationInfoKHR (line 12767) | typedef struct VkPerformanceQueryReservationInfoKHR
type VkAcquireProfilingLockInfoKHR (line 12777) | typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice dev...
type VkPointClippingBehavior (line 12785) | typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
type VkTessellationDomainOrigin (line 12786) | typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
type VkPhysicalDevicePointClippingProperties (line 12787) | typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointCli...
type VkRenderPassInputAttachmentAspectCreateInfo (line 12789) | typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAtt...
type VkInputAttachmentAspectReference (line 12791) | typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenc...
type VkImageViewUsageCreateInfo (line 12793) | typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
type VkPipelineTessellationDomainOriginStateCreateInfo (line 12795) | typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTess...
type VkPhysicalDeviceSurfaceInfo2KHR (line 12802) | typedef struct VkPhysicalDeviceSurfaceInfo2KHR
type VkSurfaceCapabilities2KHR (line 12809) | typedef struct VkSurfaceCapabilities2KHR
type VkSurfaceFormat2KHR (line 12816) | typedef struct VkSurfaceFormat2KHR
type VkPhysicalDeviceSurfaceInfo2KHR (line 12824) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2...
type VkPhysicalDeviceSurfaceInfo2KHR (line 12825) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(...
type VkPhysicalDeviceVariablePointersFeatures (line 12832) | typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariabl...
type VkPhysicalDeviceVariablePointersFeatures (line 12834) | typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariabl...
type VkDisplayProperties2KHR (line 12841) | typedef struct VkDisplayProperties2KHR
type VkDisplayPlaneProperties2KHR (line 12848) | typedef struct VkDisplayPlaneProperties2KHR
type VkDisplayModeProperties2KHR (line 12855) | typedef struct VkDisplayModeProperties2KHR
type VkDisplayPlaneInfo2KHR (line 12862) | typedef struct VkDisplayPlaneInfo2KHR
type VkDisplayPlaneCapabilities2KHR (line 12870) | typedef struct VkDisplayPlaneCapabilities2KHR
type VkDisplayPlaneInfo2KHR (line 12881) | typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPh...
type VkMemoryDedicatedRequirements (line 12900) | typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
type VkMemoryDedicatedAllocateInfo (line 12902) | typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
type VkDedicatedAllocationImageCreateInfoNV (line 12909) | typedef struct VkDedicatedAllocationImageCreateInfoNV
type VkDedicatedAllocationBufferCreateInfoNV (line 12916) | typedef struct VkDedicatedAllocationBufferCreateInfoNV
type VkDedicatedAllocationMemoryAllocateInfoNV (line 12923) | typedef struct VkDedicatedAllocationMemoryAllocateInfoNV
type VkFlags (line 12947) | typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
type VkFlags (line 12948) | typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
type VkDebugUtilsMessageSeverityFlagBitsEXT (line 12950) | typedef enum
type VkFlags (line 12958) | typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
type VkFlags (line 12959) | typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
type VkDebugUtilsLabelEXT (line 12961) | typedef struct VkDebugUtilsLabelEXT
type VkDebugUtilsObjectNameInfoEXT (line 12969) | typedef struct VkDebugUtilsObjectNameInfoEXT
type VkDebugUtilsMessengerCallbackDataEXT (line 12978) | typedef struct VkDebugUtilsMessengerCallbackDataEXT
type VkDebugUtilsMessengerCallbackDataEXT (line 12994) | typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(VkDeb...
type VkDebugUtilsMessengerCreateInfoEXT (line 12996) | typedef struct VkDebugUtilsMessengerCreateInfoEXT
type VkDebugUtilsObjectTagInfoEXT (line 13007) | typedef struct VkDebugUtilsObjectTagInfoEXT
type VkDebugUtilsObjectNameInfoEXT (line 13019) | typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice ...
type VkDebugUtilsObjectTagInfoEXT (line 13020) | typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice d...
type VkDebugUtilsMessengerCreateInfoEXT (line 13027) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInsta...
type VkDebugReportObjectTypeEXT (line 13036) | typedef enum
type VkDebugMarkerObjectNameInfoEXT (line 13087) | typedef struct VkDebugMarkerObjectNameInfoEXT
type VkDebugMarkerObjectTagInfoEXT (line 13096) | typedef struct VkDebugMarkerObjectTagInfoEXT
type VkDebugMarkerMarkerInfoEXT (line 13107) | typedef struct VkDebugMarkerMarkerInfoEXT
type VkDebugMarkerObjectTagInfoEXT (line 13116) | typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice ...
type VkDebugMarkerObjectNameInfoEXT (line 13117) | typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice...
type VkFlags (line 13139) | typedef VkFlags VkDebugReportFlagsEXT;
type const (line 13141) | typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(VkDebugReport...
type VkDebugReportCallbackCreateInfoEXT (line 13143) | typedef struct VkDebugReportCallbackCreateInfoEXT
type VkDebugReportCallbackCreateInfoEXT (line 13153) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInsta...
type VkSamplerReductionMode (line 13162) | typedef VkSamplerReductionMode VkSamplerReductionModeEXT;
type VkSamplerReductionModeCreateInfo (line 13163) | typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInf...
type VkPhysicalDeviceSamplerFilterMinmaxProperties (line 13165) | typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSa...
type VkFlags64 (line 13187) | typedef VkFlags64 VkTensorViewCreateFlagsARM;
type VkDescriptorMappingSourceEXT (line 13188) | typedef enum
type VkSpirvResourceTypeFlagBitsEXT (line 13205) | typedef enum
type VkFlags (line 13220) | typedef VkFlags VkSpirvResourceTypeFlagsEXT;
type VkHostAddressRangeEXT (line 13222) | typedef struct VkHostAddressRangeEXT
type VkHostAddressRangeConstEXT (line 13228) | typedef struct VkHostAddressRangeConstEXT
type VkDeviceAddressRangeEXT (line 13234) | typedef struct VkDeviceAddressRangeEXT
type VkTexelBufferDescriptorInfoEXT (line 13240) | typedef struct VkTexelBufferDescriptorInfoEXT
type VkImageDescriptorInfoEXT (line 13248) | typedef struct VkImageDescriptorInfoEXT
type VkTensorViewCreateInfoARM (line 13256) | typedef struct VkTensorViewCreateInfoARM
type VkResourceDescriptorDataEXT (line 13265) | typedef union VkResourceDescriptorDataEXT
type VkResourceDescriptorInfoEXT (line 13273) | typedef struct VkResourceDescriptorInfoEXT
type VkBindHeapInfoEXT (line 13281) | typedef struct VkBindHeapInfoEXT
type VkPushDataInfoEXT (line 13290) | typedef struct VkPushDataInfoEXT
type VkDescriptorMappingSourceConstantOffsetEXT (line 13298) | typedef struct VkDescriptorMappingSourceConstantOffsetEXT
type VkDescriptorMappingSourcePushIndexEXT (line 13307) | typedef struct VkDescriptorMappingSourcePushIndexEXT
type VkDescriptorMappingSourceIndirectIndexEXT (line 13321) | typedef struct VkDescriptorMappingSourceIndirectIndexEXT
type VkDescriptorMappingSourceHeapDataEXT (line 13337) | typedef struct VkDescriptorMappingSourceHeapDataEXT
type VkDescriptorMappingSourceIndirectAddressEXT (line 13343) | typedef struct VkDescriptorMappingSourceIndirectAddressEXT
type VkDescriptorMappingSourceShaderRecordIndexEXT (line 13349) | typedef struct VkDescriptorMappingSourceShaderRecordIndexEXT
type VkDescriptorMappingSourceIndirectIndexArrayEXT (line 13363) | typedef struct VkDescriptorMappingSourceIndirectIndexArrayEXT
type VkDescriptorMappingSourceDataEXT (line 13377) | typedef union VkDescriptorMappingSourceDataEXT
type VkDescriptorSetAndBindingMappingEXT (line 13392) | typedef struct VkDescriptorSetAndBindingMappingEXT
type VkShaderDescriptorSetAndBindingMappingInfoEXT (line 13404) | typedef struct VkShaderDescriptorSetAndBindingMappingInfoEXT
type VkOpaqueCaptureDataCreateInfoEXT (line 13412) | typedef struct VkOpaqueCaptureDataCreateInfoEXT
type VkPhysicalDeviceDescriptorHeapFeaturesEXT (line 13419) | typedef struct VkPhysicalDeviceDescriptorHeapFeaturesEXT
type VkPhysicalDeviceDescriptorHeapPropertiesEXT (line 13427) | typedef struct VkPhysicalDeviceDescriptorHeapPropertiesEXT
type VkCommandBufferInheritanceDescriptorHeapInfoEXT (line 13452) | typedef struct VkCommandBufferInheritanceDescriptorHeapInfoEXT
type VkSamplerCustomBorderColorIndexCreateInfoEXT (line 13460) | typedef struct VkSamplerCustomBorderColorIndexCreateInfoEXT
type VkSamplerCustomBorderColorCreateInfoEXT (line 13467) | typedef struct VkSamplerCustomBorderColorCreateInfoEXT
type VkIndirectCommandsLayoutPushDataTokenNV (line 13475) | typedef struct VkIndirectCommandsLayoutPushDataTokenNV
type VkSubsampledImageFormatPropertiesEXT (line 13483) | typedef struct VkSubsampledImageFormatPropertiesEXT
type VkPhysicalDeviceDescriptorHeapTensorPropertiesARM (line 13490) | typedef struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM
type const (line 13500) | typedef VkResult (VKAPI_PTR *PFN_vkWriteSamplerDescriptorsEXT)(VkDevice ...
type const (line 13501) | typedef VkResult (VKAPI_PTR *PFN_vkWriteResourceDescriptorsEXT)(VkDevice...
type const (line 13505) | typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDataEXT)(VkDevic...
type VkSamplerCustomBorderColorCreateInfoEXT (line 13507) | typedef VkResult (VKAPI_PTR *PFN_vkRegisterCustomBorderColorEXT)(VkDevic...
type const (line 13509) | typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDataARM)(VkDevi...
type VkAttachmentSampleCountInfoAMD (line 13516) | typedef struct VkAttachmentSampleCountInfoAMD
type VkPhysicalDeviceInlineUniformBlockFeatures (line 13535) | typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlin...
type VkPhysicalDeviceInlineUniformBlockProperties (line 13537) | typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInl...
type VkWriteDescriptorSetInlineUniformBlock (line 13539) | typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlin...
type VkDescriptorPoolInlineUniformBlockCreateInfo (line 13541) | typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInl...
type VkPhysicalDeviceShaderBfloat16FeaturesKHR (line 13553) | typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR
type VkSampleLocationEXT (line 13567) | typedef struct VkSampleLocationEXT
type VkSampleLocationsInfoEXT (line 13573) | typedef struct VkSampleLocationsInfoEXT
type VkAttachmentSampleLocationsEXT (line 13583) | typedef struct VkAttachmentSampleLocationsEXT
type VkSubpassSampleLocationsEXT (line 13589) | typedef struct VkSubpassSampleLocationsEXT
type VkRenderPassSampleLocationsBeginInfoEXT (line 13595) | typedef struct VkRenderPassSampleLocationsBeginInfoEXT
type VkPipelineSampleLocationsStateCreateInfoEXT (line 13605) | typedef struct VkPipelineSampleLocationsStateCreateInfoEXT
type VkPhysicalDeviceSampleLocationsPropertiesEXT (line 13613) | typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT
type VkMultisamplePropertiesEXT (line 13624) | typedef struct VkMultisamplePropertiesEXT
type VkBufferMemoryRequirementsInfo2 (line 13645) | typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
type VkImageMemoryRequirementsInfo2 (line 13647) | typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
type VkImageSparseMemoryRequirementsInfo2 (line 13649) | typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirem...
type VkMemoryRequirements2 (line 13651) | typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
type VkSparseImageMemoryRequirements2 (line 13653) | typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements...
type VkImageFormatListCreateInfo (line 13664) | typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
type VkBlendOverlapEXT (line 13671) | typedef enum
type VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT (line 13680) | typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
type VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT (line 13687) | typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
type VkPipelineColorBlendAdvancedStateCreateInfoEXT (line 13699) | typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT
type VkFlags (line 13713) | typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
type VkPipelineCoverageToColorStateCreateInfoNV (line 13714) | typedef struct VkPipelineCoverageToColorStateCreateInfoNV
function VK_DEFINE_NON_DISPATCHABLE_HANDLE (line 13728) | VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
type VkBuildAccelerationStructureFlagBitsKHR (line 13742) | typedef enum
type VkFlags (line 13768) | typedef VkFlags VkBuildAccelerationStructureFlagsKHR;
type VkBuildAccelerationStructureModeKHR (line 13769) | typedef enum
type VkGeometryTypeKHR (line 13776) | typedef enum
type VkGeometryFlagBitsKHR (line 13790) | typedef enum
type VkFlags (line 13798) | typedef VkFlags VkGeometryFlagsKHR;
type VkAccelerationStructureBuildTypeKHR (line 13799) | typedef enum
type VkGeometryInstanceFlagBitsKHR (line 13808) | typedef enum
type VkFlags (line 13825) | typedef VkFlags VkGeometryInstanceFlagsKHR;
type VkAccelerationStructureCreateFlagBitsKHR (line 13827) | typedef enum
type VkFlags (line 13834) | typedef VkFlags VkAccelerationStructureCreateFlagsKHR;
type VkCopyAccelerationStructureModeKHR (line 13835) | typedef enum
type VkAccelerationStructureCompatibilityKHR (line 13846) | typedef enum
type VkDeviceOrHostAddressKHR (line 13854) | typedef union VkDeviceOrHostAddressKHR
type VkDeviceOrHostAddressConstKHR (line 13860) | typedef union VkDeviceOrHostAddressConstKHR
type VkAccelerationStructureBuildRangeInfoKHR (line 13866) | typedef struct VkAccelerationStructureBuildRangeInfoKHR
type VkAabbPositionsKHR (line 13874) | typedef struct VkAabbPositionsKHR
type VkAccelerationStructureGeometryTrianglesDataKHR (line 13884) | typedef struct VkAccelerationStructureGeometryTrianglesDataKHR
type VkTransformMatrixKHR (line 13897) | typedef struct VkTransformMatrixKHR
type VkAccelerationStructureGeometryAabbsDataKHR (line 13902) | typedef struct VkAccelerationStructureGeometryAabbsDataKHR
type VkAccelerationStructureGeometryInstancesDataKHR (line 13910) | typedef struct VkAccelerationStructureGeometryInstancesDataKHR
type VkAccelerationStructureGeometryDataKHR (line 13918) | typedef union VkAccelerationStructureGeometryDataKHR
type VkAccelerationStructureGeometryKHR (line 13925) | typedef struct VkAccelerationStructureGeometryKHR
type VkAccelerationStructureBuildGeometryInfoKHR (line 13934) | typedef struct VkAccelerationStructureBuildGeometryInfoKHR
type VkAccelerationStructureInstanceKHR (line 13949) | typedef struct VkAccelerationStructureInstanceKHR
type VkAccelerationStructureCreateInfoKHR (line 13959) | typedef struct VkAccelerationStructureCreateInfoKHR
type VkWriteDescriptorSetAccelerationStructureKHR (line 13971) | typedef struct VkWriteDescriptorSetAccelerationStructureKHR
type VkPhysicalDeviceAccelerationStructureFeaturesKHR (line 13979) | typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR
type VkPhysicalDeviceAccelerationStructurePropertiesKHR (line 13990) | typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR
type VkAccelerationStructureDeviceAddressInfoKHR (line 14004) | typedef struct VkAccelerationStructureDeviceAddressInfoKHR
type VkAccelerationStructureVersionInfoKHR (line 14011) | typedef struct VkAccelerationStructureVersionInfoKHR
type VkCopyAccelerationStructureToMemoryInfoKHR (line 14018) | typedef struct VkCopyAccelerationStructureToMemoryInfoKHR
type VkCopyMemoryToAccelerationStructureInfoKHR (line 14027) | typedef struct VkCopyMemoryToAccelerationStructureInfoKHR
type VkCopyAccelerationStructureInfoKHR (line 14036) | typedef struct VkCopyAccelerationStructureInfoKHR
type VkAccelerationStructureBuildSizesInfoKHR (line 14045) | typedef struct VkAccelerationStructureBuildSizesInfoKHR
type VkAccelerationStructureCreateInfoKHR (line 14055) | typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDev...
type const (line 14059) | typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDev...
type const (line 14063) | typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresProperties...
type VkAccelerationStructureDeviceAddressInfoKHR (line 14067) | typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDevice...
type VkRayTracingShaderGroupTypeKHR (line 14079) | typedef enum
type VkShaderGroupShaderKHR (line 14090) | typedef enum
type VkRayTracingShaderGroupCreateInfoKHR (line 14100) | typedef struct VkRayTracingShaderGroupCreateInfoKHR
type VkPipelineLibraryCreateInfoKHR (line 14112) | typedef struct VkPipelineLibraryCreateInfoKHR
type VkRayTracingPipelineInterfaceCreateInfoKHR (line 14120) | typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR
type VkRayTracingPipelineCreateInfoKHR (line 14128) | typedef struct VkRayTracingPipelineCreateInfoKHR
type VkPhysicalDeviceRayTracingPipelineFeaturesKHR (line 14146) | typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR
type VkPhysicalDeviceRayTracingPipelinePropertiesKHR (line 14157) | typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR
type VkStridedDeviceAddressRegionKHR (line 14171) | typedef struct VkStridedDeviceAddressRegionKHR
type VkTraceRaysIndirectCommandKHR (line 14178) | typedef struct VkTraceRaysIndirectCommandKHR
type const (line 14187) | typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevic...
type VkPhysicalDeviceRayQueryFeaturesKHR (line 14199) | typedef struct VkPhysicalDeviceRayQueryFeaturesKHR
type VkFlags (line 14211) | typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
type VkCoverageModulationModeNV (line 14212) | typedef enum
type VkPipelineCoverageModulationStateCreateInfoNV (line 14222) | typedef struct VkPipelineCoverageModulationStateCreateInfoNV
type VkAttachmentSampleCountInfoAMD (line 14233) | typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV;
type VkPhysicalDeviceShaderSMBuiltinsPropertiesNV (line 14245) | typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV
type VkPhysicalDeviceShaderSMBuiltinsFeaturesNV (line 14253) | typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV
type VkSamplerYcbcrConversion (line 14270) | typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
type VkSamplerYcbcrModelConversion (line 14271) | typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
type VkSamplerYcbcrRange (line 14272) | typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
type VkChromaLocation (line 14273) | typedef VkChromaLocation VkChromaLocationKHR;
type VkSamplerYcbcrConversionCreateInfo (line 14274) | typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreat...
type VkSamplerYcbcrConversionInfo (line 14276) | typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
type VkBindImagePlaneMemoryInfo (line 14278) | typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
type VkImagePlaneMemoryRequirementsInfo (line 14280) | typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirement...
type VkPhysicalDeviceSamplerYcbcrConversionFeatures (line 14282) | typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceS...
type VkSamplerYcbcrConversionImageFormatProperties (line 14284) | typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConv...
type VkSamplerYcbcrConversionCreateInfo (line 14286) | typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDe...
type VkBindBufferMemoryInfo (line 14294) | typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
type VkBindImageMemoryInfo (line 14296) | typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
type const (line 14298) | typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device...
type const (line 14299) | typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device,...
type VkDrmFormatModifierPropertiesEXT (line 14306) | typedef struct VkDrmFormatModifierPropertiesEXT
type VkDrmFormatModifierPropertiesListEXT (line 14313) | typedef struct VkDrmFormatModifierPropertiesListEXT
type VkPhysicalDeviceImageDrmFormatModifierInfoEXT (line 14321) | typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT
type VkImageDrmFormatModifierListCreateInfoEXT (line 14331) | typedef struct VkImageDrmFormatModifierListCreateInfoEXT
type VkImageDrmFormatModifierExplicitCreateInfoEXT (line 14339) | typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT
type VkImageDrmFormatModifierPropertiesEXT (line 14348) | typedef struct VkImageDrmFormatModifierPropertiesEXT
type VkDrmFormatModifierProperties2EXT (line 14355) | typedef struct VkDrmFormatModifierProperties2EXT
type VkDrmFormatModifierPropertiesList2EXT (line 14362) | typedef struct VkDrmFormatModifierPropertiesList2EXT
type VkValidationCacheHeaderVersionEXT (line 14381) | typedef enum
type VkValidationCacheCreateInfoEXT (line 14388) | typedef struct VkValidationCacheCreateInfoEXT
type VkShaderModuleValidationCacheCreateInfoEXT (line 14397) | typedef struct VkShaderModuleValidationCacheCreateInfoEXT
type VkValidationCacheCreateInfoEXT (line 14405) | typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice de...
type const (line 14407) | typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice de...
type VkDescriptorBindingFlagBits (line 14415) | typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;
type VkDescriptorBindingFlags (line 14416) | typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;
type VkDescriptorSetLayoutBindingFlagsCreateInfo (line 14417) | typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayou...
type VkPhysicalDeviceDescriptorIndexingFeatures (line 14419) | typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescr...
type VkPhysicalDeviceDescriptorIndexingProperties (line 14421) | typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDes...
type VkDescriptorSetVariableDescriptorCountAllocateInfo (line 14423) | typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorS...
type VkDescriptorSetVariableDescriptorCountLayoutSupport (line 14425) | typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptor...
type VkShadingRatePaletteEntryNV (line 14437) | typedef enum
type VkCoarseSampleOrderTypeNV (line 14454) | typedef enum
type VkShadingRatePaletteNV (line 14464) | typedef struct VkShadingRatePaletteNV
type VkPipelineViewportShadingRateImageStateCreateInfoNV (line 14470) | typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV
type VkPhysicalDeviceShadingRateImageFeaturesNV (line 14479) | typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV
type VkPhysicalDeviceShadingRateImagePropertiesNV (line 14487) | typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV
type VkCoarseSampleLocationNV (line 14496) | typedef struct VkCoarseSampleLocationNV
type VkCoarseSampleOrderCustomNV (line 14503) | typedef struct VkCoarseSampleOrderCustomNV
type VkPipelineViewportCoarseSampleOrderStateCreateInfoNV (line 14511) | typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV
type VkGeometryTypeKHR (line 14533) | typedef VkGeometryTypeKHR VkGeometryTypeNV;
type VkAccelerationStructureTypeKHR (line 14534) | typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;
type VkGeometryFlagsKHR (line 14535) | typedef VkGeometryFlagsKHR VkGeometryFlagsNV;
type VkGeometryFlagBitsKHR (line 14536) | typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;
type VkGeometryInstanceFlagsKHR (line 14537) | typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
type VkGeometryInstanceFlagBitsKHR (line 14538) | typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;
type VkBuildAccelerationStructureFlagsKHR (line 14539) | typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructur...
type VkBuildAccelerationStructureFlagBitsKHR (line 14540) | typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStruc...
type VkCopyAccelerationStructureModeKHR (line 14541) | typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureMo...
type VkAccelerationStructureMemoryRequirementsTypeNV (line 14542) | typedef enum
type VkRayTracingShaderGroupCreateInfoNV (line 14551) | typedef struct VkRayTracingShaderGroupCreateInfoNV
type VkRayTracingPipelineCreateInfoNV (line 14562) | typedef struct VkRayTracingPipelineCreateInfoNV
type VkGeometryTrianglesNV (line 14577) | typedef struct VkGeometryTrianglesNV
type VkGeometryAABBNV (line 14594) | typedef struct VkGeometryAABBNV
type VkGeometryDataNV (line 14604) | typedef struct VkGeometryDataNV
type VkGeometryNV (line 14610) | typedef struct VkGeometryNV
type VkAccelerationStructureInfoNV (line 14619) | typedef struct VkAccelerationStructureInfoNV
type VkAccelerationStructureCreateInfoNV (line 14630) | typedef struct VkAccelerationStructureCreateInfoNV
type VkBindAccelerationStructureMemoryInfoNV (line 14638) | typedef struct VkBindAccelerationStructureMemoryInfoNV
type VkWriteDescriptorSetAccelerationStructureNV (line 14649) | typedef struct VkWriteDescriptorSetAccelerationStructureNV
type VkAccelerationStructureMemoryRequirementsInfoNV (line 14657) | typedef struct VkAccelerationStructureMemoryRequirementsInfoNV
type VkPhysicalDeviceRayTracingPropertiesNV (line 14665) | typedef struct VkPhysicalDeviceRayTracingPropertiesNV
type VkTransformMatrixKHR (line 14679) | typedef VkTransformMatrixKHR VkTransformMatrixNV;
type VkAabbPositionsKHR (line 14681) | typedef VkAabbPositionsKHR VkAabbPositionsNV;
type VkAccelerationStructureInstanceKHR (line 14683) | typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstan...
type VkAccelerationStructureCreateInfoNV (line 14686) | typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevi...
type const (line 14689) | typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(Vk...
type const (line 14693) | typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice...
type VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV (line 14704) | typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV
type VkPipelineRepresentativeFragmentTestStateCreateInfoNV (line 14711) | typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV
type VkPhysicalDeviceMaintenance3Properties (line 14723) | typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenan...
type VkDescriptorSetLayoutSupport (line 14725) | typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
type VkPhysicalDeviceImageViewImageFormatInfoEXT (line 14750) | typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT
type VkFilterCubicImageViewImageFormatPropertiesEXT (line 14757) | typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT
type VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM (line 14770) | typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM
type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures (line 14782) | typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDe...
type VkPhysicalDevice8BitStorageFeatures (line 14789) | typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageF...
type VkImportMemoryHostPointerInfoEXT (line 14796) | typedef struct VkImportMemoryHostPointerInfoEXT
type VkMemoryHostPointerPropertiesEXT (line 14804) | typedef struct VkMemoryHostPointerPropertiesEXT
type VkPhysicalDeviceExternalMemoryHostPropertiesEXT (line 14811) | typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT
type VkPhysicalDeviceShaderAtomicInt64Features (line 14834) | typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShader...
type VkPhysicalDeviceShaderClockFeaturesKHR (line 14841) | typedef struct VkPhysicalDeviceShaderClockFeaturesKHR
type VkPipelineCompilerControlFlagBitsAMD (line 14855) | typedef enum
type VkFlags (line 14859) | typedef VkFlags VkPipelineCompilerControlFlagsAMD;
type VkPipelineCompilerControlCreateInfoAMD (line 14861) | typedef struct VkPipelineCompilerControlCreateInfoAMD
type VkPhysicalDeviceShaderCorePropertiesAMD (line 14873) | typedef struct VkPhysicalDeviceShaderCorePropertiesAMD
type VkVideoDecodeH265ProfileInfoKHR (line 14898) | typedef struct VkVideoDecodeH265ProfileInfoKHR
type VkVideoDecodeH265CapabilitiesKHR (line 14905) | typedef struct VkVideoDecodeH265CapabilitiesKHR
type VkVideoDecodeH265SessionParametersAddInfoKHR (line 14912) | typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR
type VkVideoDecodeH265SessionParametersCreateInfoKHR (line 14924) | typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR
type VkVideoDecodeH265PictureInfoKHR (line 14934) | typedef struct VkVideoDecodeH265PictureInfoKHR
type VkVideoDecodeH265DpbSlotInfoKHR (line 14943) | typedef struct VkVideoDecodeH265DpbSlotInfoKHR
type VkPhysicalDeviceGlobalPriorityQueryFeatures (line 14955) | typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlob...
type VkQueueFamilyGlobalPriorityProperties (line 14957) | typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorit...
type VkQueueGlobalPriority (line 14964) | typedef VkQueueGlobalPriority VkQueueGlobalPriorityKHR;
type VkDeviceQueueGlobalPriorityCreateInfo (line 14965) | typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorit...
type VkPhysicalDeviceGlobalPriorityQueryFeatures (line 14967) | typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlob...
type VkQueueFamilyGlobalPriorityProperties (line 14969) | typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorit...
type VkQueueGlobalPriority (line 14976) | typedef VkQueueGlobalPriority VkQueueGlobalPriorityEXT;
type VkDeviceQueueGlobalPriorityCreateInfo (line 14977) | typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorit...
type VkMemoryOverallocationBehaviorAMD (line 14984) | typedef enum
type VkDeviceMemoryOverallocationCreateInfoAMD (line 14993) | typedef struct VkDeviceMemoryOverallocationCreateInfoAMD
type VkPipelineCreationFeedbackFlagBits (line 15005) | typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFla...
type VkPipelineCreationFeedbackFlags (line 15006) | typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT;
type VkPipelineCreationFeedbackCreateInfo (line 15007) | typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackC...
type VkPipelineCreationFeedback (line 15009) | typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT;
type VkDriverId (line 15016) | typedef VkDriverId VkDriverIdKHR;
type VkConformanceVersion (line 15017) | typedef VkConformanceVersion VkConformanceVersionKHR;
type VkPhysicalDeviceDriverProperties (line 15019) | typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertie...
type VkShaderFloatControlsIndependence (line 15026) | typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndepende...
type VkPhysicalDeviceFloatControlsProperties (line 15027) | typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatCon...
type VkResolveModeFlagBits (line 15034) | typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;
type VkResolveModeFlags (line 15035) | typedef VkResolveModeFlags VkResolveModeFlagsKHR;
type VkSubpassDescriptionDepthStencilResolve (line 15036) | typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDept...
type VkPhysicalDeviceDepthStencilResolveProperties (line 15038) | typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDe...
type VkPhysicalDeviceMeshShaderFeaturesNV (line 15050) | typedef struct VkPhysicalDeviceMeshShaderFeaturesNV
type VkPhysicalDeviceMeshShaderPropertiesNV (line 15058) | typedef struct VkPhysicalDeviceMeshShaderPropertiesNV
type VkDrawMeshTasksIndirectCommandNV (line 15077) | typedef struct VkDrawMeshTasksIndirectCommandNV
type VkPhysicalDeviceShaderImageFootprintFeaturesNV (line 15093) | typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV
type VkPipelineViewportExclusiveScissorStateCreateInfoNV (line 15105) | typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV
type VkPhysicalDeviceExclusiveScissorFeaturesNV (line 15113) | typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV
type VkQueueFamilyCheckpointPropertiesNV (line 15129) | typedef struct VkQueueFamilyCheckpointPropertiesNV
type VkCheckpointDataNV (line 15136) | typedef struct VkCheckpointDataNV
type VkQueueFamilyCheckpointProperties2NV (line 15144) | typedef struct VkQueueFamilyCheckpointProperties2NV
type VkCheckpointData2NV (line 15151) | typedef struct VkCheckpointData2NV
type VkSemaphoreType (line 15169) | typedef VkSemaphoreType VkSemaphoreTypeKHR;
type VkSemaphoreWaitFlagBits (line 15170) | typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;
type VkSemaphoreWaitFlags (line 15171) | typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;
type VkPhysicalDeviceTimelineSemaphoreFeatures (line 15172) | typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimeli...
type VkPhysicalDeviceTimelineSemaphoreProperties (line 15174) | typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTime...
type VkSemaphoreTypeCreateInfo (line 15176) | typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
type VkTimelineSemaphoreSubmitInfo (line 15178) | typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
type VkSemaphoreWaitInfo (line 15180) | typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
type VkSemaphoreSignalInfo (line 15182) | typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
type VkSemaphoreWaitInfo (line 15185) | typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, c...
type VkSemaphoreSignalInfo (line 15186) | typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, ...
type VkPresentStageFlagBitsEXT (line 15194) | typedef enum
type VkFlags (line 15202) | typedef VkFlags VkPresentStageFlagsEXT;
type VkTimeDomainKHR (line 15203) | typedef enum
type VkPastPresentationTimingFlagBitsEXT (line 15219) | typedef enum
type VkFlags (line 15225) | typedef VkFlags VkPastPresentationTimingFlagsEXT;
type VkPresentTimingInfoFlagBitsEXT (line 15227) | typedef enum
type VkFlags (line 15233) | typedef VkFlags VkPresentTimingInfoFlagsEXT;
type VkPhysicalDevicePresentTimingFeaturesEXT (line 15235) | typedef struct VkPhysicalDevicePresentTimingFeaturesEXT
type VkPresentTimingSurfaceCapabilitiesEXT (line 15244) | typedef struct VkPresentTimingSurfaceCapabilitiesEXT
type VkSwapchainCalibratedTimestampInfoEXT (line 15254) | typedef struct VkSwapchainCalibratedTimestampInfoEXT
type VkSwapchainTimingPropertiesEXT (line 15263) | typedef struct VkSwapchainTimingPropertiesEXT
type VkSwapchainTimeDomainPropertiesEXT (line 15271) | typedef struct VkSwapchainTimeDomainPropertiesEXT
type VkPastPresentationTimingInfoEXT (line 15280) | typedef struct VkPastPresentationTimingInfoEXT
type VkPresentStageTimeEXT (line 15288) | typedef struct VkPresentStageTimeEXT
type VkPastPresentationTimingEXT (line 15294) | typedef struct VkPastPresentationTimingEXT
type VkPastPresentationTimingPropertiesEXT (line 15307) | typedef struct VkPastPresentationTimingPropertiesEXT
type VkPresentTimingInfoEXT (line 15317) | typedef struct VkPresentTimingInfoEXT
type VkPresentTimingsInfoEXT (line 15328) | typedef struct VkPresentTimingsInfoEXT
type VkPastPresentationTimingInfoEXT (line 15340) | typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingEXT)(VkDevic...
type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL (line 15347) | typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
type VkQueryPoolSamplingModeINTEL (line 15367) | typedef enum
type VkPerformanceOverrideTypeINTEL (line 15373) | typedef enum
type VkPerformanceParameterTypeINTEL (line 15380) | typedef enum
type VkPerformanceValueTypeINTEL (line 15387) | typedef enum
type VkPerformanceValueDataINTEL (line 15398) | typedef union VkPerformanceValueDataINTEL
type VkPerformanceValueINTEL (line 15407) | typedef struct VkPerformanceValueINTEL
type VkInitializePerformanceApiInfoINTEL (line 15413) | typedef struct VkInitializePerformanceApiInfoINTEL
type VkQueryPoolPerformanceQueryCreateInfoINTEL (line 15420) | typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL
type VkQueryPoolPerformanceQueryCreateInfoINTEL (line 15427) | typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfo...
type VkPerformanceMarkerInfoINTEL (line 15429) | typedef struct VkPerformanceMarkerInfoINTEL
type VkPerformanceStreamMarkerInfoINTEL (line 15436) | typedef struct VkPerformanceStreamMarkerInfoINTEL
type VkPerformanceOverrideInfoINTEL (line 15443) | typedef struct VkPerformanceOverrideInfoINTEL
type VkPerformanceConfigurationAcquireInfoINTEL (line 15452) | typedef struct VkPerformanceConfigurationAcquireInfoINTEL
type VkInitializePerformanceApiInfoINTEL (line 15460) | typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevi...
type VkPerformanceMarkerInfoINTEL (line 15462) | typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkComma...
type VkPerformanceStreamMarkerInfoINTEL (line 15463) | typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(V...
type VkPerformanceOverrideInfoINTEL (line 15464) | typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCom...
type VkPerformanceConfigurationAcquireInfoINTEL (line 15465) | typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)...
type VkPhysicalDeviceVulkanMemoryModelFeatures (line 15475) | typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkan...
type VkPhysicalDevicePCIBusInfoPropertiesEXT (line 15482) | typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT
type VkDisplayNativeHdrSurfaceCapabilitiesAMD (line 15497) | typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD
type VkSwapchainDisplayNativeHdrCreateInfoAMD (line 15504) | typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD
type VkPhysicalDeviceShaderTerminateInvocationFeatures (line 15519) | typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDevi...
type VkPhysicalDeviceFragmentDensityMapFeaturesEXT (line 15526) | typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT
type VkPhysicalDeviceFragmentDensityMapPropertiesEXT (line 15535) | typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT
type VkRenderPassFragmentDensityMapCreateInfoEXT (line 15544) | typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT
type VkRenderingFragmentDensityMapAttachmentInfoEXT (line 15551) | typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT
type VkPhysicalDeviceScalarBlockLayoutFeatures (line 15564) | typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalar...
type VkPhysicalDeviceSubgroupSizeControlFeatures (line 15581) | typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubg...
type VkPhysicalDeviceSubgroupSizeControlProperties (line 15583) | typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSu...
type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo (line 15585) | typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineSh...
type VkFragmentShadingRateCombinerOpKHR (line 15592) | typedef enum
type VkFragmentShadingRateAttachmentInfoKHR (line 15603) | typedef struct VkFragmentShadingRateAttachmentInfoKHR
type VkPipelineFragmentShadingRateStateCreateInfoKHR (line 15611) | typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR
type VkPhysicalDeviceFragmentShadingRateFeaturesKHR (line 15619) | typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR
type VkPhysicalDeviceFragmentShadingRatePropertiesKHR (line 15628) | typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR
type VkPhysicalDeviceFragmentShadingRateKHR (line 15651) | typedef struct VkPhysicalDeviceFragmentShadingRateKHR
type VkRenderingFragmentShadingRateAttachmentInfoKHR (line 15659) | typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR
type VkShaderCorePropertiesFlagBitsAMD (line 15678) | typedef enum
type VkFlags (line 15682) | typedef VkFlags VkShaderCorePropertiesFlagsAMD;
type VkPhysicalDeviceShaderCoreProperties2AMD (line 15684) | typedef struct VkPhysicalDeviceShaderCoreProperties2AMD
type VkPhysicalDeviceCoherentMemoryFeaturesAMD (line 15697) | typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD
type VkPhysicalDeviceDynamicRenderingLocalReadFeatures (line 15709) | typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures VkPhysicalDevi...
type VkRenderingAttachmentLocationInfo (line 15711) | typedef VkRenderingAttachmentLocationInfo VkRenderingAttachmentLocationI...
type VkRenderingInputAttachmentIndexInfo (line 15713) | typedef VkRenderingInputAttachmentIndexInfo VkRenderingInputAttachmentIn...
type VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT (line 15723) | typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
type VkPhysicalDeviceShaderQuadControlFeaturesKHR (line 15736) | typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR
type VkPhysicalDeviceMemoryBudgetPropertiesEXT (line 15753) | typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT
type VkPhysicalDeviceMemoryPriorityFeaturesEXT (line 15766) | typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT
type VkMemoryPriorityAllocateInfoEXT (line 15773) | typedef struct VkMemoryPriorityAllocateInfoEXT
type VkSurfaceProtectedCapabilitiesKHR (line 15785) | typedef struct VkSurfaceProtectedCapabilitiesKHR
type VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV (line 15797) | typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures (line 15809) | typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDe...
type VkAttachmentReferenceStencilLayout (line 15811) | typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilL...
type VkAttachmentDescriptionStencilLayout (line 15813) | typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionSten...
type VkToolPurposeFlagBits (line 15820) | typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT;
type VkToolPurposeFlags (line 15821) | typedef VkToolPurposeFlags VkToolPurposeFlagsEXT;
type VkPhysicalDeviceToolProperties (line 15822) | typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT;
type VkImageStencilUsageCreateInfo (line 15831) | typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
type VkValidationFeatureEnableEXT (line 15838) | typedef enum
type VkValidationFeatureDisableEXT (line 15848) | typedef enum
type VkValidationFeaturesEXT (line 15862) | typedef struct VkValidationFeaturesEXT
type VkPhysicalDevicePresentWaitFeaturesKHR (line 15877) | typedef struct VkPhysicalDevicePresentWaitFeaturesKHR
type VkComponentTypeKHR (line 15892) | typedef enum
type VkComponentTypeKHR (line 15926) | typedef VkComponentTypeKHR VkComponentTypeNV;
type VkScopeKHR (line 15927) | typedef enum
type VkScopeKHR (line 15940) | typedef VkScopeKHR VkScopeNV;
type VkCooperativeMatrixPropertiesNV (line 15942) | typedef struct VkCooperativeMatrixPropertiesNV
type VkPhysicalDeviceCooperativeMatrixFeaturesNV (line 15956) | typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV
type VkPhysicalDeviceCooperativeMatrixPropertiesNV (line 15964) | typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV
type VkFlags (line 15979) | typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
type VkCoverageReductionModeNV (line 15980) | typedef enum
type VkPhysicalDeviceCoverageReductionModeFeaturesNV (line 15988) | typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV
type VkPipelineCoverageReductionStateCreateInfoNV (line 15995) | typedef struct VkPipelineCoverageReductionStateCreateInfoNV
type VkFramebufferMixedSamplesCombinationNV (line 16003) | typedef struct VkFramebufferMixedSamplesCombinationNV
type VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT (line 16021) | typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
type VkPhysicalDeviceYcbcrImageArraysFeaturesEXT (line 16035) | typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
type VkPhysicalDeviceUniformBufferStandardLayoutFeatures (line 16047) | typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDe...
type VkProvokingVertexModeEXT (line 16054) | typedef enum
type VkPhysicalDeviceProvokingVertexFeaturesEXT (line 16062) | typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT
type VkPhysicalDeviceProvokingVertexPropertiesEXT (line 16070) | typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT
type VkPipelineRasterizationProvokingVertexStateCreateInfoEXT (line 16078) | typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT
type VkFlags (line 16090) | typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
type VkHeadlessSurfaceCreateInfoEXT (line 16091) | typedef struct VkHeadlessSurfaceCreateInfoEXT
type VkHeadlessSurfaceCreateInfoEXT (line 16099) | typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance ...
type VkPhysicalDeviceBufferDeviceAddressFeatures (line 16106) | typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBuff...
type VkBufferDeviceAddressInfo (line 16108) | typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;
type VkBufferOpaqueCaptureAddressCreateInfo (line 16110) | typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddr...
type VkMemoryOpaqueCaptureAddressAllocateInfo (line 16112) | typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAd...
type VkDeviceMemoryOpaqueCaptureAddressInfo (line 16114) | typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptu...
type VkBufferDeviceAddressInfo (line 16116) | typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkD...
type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT (line 16125) | typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT
type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT (line 16134) | typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceB...
type VkBufferDeviceAddressInfo (line 16136) | typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;
type VkBufferDeviceAddressCreateInfoEXT (line 16138) | typedef struct VkBufferDeviceAddressCreateInfoEXT
type VkBufferDeviceAddressInfo (line 16146) | typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkD...
type VkPhysicalDeviceShaderAtomicFloatFeaturesEXT (line 16153) | typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT
type VkPhysicalDeviceHostQueryResetFeatures (line 16176) | typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQuery...
type VkPhysicalDeviceExtendedDynamicStateFeaturesEXT (line 16185) | typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
type VkAllocationCallbacks (line 16211) | typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice ...
type VkPipelineExecutableStatisticFormatKHR (line 16222) | typedef enum
type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR (line 16232) | typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
type VkPipelineInfoKHR (line 16239) | typedef struct VkPipelineInfoKHR
type VkPipelineExecutablePropertiesKHR (line 16246) | typedef struct VkPipelineExecutablePropertiesKHR
type VkPipelineExecutableInfoKHR (line 16256) | typedef struct VkPipelineExecutableInfoKHR
type VkPipelineExecutableStatisticValueKHR (line 16264) | typedef union VkPipelineExecutableStatisticValueKHR
type VkPipelineExecutableStatisticKHR (line 16272) | typedef struct VkPipelineExecutableStatisticKHR
type VkPipelineExecutableInternalRepresentationKHR (line 16282) | typedef struct VkPipelineExecutableInternalRepresentationKHR
type VkPipelineInfoKHR (line 16294) | typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(V...
type VkPipelineExecutableInfoKHR (line 16295) | typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(V...
type VkPipelineExecutableInfoKHR (line 16296) | typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresen...
type VkHostImageCopyFlagBits (line 16303) | typedef VkHostImageCopyFlagBits VkHostImageCopyFlagBitsEXT;
type VkHostImageCopyFlags (line 16304) | typedef VkHostImageCopyFlags VkHostImageCopyFlagsEXT;
type VkPhysicalDeviceHostImageCopyFeatures (line 16305) | typedef VkPhysicalDeviceHostImageCopyFeatures VkPhysicalDeviceHostImageC...
type VkPhysicalDeviceHostImageCopyProperties (line 16307) | typedef VkPhysicalDeviceHostImageCopyProperties VkPhysicalDeviceHostImag...
type VkMemoryToImageCopy (line 16309) | typedef VkMemoryToImageCopy VkMemoryToImageCopyEXT;
type VkImageToMemoryCopy (line 16311) | typedef VkImageToMemoryCopy VkImageToMemoryCopyEXT;
type VkCopyMemoryToImageInfo (line 16313) | typedef VkCopyMemoryToImageInfo VkCopyMemoryToImageInfoEXT;
type VkCopyImageToMemoryInfo (line 16315) | typedef VkCopyImageToMemoryInfo VkCopyImageToMemoryInfoEXT;
type VkCopyImageToImageInfo (line 16317) | typedef VkCopyImageToImageInfo VkCopyImageToImageInfoEXT;
type VkHostImageLayoutTransitionInfo (line 16319) | typedef VkHostImageLayoutTransitionInfo VkHostImageLayoutTransitionInfoEXT;
type VkSubresourceHostMemcpySize (line 16321) | typedef VkSubresourceHostMemcpySize VkSubresourceHostMemcpySizeEXT;
type VkHostImageCopyDevicePerformanceQuery (line 16323) | typedef VkHostImageCopyDevicePerformanceQuery VkHostImageCopyDevicePerfo...
type VkSubresourceLayout2 (line 16325) | typedef VkSubresourceLayout2 VkSubresourceLayout2EXT;
type VkImageSubresource2 (line 16327) | typedef VkImageSubresource2 VkImageSubresource2EXT;
type VkCopyMemoryToImageInfo (line 16329) | typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImageEXT)(VkDevice device...
type VkCopyImageToMemoryInfo (line 16330) | typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemoryEXT)(VkDevice device...
type VkCopyImageToImageInfo (line 16331) | typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImageEXT)(VkDevice device,...
type const (line 16332) | typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice de...
type VkMemoryUnmapFlagBits (line 16340) | typedef VkMemoryUnmapFlagBits VkMemoryUnmapFlagBitsKHR;
type VkMemoryUnmapFlags (line 16341) | typedef VkMemoryUnmapFlags VkMemoryUnmapFlagsKHR;
type VkMemoryMapInfo (line 16342) | typedef VkMemoryMapInfo VkMemoryMapInfoKHR;
type VkMemoryUnmapInfo (line 16344) | typedef VkMemoryUnmapInfo VkMemoryUnmapInfoKHR;
type VkMemoryMapInfo (line 16346) | typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const...
type VkMemoryUnmapInfo (line 16347) | typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, con...
type VkPhysicalDeviceMapMemoryPlacedFeaturesEXT (line 16354) | typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT
type VkPhysicalDeviceMapMemoryPlacedPropertiesEXT (line 16363) | typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT
type VkMemoryMapPlacedInfoEXT (line 16370) | typedef struct VkMemoryMapPlacedInfoEXT
type VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT (line 16382) | typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT
type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures (line 16405) | typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysica...
type VkFlags (line 16420) | typedef VkFlags VkIndirectStateFlagsNV;
type VkIndirectCommandsTokenTypeNV (line 16421) | typedef enum
type VkIndirectCommandsLayoutUsageFlagBitsNV (line 16439) | typedef enum
type VkFlags (line 16446) | typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;
type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV (line 16448) | typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV
type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV (line 16463) | typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
type VkGraphicsShaderGroupCreateInfoNV (line 16470) | typedef struct VkGraphicsShaderGroupCreateInfoNV
type VkGraphicsPipelineShaderGroupsCreateInfoNV (line 16480) | typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV
type VkBindShaderGroupIndirectCommandNV (line 16490) | typedef struct VkBindShaderGroupIndirectCommandNV
type VkBindIndexBufferIndirectCommandNV (line 16495) | typedef struct VkBindIndexBufferIndirectCommandNV
type VkBindVertexBufferIndirectCommandNV (line 16502) | typedef struct VkBindVertexBufferIndirectCommandNV
type VkSetStateFlagsIndirectCommandNV (line 16509) | typedef struct VkSetStateFlagsIndirectCommandNV
type VkIndirectCommandsStreamNV (line 16514) | typedef struct VkIndirectCommandsStreamNV
type VkIndirectCommandsLayoutTokenNV (line 16520) | typedef struct VkIndirectCommandsLayoutTokenNV
type VkIndirectCommandsLayoutCreateInfoNV (line 16539) | typedef struct VkIndirectCommandsLayoutCreateInfoNV
type VkGeneratedCommandsInfoNV (line 16551) | typedef struct VkGeneratedCommandsInfoNV
type VkGeneratedCommandsMemoryRequirementsInfoNV (line 16570) | typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV
type VkIndirectCommandsLayoutCreateInfoNV (line 16585) | typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDev...
type VkPhysicalDeviceInheritedViewportScissorFeaturesNV (line 16593) | typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV
type VkCommandBufferInheritanceViewportScissorInfoNV (line 16600) | typedef struct VkCommandBufferInheritanceViewportScissorInfoNV
type VkPhysicalDeviceShaderIntegerDotProductFeatures (line 16614) | typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDevice...
type VkPhysicalDeviceShaderIntegerDotProductProperties (line 16616) | typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDevi...
type VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT (line 16623) | typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT
type VkPhysicalDeviceTexelBufferAlignmentProperties (line 16630) | typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceT...
type VkRenderPassTransformBeginInfoQCOM (line 16637) | typedef struct VkRenderPassTransformBeginInfoQCOM
type VkCommandBufferInheritanceRenderPassTransformInfoQCOM (line 16644) | typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM
type VkDepthBiasRepresentationEXT (line 16657) | typedef enum
type VkPhysicalDeviceDepthBiasControlFeaturesEXT (line 16666) | typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT
type VkDepthBiasInfoEXT (line 16676) | typedef struct VkDepthBiasInfoEXT
type VkDepthBiasRepresentationInfoEXT (line 16685) | typedef struct VkDepthBiasRepresentationInfoEXT
type VkFlags (line 16701) | typedef VkFlags VkDeviceMemoryReportFlagsEXT;
type VkDeviceMemoryReportEventTypeEXT (line 16702) | typedef enum
type VkPhysicalDeviceDeviceMemoryReportFeaturesEXT (line 16713) | typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT
type VkDeviceMemoryReportCallbackDataEXT (line 16720) | typedef struct VkDeviceMemoryReportCallbackDataEXT
type VkDeviceDeviceMemoryReportCreateInfoEXT (line 16735) | typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT
type VkPhysicalDeviceCustomBorderColorPropertiesEXT (line 16757) | typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT
type VkPhysicalDeviceCustomBorderColorFeaturesEXT (line 16764) | typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT
type VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT (line 16777) | typedef struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT
type VkPhysicalDevicePresentBarrierFeaturesNV (line 16799) | typedef struct VkPhysicalDevicePresentBarrierFeaturesNV
type VkSurfaceCapabilitiesPresentBarrierNV (line 16806) | typedef struct VkSurfaceCapabilitiesPresentBarrierNV
type VkSwapchainPresentBarrierCreateInfoNV (line 16813) | typedef struct VkSwapchainPresentBarrierCreateInfoNV
type VkPresentIdKHR (line 16830) | typedef struct VkPresentIdKHR
type VkPhysicalDevicePresentIdFeaturesKHR (line 16838) | typedef struct VkPhysicalDevicePresentIdFeaturesKHR
type VkPrivateDataSlot (line 16850) | typedef VkPrivateDataSlot VkPrivateDataSlotEXT;
type VkPrivateDataSlotCreateFlags (line 16851) | typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT;
type VkPhysicalDevicePrivateDataFeatures (line 16852) | typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataF...
type VkDevicePrivateDataCreateInfo (line 16854) | typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT;
type VkPrivateDataSlotCreateInfo (line 16856) | typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT;
type VkPrivateDataSlotCreateInfo (line 16858) | typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice de...
type VkPhysicalDevicePipelineCreationCacheControlFeatures (line 16868) | typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalD...
type VkVideoEncodeFlagBitsKHR (line 16876) | typedef enum
type VkFlags (line 16883) | typedef VkFlags VkVideoEncodeFlagsKHR;
type VkVideoEncodeCapabilityFlagBitsKHR (line 16885) | typedef enum
type VkFlags (line 16893) | typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
type VkVideoEncodeRateControlModeFlagBitsKHR (line 16895) | typedef enum
type VkFlags (line 16903) | typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
type VkVideoEncodeFeedbackFlagBitsKHR (line 16905) | typedef enum
type VkFlags (line 16912) | typedef VkFlags VkVideoEncodeFeedbackFlagsKHR;
type VkVideoEncodeUsageFlagBitsKHR (line 16914) | typedef enum
type VkFlags (line 16923) | typedef VkFlags VkVideoEncodeUsageFlagsKHR;
type VkVideoEncodeContentFlagBitsKHR (line 16925) | typedef enum
type VkFlags (line 16933) | typedef VkFlags VkVideoEncodeContentFlagsKHR;
type VkVideoEncodeTuningModeKHR (line 16934) | typedef enum
type VkFlags (line 16944) | typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
type VkVideoEncodeInfoKHR (line 16946) | typedef struct VkVideoEncodeInfoKHR
type VkVideoEncodeCapabilitiesKHR (line 16961) | typedef struct VkVideoEncodeCapabilitiesKHR
type VkQueryPoolVideoEncodeFeedbackCreateInfoKHR (line 16974) | typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR
type VkVideoEncodeUsageInfoKHR (line 16981) | typedef struct VkVideoEncodeUsageInfoKHR
type VkVideoEncodeRateControlLayerInfoKHR (line 16990) | typedef struct VkVideoEncodeRateControlLayerInfoKHR
type VkVideoEncodeRateControlInfoKHR (line 17000) | typedef struct VkVideoEncodeRateControlInfoKHR
type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR (line 17012) | typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR
type VkVideoEncodeQualityLevelPropertiesKHR (line 17020) | typedef struct VkVideoEncodeQualityLevelPropertiesKHR
type VkVideoEncodeQualityLevelInfoKHR (line 17028) | typedef struct VkVideoEncodeQualityLevelInfoKHR
type VkVideoEncodeSessionParametersGetInfoKHR (line 17035) | typedef struct VkVideoEncodeSessionParametersGetInfoKHR
type VkVideoEncodeSessionParametersFeedbackInfoKHR (line 17042) | typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR
type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR (line 17050) | typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLe...
type VkVideoEncodeSessionParametersGetInfoKHR (line 17051) | typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(...
type VkDeviceDiagnosticsConfigFlagBitsNV (line 17060) | typedef enum
type VkFlags (line 17068) | typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;
type VkPhysicalDeviceDiagnosticsConfigFeaturesNV (line 17070) | typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV
type VkDeviceDiagnosticsConfigCreateInfoNV (line 17077) | typedef struct VkDeviceDiagnosticsConfigCreateInfoNV
type VkRefreshObjectFlagBitsKHR (line 17095) | typedef enum
type VkFlags (line 17099) | typedef VkFlags VkRefreshObjectFlagsKHR;
type VkRefreshObjectKHR (line 17101) | typedef struct VkRefreshObjectKHR
type VkRefreshObjectListKHR (line 17108) | typedef struct VkRefreshObjectListKHR
type VkTileShadingRenderPassFlagBitsQCOM (line 17126) | typedef enum
type VkFlags (line 17132) | typedef VkFlags VkTileShadingRenderPassFlagsQCOM;
type VkPhysicalDeviceTileShadingFeaturesQCOM (line 17134) | typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM
type VkPhysicalDeviceTileShadingPropertiesQCOM (line 17154) | typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM
type VkRenderPassTileShadingCreateInfoQCOM (line 17164) | typedef struct VkRenderPassTileShadingCreateInfoQCOM
type VkPerTileBeginInfoQCOM (line 17172) | typedef struct VkPerTileBeginInfoQCOM
type VkPerTileEndInfoQCOM (line 17178) | typedef struct VkPerTileEndInfoQCOM
type VkDispatchTileInfoQCOM (line 17184) | typedef struct VkDispatchTileInfoQCOM
type VkQueryLowLatencySupportNV (line 17200) | typedef struct VkQueryLowLatencySupportNV
type VkPipelineStageFlags2 (line 17212) | typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR;
type VkPipelineStageFlagBits2 (line 17213) | typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR;
type VkAccessFlags2 (line 17214) | typedef VkAccessFlags2 VkAccessFlags2KHR;
type VkAccessFlagBits2 (line 17215) | typedef VkAccessFlagBits2 VkAccessFlagBits2KHR;
type VkSubmitFlagBits (line 17216) | typedef VkSubmitFlagBits VkSubmitFlagBitsKHR;
type VkSubmitFlags (line 17217) | typedef VkSubmitFlags VkSubmitFlagsKHR;
type VkMemoryBarrier2 (line 17218) | typedef VkMemoryBarrier2 VkMemoryBarrier2KHR;
type VkBufferMemoryBarrier2 (line 17220) | typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR;
type VkImageMemoryBarrier2 (line 17222) | typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR;
type VkDependencyInfo (line 17224) | typedef VkDependencyInfo VkDependencyInfoKHR;
type VkSubmitInfo2 (line 17226) | typedef VkSubmitInfo2 VkSubmitInfo2KHR;
type VkSemaphoreSubmitInfo (line 17228) | typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR;
type VkCommandBufferSubmitInfo (line 17230) | typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR;
type VkPhysicalDeviceSynchronization2Features (line 17232) | typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchro...
type const (line 17239) | typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint3...
type VkPhysicalDeviceDescriptorBufferPropertiesEXT (line 17246) | typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT
type VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT (line 17285) | typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
type VkPhysicalDeviceDescriptorBufferFeaturesEXT (line 17292) | typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT
type VkDescriptorAddressInfoEXT (line 17302) | typedef struct VkDescriptorAddressInfoEXT
type VkDescriptorBufferBindingInfoEXT (line 17311) | typedef struct VkDescriptorBufferBindingInfoEXT
type VkDescriptorBufferBindingPushDescriptorBufferHandleEXT (line 17319) | typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT
type VkDescriptorDataEXT (line 17326) | typedef union VkDescriptorDataEXT
type VkDescriptorGetInfoEXT (line 17340) | typedef struct VkDescriptorGetInfoEXT
type VkBufferCaptureDescriptorDataInfoEXT (line 17348) | typedef struct VkBufferCaptureDescriptorDataInfoEXT
type VkImageCaptureDescriptorDataInfoEXT (line 17355) | typedef struct VkImageCaptureDescriptorDataInfoEXT
type VkImageViewCaptureDescriptorDataInfoEXT (line 17362) | typedef struct VkImageViewCaptureDescriptorDataInfoEXT
type VkSamplerCaptureDescriptorDataInfoEXT (line 17369) | typedef struct VkSamplerCaptureDescriptorDataInfoEXT
type VkOpaqueCaptureDescriptorDataCreateInfoEXT (line 17376) | typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT
type VkAccelerationStructureCaptureDescriptorDataInfoEXT (line 17383) | typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT
type VkBufferCaptureDescriptorDataInfoEXT (line 17398) | typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataE...
type VkImageCaptureDescriptorDataInfoEXT (line 17399) | typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEX...
type VkImageViewCaptureDescriptorDataInfoEXT (line 17400) | typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDa...
type VkSamplerCaptureDescriptorDataInfoEXT (line 17401) | typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorData...
type VkAccelerationStructureCaptureDescriptorDataInfoEXT (line 17402) | typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCapture...
type VkGraphicsPipelineLibraryFlagBitsEXT (line 17410) | typedef enum
type VkFlags (line 17418) | typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT;
type VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT (line 17420) | typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
type VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT (line 17427) | typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
type VkGraphicsPipelineLibraryCreateInfoEXT (line 17435) | typedef struct VkGraphicsPipelineLibraryCreateInfoEXT
type VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD (line 17447) | typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR (line 17459) | typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR
type VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR (line 17466) | typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR
type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR (line 17478) | typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalD...
type VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR (line 17485) | typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures (line 17497) | typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysical...
type VkFragmentShadingRateTypeNV (line 17504) | typedef enum
type VkFragmentShadingRateNV (line 17511) | typedef enum
type VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV (line 17529) | typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV
type VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV (line 17538) | typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV
type VkPipelineFragmentShadingRateEnumStateCreateInfoNV (line 17545) | typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV
type VkFlags (line 17562) | typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV;
type VkAccelerationStructureMotionInstanceTypeNV (line 17563) | typedef enum
type VkFlags (line 17571) | typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV;
type VkAccelerationStructureGeometryMotionTrianglesDataNV (line 17573) | typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV
type VkAccelerationStructureMotionInfoNV (line 17580) | typedef struct VkAccelerationStructureMotionInfoNV
type VkAccelerationStructureMatrixMotionInstanceNV (line 17588) | typedef struct VkAccelerationStructureMatrixMotionInstanceNV
type VkSRTDataNV (line 17599) | typedef struct VkSRTDataNV
type VkAccelerationStructureSRTMotionInstanceNV (line 17619) | typedef struct VkAccelerationStructureSRTMotionInstanceNV
type VkAccelerationStructureMotionInstanceDataNV (line 17630) | typedef union VkAccelerationStructureMotionInstanceDataNV
type VkAccelerationStructureMotionInstanceNV (line 17637) | typedef struct VkAccelerationStructureMotionInstanceNV
type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV (line 17644) | typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV
type VkPhysicalDeviceMeshShaderFeaturesEXT (line 17657) | typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT
type VkPhysicalDeviceMeshShaderPropertiesEXT (line 17668) | typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT
type VkDrawMeshTasksIndirectCommandEXT (line 17702) | typedef struct VkDrawMeshTasksIndirectCommandEXT
type VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT (line 17719) | typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
type VkPhysicalDeviceFragmentDensityMap2FeaturesEXT (line 17731) | typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT
type VkPhysicalDeviceFragmentDensityMap2PropertiesEXT (line 17738) | typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT
type VkCopyCommandTransformInfoQCOM (line 17753) | typedef struct VkCopyCommandTransformInfoQCOM
type VkPhysicalDeviceImageRobustnessFeatures (line 17765) | typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRob...
type VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR (line 17772) | typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
type VkCopyBufferInfo2 (line 17787) | typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR;
type VkCopyImageInfo2 (line 17789) | typedef VkCopyImageInfo2 VkCopyImageInfo2KHR;
type VkCopyBufferToImageInfo2 (line 17791) | typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR;
type VkCopyImageToBufferInfo2 (line 17793) | typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR;
type VkBlitImageInfo2 (line 17795) | typedef VkBlitImageInfo2 VkBlitImageInfo2KHR;
type VkResolveImageInfo2 (line 17797) | typedef VkResolveImageInfo2 VkResolveImageInfo2KHR;
type VkBufferCopy2 (line 17799) | typedef VkBufferCopy2 VkBufferCopy2KHR;
type VkImageCopy2 (line 17801) | typedef VkImageCopy2 VkImageCopy2KHR;
type VkImageBlit2 (line 17803) | typedef VkImageBlit2 VkImageBlit2KHR;
type VkBufferImageCopy2 (line 17805) | typedef VkBufferImageCopy2 VkBufferImageCopy2KHR;
type VkImageResolve2 (line 17807) | typedef VkImageResolve2 VkImageResolve2KHR;
type VkImageCompressionFlagBitsEXT (line 17822) | typedef enum
type VkFlags (line 17830) | typedef VkFlags VkImageCompressionFlagsEXT;
type VkImageCompressionFixedRateFlagBitsEXT (line 17832) | typedef enum
type VkFlags (line 17861) | typedef VkFlags VkImageCompressionFixedRateFlagsEXT;
type VkPhysicalDeviceImageCompressionControlFeaturesEXT (line 17863) | typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT
type VkImageCompressionControlEXT (line 17870) | typedef struct VkImageCompressionControlEXT
type VkImageCompressionPropertiesEXT (line 17879) | typedef struct VkImageCompressionPropertiesEXT
type VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT (line 17892) | typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
type VkPhysicalDevice4444FormatsFeaturesEXT (line 17904) | typedef struct VkPhysicalDevice4444FormatsFeaturesEXT
type VkDeviceFaultAddressTypeEXT (line 17917) | typedef enum
type VkDeviceFaultVendorBinaryHeaderVersionEXT (line 17929) | typedef enum
type VkPhysicalDeviceFaultFeaturesEXT (line 17936) | typedef struct VkPhysicalDeviceFaultFeaturesEXT
type VkDeviceFaultCountsEXT (line 17944) | typedef struct VkDeviceFaultCountsEXT
type VkDeviceFaultAddressInfoEXT (line 17953) | typedef struct VkDeviceFaultAddressInfoEXT
type VkDeviceFaultVendorInfoEXT (line 17960) | typedef struct VkDeviceFaultVendorInfoEXT
type VkDeviceFaultInfoEXT (line 17967) | typedef struct VkDeviceFaultInfoEXT
type VkDeviceFaultVendorBinaryHeaderVersionOneEXT (line 17977) | typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT
type VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT (line 18000) | typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT
type VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT (line 18012) | typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT
type VkVertexInputBindingDescription2EXT (line 18019) | typedef struct VkVertexInputBindingDescription2EXT
type VkVertexInputAttributeDescription2EXT (line 18029) | typedef struct VkVertexInputAttributeDescription2EXT
type VkPhysicalDeviceDrmPropertiesEXT (line 18047) | typedef struct VkPhysicalDeviceDrmPropertiesEXT
type VkDeviceAddressBindingFlagBitsEXT (line 18065) | typedef enum
type VkFlags (line 18070) | typedef VkFlags VkDeviceAddressBindingFlagsEXT;
type VkDeviceAddressBindingTypeEXT (line 18071) | typedef enum
type VkPhysicalDeviceAddressBindingReportFeaturesEXT (line 18079) | typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT
type VkDeviceAddressBindingCallbackDataEXT (line 18086) | typedef struct VkDeviceAddressBindingCallbackDataEXT
type VkPhysicalDeviceDepthClipControlFeaturesEXT (line 18101) | typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT
type VkPipelineViewportDepthClipControlCreateInfoEXT (line 18108) | typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT
type VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT (line 18120) | typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
type VkFormatFeatureFlags2 (line 18133) | typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR;
type VkFormatFeatureFlagBits2 (line 18134) | typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;
type VkFormatProperties3 (line 18135) | typedef VkFormatProperties3 VkFormatProperties3KHR;
type VkSubpassShadingPipelineCreateInfoHUAWEI (line 18142) | typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI
type VkPhysicalDeviceSubpassShadingFeaturesHUAWEI (line 18150) | typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI
type VkPhysicalDeviceSubpassShadingPropertiesHUAWEI (line 18157) | typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI
type VkPhysicalDeviceInvocationMaskFeaturesHUAWEI (line 18173) | typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI
type VkMemoryGetRemoteAddressInfoNV (line 18190) | typedef struct VkMemoryGetRemoteAddressInfoNV
type VkPhysicalDeviceExternalMemoryRDMAFeaturesNV (line 18198) | typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV
type VkMemoryGetRemoteAddressInfoNV (line 18206) | typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice de...
type VkPipelineInfoKHR (line 18213) | typedef VkPipelineInfoKHR VkPipelineInfoEXT;
type VkPipelinePropertiesIdentifierEXT (line 18215) | typedef struct VkPipelinePropertiesIdentifierEXT
type VkPhysicalDevicePipelinePropertiesFeatur
Condensed preview — 14 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,605K chars).
[
{
"path": ".gitignore",
"chars": 85,
"preview": ".vscode\n/#docs\n/build\n/examples/_build\n/resources/vk.xml\n/resources/video.xml\n*.spirv"
},
{
"path": "CMakeLists.txt",
"chars": 4102,
"preview": "cmake_minimum_required(VERSION 3.10)\n\n# Extract version.\nfile(STRINGS \"${CMAKE_CURRENT_SOURCE_DIR}/vkbind.h\" VKBIND_VERS"
},
{
"path": "README.md",
"chars": 4020,
"preview": "\n<h4 align=\"center\">A single file Vulkan header and API loader.</h4>\n\n<p align=\"center\">\n <a href=\"https://discord.gg"
},
{
"path": "examples/01_Fundamentals/01_Fundamentals.c",
"chars": 138224,
"preview": "/*\nDemonstrates the fundamentals of the Vulkan API, including:\n\n * Layers\n * Extensions\n * Physical and logical devic"
},
{
"path": "examples/01_Fundamentals/01_Fundamentals.cpp",
"chars": 28,
"preview": "#include \"01_Fundamentals.c\""
},
{
"path": "examples/01_Fundamentals/01_Fundamentals_VFS.c",
"chars": 22477,
"preview": "#include <string.h>\n#include <stdlib.h>\n\nstatic unsigned char g_vfsFileData[] = {\n 0x23, 0x76, 0x65, 0x72, 0x73, 0x69"
},
{
"path": "examples/01_Fundamentals/resources/shaders/01_Fundamentals.glsl.frag",
"chars": 576,
"preview": "#version 450\n\n// Descriptor sets. This example uses separate textures and samplers, but you can also use a combined\n// t"
},
{
"path": "examples/01_Fundamentals/resources/shaders/01_Fundamentals.glsl.vert",
"chars": 513,
"preview": "#version 450\n\n// Vertex Input\nlayout(location = 0) in vec3 VERT_Position;\nlayout(location = 1) in vec3 VERT_Color;\nlayou"
},
{
"path": "resources/README.md",
"chars": 78,
"preview": "Vulkan XML: https://github.com/KhronosGroup/Vulkan-Docs/blob/master/xml/vk.xml"
},
{
"path": "source/external/tinyxml2.cpp",
"chars": 70848,
"preview": "/*\nOriginal code by Lee Thomason (www.grinninglizard.com)\n\nThis software is provided 'as-is', without any express or imp"
},
{
"path": "source/external/tinyxml2.h",
"chars": 68359,
"preview": "/*\nOriginal code by Lee Thomason (www.grinninglizard.com)\n\nThis software is provided 'as-is', without any express or imp"
},
{
"path": "source/vkbind_build.cpp",
"chars": 158353,
"preview": "#include \"external/tinyxml2.cpp\"\n#include <string>\n#include <vector>\n#include <algorithm>\n#include <stdio.h>\n#include <a"
},
{
"path": "source/vkbind_template.h",
"chars": 18538,
"preview": "/*\nVulkan API loader. Choice of public domain or MIT-0. See license statements at the end of this file.\nvkbind - v<<vulk"
},
{
"path": "vkbind.h",
"chars": 2053750,
"preview": "/*\nVulkan API loader. Choice of public domain or MIT-0. See license statements at the end of this file.\nvkbind - v1.4.34"
}
]
About this extraction
This page contains the full source code of the mackron/vkbind GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 14 files (2.4 MB), approximately 635.7k tokens, and a symbol index with 4124 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.