xref: /third_party/vk-gl-cts/external/vulkan-docs/src/appendices/boilerplate.txt (revision e5c31af7)

// Copyright 2016-2021 The Khronos Group, Inc.
//
// SPDX-License-Identifier: CC-BY-4.0

[appendix]
[[boilerplate]]
= API Boilerplate

This appendix defines Vulkan API features that are infrastructure required
for a complete functional description of Vulkan, but do not logically belong
elsewhere in the Specification.


[[boilerplate-headers]]
== Vulkan Header Files

Vulkan is defined as an API in the C99 language.
Khronos provides a corresponding set of header files for applications using
the API, which may be used in either C or C++ code.
The interface descriptions in the specification are the same as the
interfaces defined in these header files, and both are derived from the
`vk.xml` XML API Registry, which is the canonical machine-readable
description of the Vulkan API.
The Registry, scripts used for processing it into various forms, and
documentation of the registry schema are available as described at
https://www.khronos.org/registry/vulkan/#apiregistry .

Language bindings for other languages can be defined using the information
in the Specification and the Registry.
Khronos does not provide any such bindings, but third-party developers have
created some additional bindings.


[[boilerplate-vulkan-h]]
=== Vulkan Combined API Header `{full_header}` (Informative)

Applications normally will include the header `{full_header}`.
In turn, `{full_header}` always includes the following headers:

  * <<boilerplate-platform-macros,`vk_platform.h`>>, defining
    platform-specific macros and headers.
  * <<boilerplate-vulkan-core,`{core_header}`>>, defining APIs for the
    Vulkan core and all registered extensions _other_ than
    <<boilerplate-wsi-header, window system-specific>> and
    <<boilerplate-provisional-header, provisional>> extensions, which are
    included in separate header files.

In addition, specific preprocessor macros defined at the time
`{full_header}` is included cause header files for the corresponding window
system-specific and provisional interfaces to be included, as described
below.


[[boilerplate-platform-macros]]
=== Vulkan Platform-Specific Header `vk_platform.h` (Informative)

Platform-specific macros and interfaces are defined in `vk_platform.h`.
These macros are used to control platform-dependent behavior, and their
exact definitions are under the control of specific platforms and Vulkan
implementations.


[[boilerplate-platform-specific-calling-conventions]]
==== Platform-Specific Calling Conventions

On many platforms the following macros are empty strings, causing platform-
and compiler-specific default calling conventions to be used.

[open,refpage='VKAPI_ATTR',desc='Vulkan function attribute macro',type='freeform',anchor='boilerplate-platform-specific-calling-conventions',xrefs='VKAPI_CALL VKAPI_PTR']
--
dname:VKAPI_ATTR is a macro placed before the return type in Vulkan API
function declarations.
This macro controls calling conventions for C++11 and GCC/Clang-style
compilers.
--

[open,refpage='VKAPI_CALL',desc='Vulkan function calling conventions macro',type='freeform',anchor='boilerplate-platform-specific-calling-conventions',xrefs='VKAPI_ATTR VKAPI_PTR']
--
dname:VKAPI_CALL is a macro placed after the return type in Vulkan API
function declarations.
This macro controls calling conventions for MSVC-style compilers.
--

[open,refpage='VKAPI_PTR',desc='Vulkan function pointer calling conventions macro',type='freeform',anchor='boilerplate-platform-specific-calling-conventions',xrefs='VKAPI_ATTR VKAPI_CALL']
--
dname:VKAPI_PTR is a macro placed between the '(' and '*' in Vulkan API
function pointer declarations.
This macro also controls calling conventions, and typically has the same
definition as dname:VKAPI_ATTR or dname:VKAPI_CALL, depending on the
compiler.
--

With these macros, a Vulkan function declaration takes the form of:

[source,c++]
----------------------------------------
VKAPI_ATTR <return_type> VKAPI_CALL <command_name>(<command_parameters>);
----------------------------------------

Additionally, a Vulkan function pointer type declaration takes the form of:

[source,c++]
----------------------------------------
typedef <return_type> (VKAPI_PTR *PFN_<command_name>)(<command_parameters>);
----------------------------------------


[[boilerplate-platform-specific-header-control]]
==== Platform-Specific Header Control

[open,refpage='VK_NO_STDINT_H',desc='Control definition of <stdint.h> types',type='freeform',anchor='boilerplate-platform-specific-header-control']
--
If the dname:VK_NO_STDINT_H macro is defined by the application at compile
time, extended integer types used by the Vulkan API, such as code:uint8_t,
must: also be defined by the application.
Otherwise, the Vulkan headers will not compile.
If dname:VK_NO_STDINT_H is not defined, the system `<stdint.h>` is used to
define these types.
There is a fallback path when Microsoft Visual Studio version 2008 and
earlier versions are detected at compile time.
--

