Home | History | Annotate | Download | only in templates 
      1 {{Include "vulkan_common.tmpl"}}
      2 {{Macro "DefineGlobals" $}}
      3 {{$ | Macro "vulkan.h" | Format (Global "clang-format") | Write "../include/vulkan.h"}}
      4 
      5 
      6 {{/*
      7 -------------------------------------------------------------------------------
      8   Entry point
      9 -------------------------------------------------------------------------------
     10 */}}
     11 {{define "vulkan.h"}}
     12 #ifndef __vulkan_h_
     13 #define __vulkan_h_ 1
     14 
     15 #ifdef __cplusplus
     16 extern "C" {
     17 #endif
     18 
     19 /*
     20 ** Copyright (c) 2015-2016 The Khronos Group Inc.
     21 **
     22 ** Permission is hereby granted, free of charge, to any person obtaining a
     23 ** copy of this software and/or associated documentation files (the
     24 ** "Materials"), to deal in the Materials without restriction, including
     25 ** without limitation the rights to use, copy, modify, merge, publish,
     26 ** distribute, sublicense, and/or sell copies of the Materials, and to
     27 ** permit persons to whom the Materials are furnished to do so, subject to
     28 ** the following conditions:
     29 **
     30 ** The above copyright notice and this permission notice shall be included
     31 ** in all copies or substantial portions of the Materials.
     32 **
     33 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     34 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     35 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     36 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     37 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     38 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     39 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
     40 */
     41 
     42 /*
     43 ** This header is generated from the Khronos Vulkan API Registry.
     44 **
     45 */
     46 
     47 #define VK_VERSION_1_0 1
     48 #include "vk_platform.h"
     49 
     50 #define VK_MAKE_VERSION(major, minor, patch) (((major) << 22) | ((minor) << 12) | (patch))
     51 
     52 // Vulkan API version supported by this file
     53 #define VK_API_VERSION \
     54     VK_MAKE_VERSION({{Global "VERSION_MAJOR"}}, {{Global "VERSION_MINOR"}}, {{Global "VERSION_PATCH"}})
     55 
     56 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
     57 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
     58 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
     59 
     60 #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800 || __cplusplus >= 201103L)
     61     #define VK_NULL_HANDLE nullptr
     62 #else
     63     #define VK_NULL_HANDLE 0
     64 #endif
     65 
     66 #define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
     67 
     68 #if defined(__cplusplus)
     69 #if ((defined(_MSC_VER) && _MSC_VER >= 1800 || __cplusplus >= 201103L)
     70 // The bool operator only works if there are no implicit conversions from an obj to
     71 // a bool-compatible type, which can then be used to unintentionally violate type safety.
     72 // C++11 and above supports the "explicit" keyword on conversion operators to stop this
     73 // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating
     74 // the object handle as a bool in expressions like:
     75 //     if (obj) vkDestroy(obj);
     76 #define VK_NONDISP_HANDLE_OPERATOR_BOOL() \
     77     explicit operator bool() const { return handle != 0; }
     78 #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
     79     explicit obj(uint64_t x) : handle(x) { } \
     80     obj(decltype(nullptr)) : handle(0) { }
     81 #else
     82 #define VK_NONDISP_HANDLE_OPERATOR_BOOL()
     83 #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
     84     obj(uint64_t x) : handle(x) { }
     85 #endif
     86 #define VK_DEFINE_NONDISP_HANDLE(obj)                                              \
     87     struct obj {                                                                   \
     88         obj() : handle(0) { }                                                      \
     89         VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj)                             \
     90         obj& operator=(uint64_t x) {                                               \
     91             handle = x;                                                            \
     92             return *this;                                                          \
     93         }                                                                          \
     94         bool operator==(const obj& other) const { return handle == other.handle; } \
     95         bool operator!=(const obj& other) const { return handle != other.handle; } \
     96         bool operator!() const { return !handle; }                                 \
     97         VK_NONDISP_HANDLE_OPERATOR_BOOL()                                          \
     98         uint64_t handle;                                                           \
     99     };
    100 #else
    101 #define VK_DEFINE_NONDISP_HANDLE(obj) \
    102     typedef struct obj##_T { uint64_t handle; } obj;
    103 #endif
    104 
    105 #define VK_LOD_CLAMP_NONE         1000.0f
    106 #define VK_REMAINING_MIP_LEVELS   (~0U)
    107 #define VK_REMAINING_ARRAY_LAYERS (~0U)
    108 #define VK_WHOLE_SIZE             (~0ULL)
    109 #define VK_ATTACHMENT_UNUSED      (~0U)
    110 define VK_QUEUE_FAMILY_IGNORED    (~0U)
    111 define VK_SUBPASS_EXTERNAL        (~0U)
    112 {{range $d := $.Definitions}}
    113   {{if HasPrefix $d.Name "VK_"}}#define {{$d.Name}}  {{$d.Expression}}{{end}}
    114 {{end}}
    115 
    116 {{range $i, $p := $.Pseudonyms}}
    117   {{if GetAnnotation $p "dispatchHandle"}}VK_DEFINE_HANDLE({{$p.Name}})
    118   {{else if GetAnnotation $p "nonDispatchHandle"}}VK_DEFINE_NONDISP_HANDLE({{$p.Name}})
    119   {{end}}
    120 {{end}}
    121 
    122 // ------------------------------------------------------------------------------------------------
    123 // Enumerations
    124 
    125   {{range $e := $.Enums}}
    126     {{if not $e.IsBitfield}}
    127       {{Macro "Enum" $e}}
    128     {{end}}
    129   {{end}}
    130 
    131 // ------------------------------------------------------------------------------------------------
    132 // Flags
    133 
    134   {{range $e := $.Enums}}
    135     {{if $e.IsBitfield}}
    136       {{Macro "Bitfield" $e}}
    137     {{end}}
    138   {{end}}
    139 
    140 // ------------------------------------------------------------------------------------------------
    141 // Vulkan structures
    142 
    143   {{/* Function pointers */}}
    144   {{range $f := AllCommands $}}
    145     {{if GetAnnotation $f "pfn"}}
    146       {{Macro "FunctionTypedef" $f}}
    147     {{end}}
    148   {{end}}
    149 
    150   {{range $c := $.Classes}}
    151     {{if not (GetAnnotation $c "internal")}}
    152       {{Macro "Struct" $c}}
    153     {{end}}
    154   {{end}}
    155 
    156 // ------------------------------------------------------------------------------------------------
    157 // API functions
    158 
    159   {{range $f := AllCommands $}}
    160     {{if not (GetAnnotation $f "pfn")}}
    161       {{Macro "FunctionTypedef" $f}}
    162     {{end}}
    163   {{end}}
    164 
    165 #ifdef VK_NO_PROTOTYPES
    166 
    167   {{range $f := AllCommands $}}
    168     {{if not (GetAnnotation $f "pfn")}}
    169       {{Macro "FunctionDecl" $f}}
    170     {{end}}
    171   {{end}}
    172 
    173 #endif
    174 
    175 #ifdef __cplusplus
    176 }
    177 #endif
    178 
    179 #endif
    180 {{end}}
    181 
    182 {{/*
    183 -------------------------------------------------------------------------------
    184   Emits the C declaration for the specified bitfield.
    185 -------------------------------------------------------------------------------
    186 */}}
    187 {{define "Bitfield"}}
    188   {{AssertType $ "Enum"}}
    189 
    190   {{Macro "Docs" $.Docs}}
    191   typedef VkFlags {{Macro "EnumName" $}};
    192   {{if $.Entries}}
    193   typedef enum {
    194   {{range $b := $.Entries}}
    195     {{Macro "BitfieldEntryName" $b}} = {{printf "0x%.8X" $b.Value}}, {{Macro "Docs" $b.Docs}}
    196   {{end}}
    197   } {{Macro "EnumName" $ | TrimRight "s"}}Bits;
    198   {{end}}
    199   
    200 {{end}}
    201 
    202 
    203 {{/*
    204 -------------------------------------------------------------------------------
    205   Emits the C declaration for the specified enum.
    206 -------------------------------------------------------------------------------
    207 */}}
    208 {{define "Enum"}}
    209   {{AssertType $ "Enum"}}
    210 
    211   {{Macro "Docs" $.Docs}}
    212   typedef enum {
    213     {{range $i, $e := $.Entries}}
    214       {{Macro "EnumEntry" $e}} = {{printf "0x%.8X" $e.Value}}, {{Macro "Docs" $e.Docs}}
    215     {{end}}
    216   
    217     {{$name  := Macro "EnumName" $ | TrimRight "ABCDEFGHIJKLMNOQRSTUVWXYZ" | SplitPascalCase | Upper | JoinWith "_"}}
    218     {{if GetAnnotation $ "enumMaxOnly"}}
    219       VK_MAX_ENUM({{$name | SplitOn "VK_"}})
    220     {{else}}
    221       {{$first := Macro "EnumFirstEntry" $ | SplitOn $name | TrimLeft "_"}}
    222       {{$last  := Macro "EnumLastEntry" $  | SplitOn $name | TrimLeft "_"}}
    223       VK_ENUM_RANGE({{$name | SplitOn "VK_"}}, {{$first}}, {{$last}})
    224     {{end}}
    225   } {{Macro "EnumName" $}};
    226   
    227 {{end}}
    228 
    229 
    230 {{/*
    231 -------------------------------------------------------------------------------
    232   Emits the C declaration for the specified class.
    233 -------------------------------------------------------------------------------
    234 */}}
    235 {{define "Struct"}}
    236   {{AssertType $ "Class"}}
    237 
    238   {{Macro "Docs" $.Docs}}
    239   typedef {{Macro "StructType" $}} {
    240     {{ForEach $.Fields "Field" | JoinWith "\n"}}
    241   } {{Macro "StructName" $}};
    242   
    243 {{end}}
    244 
    245 
    246 {{/*
    247 -------------------------------------------------------------------------------
    248   Emits the C declaration for the specified class field.
    249 -------------------------------------------------------------------------------
    250 */}}
    251 {{define "Field"}}
    252   {{AssertType $ "Field"}}
    253 
    254   {{Node "Type" $}} {{$.Name}}
    255   {{Macro "ArrayPostfix" (TypeOf $)}}; {{Macro "Docs" $.Docs}}
    256 {{end}}
    257 
    258 
    259 {{/*
    260 -------------------------------------------------------------------------------
    261   Emits either 'struct' or 'union' for the specified class.
    262 -------------------------------------------------------------------------------
    263 */}}
    264 {{define "StructType"}}
    265   {{AssertType $ "Class"}}
    266 
    267   {{if GetAnnotation $ "union"}}union{{else}}struct{{end}}
    268 {{end}}
    269 
    270 
    271 {{/*
    272 -------------------------------------------------------------------------------
    273   Emits the C function pointer typedef declaration for the specified command.
    274 -------------------------------------------------------------------------------
    275 */}}
    276 {{define "FunctionTypedef"}}
    277   {{AssertType $ "Function"}}
    278 
    279   typedef {{Node "Type" $.Return}} (VKAPI* {{Macro "FunctionPtrName" $}})({{Macro "Parameters" $}});
    280 {{end}}
    281 
    282 
    283 {{/*
    284 -------------------------------------------------------------------------------
    285   Emits the C function declaration for the specified command.
    286 -------------------------------------------------------------------------------
    287 */}}
    288 {{define "FunctionDecl"}}
    289   {{AssertType $ "Function"}}
    290 
    291   {{if not (GetAnnotation $ "fptr")}}
    292     {{Macro "Docs" $.Docs}}
    293     {{Node "Type" $.Return}} VKAPI {{Macro "FunctionName" $}}({{Macro "Parameters" $}});
    294   {{end}}
    295 {{end}}
    296