[open,refpage='VK_NO_STDDEF_H',desc='Control definition of <stddef.h> types',type='freeform',anchor='boilerplate-platform-specific-header-control']
--
If the dname:VK_NO_STDDEF_H macro is defined by the application at compile
time, code:size_t, must: also be defined by the application.
Otherwise, the Vulkan headers will not compile.
If dname:VK_NO_STDDEF_H is not defined, the system `<stddef.h>` is used to
define this type.
--


[[boilerplate-vulkan-core]]
=== Vulkan Core API Header `{core_header}`

Applications that do not make use of window system-specific extensions may
simply include `{core_header}` instead of `{full_header}`, although there is
usually no reason to do so.
In addition to the Vulkan API, `{core_header}` also defines a small number
of C preprocessor macros that are described below.





==== Vulkan Header File Version Number

[open,refpage='VK_HEADER_VERSION',desc='Vulkan header file version number',type='defines']
--
dname:VK_HEADER_VERSION is the version number of the `{core_header}` header.
This value is kept synchronized with the patch version of the released
Specification.

include::{generated}/api/defines/VK_HEADER_VERSION.txt[]
--

[open,refpage='VK_HEADER_VERSION_COMPLETE',desc='Vulkan header file complete version number',type='defines']
--
dname:VK_HEADER_VERSION_COMPLETE is the complete version number of the
`{core_header}` header, comprising the major, minor, and patch versions.
The major/minor values are kept synchronized with the complete version of
the released Specification.
This value is intended for use by automated tools to identify exactly which
version of the header was used during their generation.

Applications should not use this value as their
slink:VkApplicationInfo::pname:apiVersion.
Instead applications should explicitly select a specific fixed major/minor
API version using, for example, one of the dname:VK_API_VERSION_*_* values.

include::{generated}/api/defines/VK_HEADER_VERSION_COMPLETE.txt[]
--

[open,refpage='VK_API_VERSION',desc='Deprecated version number macro',type='defines']
--
dname:VK_API_VERSION is now commented out of `{core_header}` and cannot: be
used.

include::{generated}/api/defines/VK_API_VERSION.txt[]
--


==== Vulkan Handle Macros

[open,refpage='VK_DEFINE_HANDLE',desc='Declare a dispatchable object handle',type='defines',xrefs='VkCommandBuffer VkDevice VkInstance VkPhysicalDevice VkQueue']
--
dname:VK_DEFINE_HANDLE defines a <<fundamentals-objectmodel-overview,
dispatchable handle>> type.

include::{generated}/api/defines/VK_DEFINE_HANDLE.txt[]

  * pname:object is the name of the resulting C type.

The only dispatchable handle types are those related to device and instance
management, such as slink:VkDevice.
--

[open,refpage='VK_DEFINE_NON_DISPATCHABLE_HANDLE',desc='Declare a non-dispatchable object handle',type='defines',xrefs='VkBuffer']
--
dname:VK_DEFINE_NON_DISPATCHABLE_HANDLE defines a
<<fundamentals-objectmodel-overview, non-dispatchable handle>> type.

include::{generated}/api/defines/VK_DEFINE_NON_DISPATCHABLE_HANDLE.txt[]

  * pname:object is the name of the resulting C type.

Most Vulkan handle types, such as slink:VkBuffer, are non-dispatchable.

[NOTE]
.Note
====
The `{core_header}` header allows the
dname:VK_DEFINE_NON_DISPATCHABLE_HANDLE and dname:VK_NULL_HANDLE definitions
to be overridden by the application.
If dname:VK_DEFINE_NON_DISPATCHABLE_HANDLE is already defined when
`{core_header}` is compiled, the default definitions for
dname:VK_DEFINE_NON_DISPATCHABLE_HANDLE and dname:VK_NULL_HANDLE are
skipped.
This allows the application to define a binary-compatible custom handle
which may: provide more type-safety or other features needed by the
application.
Applications must: not define handles in a way that is not binary compatible
- where binary compatibility is platform dependent.
====
--

[open,refpage='VK_NULL_HANDLE',desc='Reserved non-valid object handle',type='defines']
--
dname:VK_NULL_HANDLE is a reserved value representing a non-valid object
handle.
It may be passed to and returned from Vulkan commands only when
<<fundamentals-validusage-handles, specifically allowed>>.

include::{generated}/api/defines/VK_NULL_HANDLE.txt[]
--

[open,refpage='VK_USE_64_BIT_PTR_DEFINES',desc='Defines whether non-dispatchable handles are a 64-bit pointer type or a 64-bit unsigned integer type',type='defines']
--
dname:VK_USE_64_BIT_PTR_DEFINES defines whether the default non-dispatchable
handles are declared using either a 64-bit pointer type or a 64-bit unsigned
integer type.

dname:VK_USE_64_BIT_PTR_DEFINES is set to '1' to use a 64-bit pointer type
or any other value to use a 64-bit unsigned integer type.

include::{generated}/api/defines/VK_USE_64_BIT_PTR_DEFINES.txt[]

[NOTE]
.Note
====
The `{core_header}` header allows the dname:VK_USE_64_BIT_PTR_DEFINES
definition to be overridden by the application.
This allows the application to select either a 64-bit pointer type or a
64-bit unsigned integer type for non-dispatchable handles in the case where
the predefined preprocessor check does not identify the desired
configuration.
====

--

[[boilerplate-wsi-header]]
== Window System-Specific Header Control (Informative)

[open,refpage='WSIheaders',desc='Control inclusion of window system interface extensions',type='freeform',anchor='boilerplate-wsi-header',xrefs='provisional-headers']
--
To use a Vulkan extension supporting a platform-specific window system,
header files for that window systems must: be included at compile time, or
platform-specific types must: be forward-declared.
The Vulkan header files cannot determine whether or not an external header
is available at compile time, so platform-specific extensions are provided
in separate headers from the core API and platform-independent extensions,
allowing applications to decide which ones should be defined and how the
external headers are included.

Extensions dependent on particular sets of platform headers, or that
forward-declare platform-specific types, are declared in a header named for
that platform.
Before including these platform-specific Vulkan headers, applications must:
include both `{core_header}` and any external native headers the platform
extensions depend on.

As a convenience for applications that do not need the flexibility of
separate platform-specific Vulkan headers, `{full_header}` includes
`{core_header}`, and then conditionally includes platform-specific Vulkan
headers and the external headers they depend on.
Applications control which platform-specific headers are included by
#defining macros before including `{full_header}`.

The correspondence between platform-specific extensions, external headers
they require, the platform-specific header which declares them, and the
preprocessor macros which enable inclusion by `{full_header}` are shown in
the <<boilerplate-wsi-header-table,following table>>.

[[boilerplate-wsi-header-table]]
.Window System Extensions and Headers
[options="header"]
|====
| Extension Name                     | Window System Name | Platform-specific Header | Required External Headers      | Controlling `{full_header}` Macro
| `apiext:VK_KHR_android_surface`       | Android            | `vulkan_android.h`       | None                           | dname:VK_USE_PLATFORM_ANDROID_KHR
| `apiext:VK_KHR_wayland_surface`       | Wayland            | `vulkan_wayland.h`       | `<wayland-client.h>`           | dname:VK_USE_PLATFORM_WAYLAND_KHR
| `apiext:VK_KHR_win32_surface`,
  `apiext:VK_KHR_external_memory_win32`,
  `apiext:VK_KHR_win32_keyed_mutex`,
  `apiext:VK_KHR_external_semaphore_win32`,
  `apiext:VK_KHR_external_fence_win32`,
ifdef::VK_NV_external_memory_win32[]
  `apiext:VK_NV_external_memory_win32`,
endif::VK_NV_external_memory_win32[]
ifdef::VK_NV_win32_keyed_mutex[]
  `apiext:VK_NV_win32_keyed_mutex`
endif::VK_NV_win32_keyed_mutex[]
                                     | Microsoft Windows      | `vulkan_win32.h`         | `<windows.h>`                  | dname:VK_USE_PLATFORM_WIN32_KHR
| `apiext:VK_KHR_xcb_surface`           | X11 Xcb                | `vulkan_xcb.h`           | `<xcb/xcb.h>`                  | dname:VK_USE_PLATFORM_XCB_KHR
| `apiext:VK_KHR_xlib_surface`          | X11 Xlib               | `vulkan_xlib.h`          | `<X11/Xlib.h>`                 | dname:VK_USE_PLATFORM_XLIB_KHR
ifdef::VK_EXT_directfb_surface[]
| `apiext:VK_EXT_directfb_surface`      | DirectFB               | `vulkan_directfb.h`      | `<directfb/directfb.h>`        | dname:VK_USE_PLATFORM_DIRECTFB_EXT
endif::VK_EXT_directfb_surface[]
ifdef::VK_EXT_acquire_xlib_display[]
| `apiext:VK_EXT_acquire_xlib_display`  | X11 XRAndR             | `vulkan_xlib_xrandr.h`   | `<X11/Xlib.h>`,
                                                                                           `<X11/extensions{wbro}/Xrandr.h>`    | dname:VK_USE_PLATFORM_XLIB_XRANDR_EXT
endif::VK_EXT_acquire_xlib_display[]
ifdef::VK_GGP_stream_descriptor_surface[]
| `apiext:VK_GGP_stream_descriptor_surface`,
  `apiext:VK_GGP_frame_token`
                                     | Google Games Platform | `vulkan_ggp.h`        | <ggp_c/vulkan_types.h>         | dname:VK_USE_PLATFORM_GGP
endif::VK_GGP_stream_descriptor_surface[]
ifdef::VK_MVK_ios_surface[]
| `apiext:VK_MVK_ios_surface`           | iOS                    | `vulkan_ios.h`           | None                           | dname:VK_USE_PLATFORM_IOS_MVK
endif::VK_MVK_ios_surface[]
ifdef::VK_MVK_macos_surface[]
| `apiext:VK_MVK_macos_surface`         | macOS                  | `vulkan_macos.h`         | None                           | dname:VK_USE_PLATFORM_MACOS_MVK
endif::VK_MVK_macos_surface[]
ifdef::VK_NN_vi_surface[]
| `apiext:VK_NN_vi_surface`             | VI                     | `vulkan_vi.h`            | None                           | dname:VK_USE_PLATFORM_VI_NN
endif::VK_NN_vi_surface[]
ifdef::VK_FUCHSIA_imagepipe_surface[]
| `apiext:VK_FUCHSIA_imagepipe_surface` | Fuchsia                | `vulkan_fuchsia.h`       | `<zircon/types.h>`             | dname:VK_USE_PLATFORM_FUCHSIA
endif::VK_FUCHSIA_imagepipe_surface[]
ifdef::VK_EXT_metal_surface[]
| `apiext:VK_EXT_metal_surface`         | Metal on CoreAnimation | `vulkan_metal.h`         | None                           | dname:VK_USE_PLATFORM_METAL_EXT
endif::VK_EXT_metal_surface[]
ifdef::VK_QNX_screen_surface[]
| `apiext:VK_QNX_screen_surface`        | QNX Screen             | `vulkan_screen.h`        | `<screen/screen.h>`            | dname:VK_USE_PLATFORM_SCREEN_QNX
endif::VK_QNX_screen_surface[]
|====

[NOTE]
.Note
====
This section describes the purpose of the headers independently of the
specific underlying functionality of the window system extensions
themselves.
Each extension name will only link to a description of that extension when
viewing a specification built with that extension included.
====
--


[[boilerplate-provisional-header]]
== Provisional Extension Header Control (Informative)

[open,refpage='provisional-headers',desc='Control inclusion of provisional extensions',type='freeform',alias='VK_ENABLE_BETA_EXTENSIONS',anchor='boilerplate-provisional-header',xrefs='WSIheaders']
--
_Provisional_ extensions should: not be used in production applications.
The functionality defined by such extensions may: change in ways that break
backwards compatibility between revisions, and before final release of a
non-provisional version of that extension.

Provisional extensions are defined in a separate _provisional header_,
`vulkan_beta.h`, allowing applications to decide whether or not to include
them.
The mechanism is similar to <<boilerplate-wsi-header, window system-specific
headers>>: before including `vulkan_beta.h`, applications must: include
`{core_header}`.

[NOTE]
.Note
====
Sometimes a provisional extension will include a subset of its interfaces in
`{core_header}`.
This may occur if the provisional extension is promoted from an existing
vendor or EXT extension and some of the existing interfaces are defined as
aliases of the provisional extension interfaces.
All other interfaces of that provisional extension which are not aliased
will be included in `vulkan_beta.h`.
====

As a convenience for applications, `{full_header}` conditionally includes
`vulkan_beta.h`.
Applications can: control inclusion of `vulkan_beta.h` by #defining the
macro etext:VK_ENABLE_BETA_EXTENSIONS before including `{full_header}`.

[NOTE]
.Note
====
Starting in version 1.2.171 of the Specification, all provisional enumerants
are protected by the macro etext:VK_ENABLE_BETA_EXTENSIONS.
Applications needing to use provisional extensions must always define this
macro, even if they are explicitly including `vulkan_beta.h`.
This is a minor change to behavior, affecting only provisional extensions.
====

[NOTE]
.Note
====
This section describes the purpose of the provisional header independently
of the specific provisional extensions which are contained in that header at
any given time.
The extension appendices for provisional extensions note their provisional
status, and link back to this section for more information.
Provisional extensions are intended to provide early access for
bleeding-edge developers, with the understanding that extension interfaces
may change in response to developer feedback.
Provisional extensions are very likely to eventually be updated and released
as non-provisional extensions, but there is no guarantee this will happen,
or how long it will take if it does happen.
====
--