├── LICENSE ├── README.md ├── basetype.go ├── basetype_metal.go ├── bitmask.go ├── bitmask_macos.go ├── bitmask_metal.go ├── bitmask_win32.go ├── command.go ├── command_macos.go ├── command_metal.go ├── command_win32.go ├── define.go ├── dlload.c ├── dlload.h ├── enum.go ├── enum_macos.go ├── enum_metal.go ├── enum_metal_string_0.go ├── enum_string_0.go ├── enum_string_1.go ├── enum_string_2.go ├── enum_string_3.go ├── enum_string_4.go ├── enum_string_5.go ├── enum_string_6.go ├── enum_string_7.go ├── enum_win32.go ├── enum_win32_string_0.go ├── exten.go ├── exten_macos.go ├── exten_metal.go ├── exten_win32.go ├── external.go ├── go.mod ├── go.sum ├── handle.go ├── static_basetype.go ├── static_common.go ├── static_defines.go ├── static_mem.go ├── struct.go ├── struct_macos.go ├── struct_metal.go ├── struct_win32.go ├── sys_unix.go ├── sys_windows.go └── union.go /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 Ben Bredesen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 6 | 7 | The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # go-vk - Vulkan 1.3 supporting Windows and Mac 2 | 3 | ***This package is in a beta state right now!*** It has been tested on Windows and Mac. Please report any bugs you find! 4 | 5 | go-vk is a Go-langauge (and Go-style) binding around the Vulkan graphics API. Rather than just slapping a Cgo wrapper 6 | around everything, Vulkan's functions, structures and other types have been translated to a Go-style API. For example, 7 | "native" Vulkan returns any resources you request in pointers your program passes into Vulkan. This allows 8 | Vulkan to (generally) return a VkResult success or error code from the C function call. However, in Go, we have the 9 | luxury of multiple return values, so this: 10 | 11 | ```C 12 | VkInstance myInstance; 13 | Result r = vkCreateInstance(&instanceCI, NULL, &myInstance); 14 | if (r != VK_SUCCESS) { 15 | // Handle an error 16 | } 17 | // Use the instance handle 18 | ``` 19 | 20 | Becomes this: 21 | ```go 22 | instance, err := vk.CreateInstance(&instanceCI, nil) 23 | if err != nil { 24 | panic("Could not create a Vulkan instance!") // Don't panic 25 | } 26 | ``` 27 | 28 | Likewise, the "Enumerate" group of functions returning an array of values in C require a call, an error check, an 29 | allocation, another function call, and another error check: 30 | ```C 31 | int deviceCount; 32 | Result res = vkEnumeratePhysicalDevices(myInstance, &deviceCount, NULL); 33 | if (res != VK_SUCCESS) { // Check the result, of course 34 | // handle the error 35 | } 36 | // ...and you really should also check that deviceCount > 0 37 | if (deviceCount == 0) { 38 | // gracefully exit, since there are no GPU devices actually available on this machine 39 | } 40 | 41 | VkPhysicalDevice devices[deviceCount]; 42 | 43 | res = vkEnumeratePhysicalDevices(myInstance, &deviceCount, devices); 44 | if (res != VK_SUCCESS) { // Check the result again 45 | // handle the error 46 | } 47 | // Now do something with the devices and make sure you hold on to deviceCount 48 | // so you don't go beyond the bounds of the array... 49 | for (int i = 0; i < deviceCount; i++) { 50 | // Check device suitability, select a device, and hold on to that handle... 51 | } 52 | ``` 53 | 54 | Yuck. Here's the same code in Go: 55 | ```go 56 | if devices, err := vk.EnumeratePhysicalDevices(myInstance); err != nil { 57 | // handle the error 58 | } else { 59 | // devices is a slice of vk.PhysicalDevice. Nice! 60 | } 61 | ``` 62 | 63 | But there's more! Passing multiple values to a Vulkan command requires a pointer and count parameter, and sometimes 64 | that count parameter is embedded in another struct. You can make life a little easier with C++'s `std::vector`. 65 | For example, specifying requested extensions at instance creation: 66 | 67 | ```C++ 68 | std::vector requiredExtensions = { 69 | VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SURFACE_EXTENSION_NAME 70 | }; 71 | 72 | VkInstanceCreateInfo createInfo{}; 73 | createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 74 | // Other create info props... 75 | 76 | // set the size 77 | createInfo.enabledExtensionCount = static_cast(extensions.size()); 78 | // extract the data pointer from the vector 79 | createInfo.ppEnabledExtensionNames = extensions.data(); 80 | ``` 81 | 82 | versus: 83 | 84 | ```go 85 | requiredExtensions := []string{vk.KHR_SWAPCHAIN_EXTENSION_NAME, vk.KHR_SURFACE_EXTENSION_NAME} 86 | 87 | createInfo := vk.InstanceCreateInfo{ 88 | // No structure type, no length member, and no pointer required. 89 | // Just assign the slice, or even instantiate it inline 90 | EnabledExtensionNames: requiredExtensions, 91 | } 92 | ``` 93 | 94 | ## Code Generation 95 | This codebase is (almost) entirely generated from a `vk.xml` file by the [vk-gen](https://github.com/bbredesen/vk-gen) 96 | tool. Updating go-vk for a new Vulkan version should be as easy as downloading the new vk.xml file from Khronos and 97 | executing vk-gen. **This repository does not get direct modifications!** Any bug fixes or new features need to be made in 98 | `vk-gen`, which will then be used re-generate this code base. 99 | 100 | ## Usage 101 | 102 | Ensure that your GPU supports Vulkan and that a Vulkan library is installed in your system-default library location 103 | (e.g., C:\windows\system32\vulkan-1.dll on Windows). This package uses Cgo to call Vulkan, so it needs to be enabled in 104 | your Go settings. 105 | 106 | `$ go get github.com/bbredesen/go-vk@latest` 107 | 108 | Builds for Vulkan API versions 1.1, 1.2, 1.3 (and future releases) will be tagged as releases of go-vk with matching 109 | version numbers, if you want to use a specific version of the API. go-vk does not itself require the Vulkan SDK be installed, 110 | as it reads symbols from the system-default Vulkan library at runtime. However, you will need the SDK installed to use 111 | validation layers, shader compilers, etc. during development. 112 | 113 | ```go main.go 114 | package main 115 | 116 | import ( 117 | "github.com/bbredesen/go-vk" 118 | ) 119 | // Notice that you don't need to alias the import, it is already bound to the "vk" namespace 120 | 121 | func main() { 122 | if encodedVersion, err := vk.EnumerateInstanceVersion(); err != nil { 123 | // Returned errors are vk.Results. You can directly compare err those 124 | // predefined values to determine which error occured. 125 | // The string returned by Error() is the name of the code. For example, 126 | // vk.ERROR_OUT_OF_DATE_KHR.Error() == "ERROR_OUT_OF_DATE_KHR" 127 | fmt.Printf("EnumerateInstanceVersion failed! Error code was %s\n", err.Error()) 128 | os.Exit(1) 129 | } else { 130 | fmt.Printf("Installed Vulkan version: %d.%d.%d\n", 131 | vk.API_VERSION_MAJOR(encodedVersion), 132 | vk.API_VERSION_MINOR(encodedVersion), 133 | vk.API_VERSION_PATCH(encodedVersion), 134 | ) 135 | } 136 | 137 | // Also notice that you don't need to set the StructureType field on your Go structs. 138 | // In fact, the sType field doesn't even exist on the public side of the binding...it is automatically 139 | // added when you pass your struct through to a command. 140 | appInfo := vk.ApplicationInfo{ 141 | ApplicationName: "Example App", 142 | ApplicationVersion: vk.MAKE_VERSION(1, 0, 0), 143 | EngineVersion: vk.MAKE_VERSION(1, 0, 0), 144 | ApiVersion: vk.MAKE_VERSION(1, 3, 0), 145 | } 146 | 147 | icInfo := vk.InstanceCreateInfo{ 148 | ApplicationInfo: appInfo, 149 | // Extension names are built into the binding as const strings. 150 | EnabledExtensionNames: []string{vk.KHR_SURFACE_EXTENSION_NAME, vk.KHR_WIN32_SURFACE_EXTENSION_NAME}, 151 | // Layer names are not built in, unfortunately...layers are not part of the core API spec and names are not present in vk.xml 152 | EnabledLayerNames: []string{"VK_LAYER_KHRONOS_validation"}, 153 | } 154 | 155 | instance, err := vk.CreateInstance(&icInfo, nil) 156 | // vk.SUCCESS is defined as nil, so you can also check for an error like this if preferred. 157 | if err != vk.SUCCESS { 158 | fmt.Printf("Failed to create Vulkan instance, error code was %s\n", err.Error()) 159 | if err == vk.ERROR_INCOMPATIBLE_DRIVER { 160 | /* ... */ 161 | } 162 | } 163 | fmt.Printf("Vulkan instance created, handle value is 0x%x\n", instance) 164 | 165 | // Clean up after yourself before exiting! 166 | vk.DestroyInstance(instance) 167 | } 168 | ``` 169 | 170 | `$ go run main.go` 171 | 172 | A number of code samples and working demos, including an implementation of the excellent tutorial program from 173 | [vulkan-tutorial.com](https://vulkan-tutorial.com), are available at [go-vk-samples](https://github.com/bbredesen/go-vk-samples) 174 | 175 | ## Library Structure 176 | 177 | The Vulkan API is defined through a set of type categories, each of which has a corresponding source file in go-vk. 178 | Thus, you will find all structs defined in struct.go, all commands defined in command.go, etc. Where 179 | platform-specific types are neccessary, they are defined in separate files with appropriate go:build tags. The 180 | `stringify` tool has also been run against enumerated types, so if `result == vk.NOT_READY` then `result.String() == "NOT_READY"`. 181 | 182 | The underlying Vulkan implementation is actually accessed through a small Cgo wrapper, found in static_common.go; go-vk 183 | opens the shared library and lazy-loads any requested symbols. All of the public-facing structs in Go are translated to 184 | the appropriate memory layout before being passed through to the API, via each struct's Vulkanize() function. 185 | Vulkanize()'s primary purpose is to convert slices to a length and pointer field in the internal struct, Go strings to 186 | null-terminated byte pointers, and to recursively Vulkanize any non-primitive members. 187 | 188 | The structs also have a Goify function to do the reverse: create slices 189 | from a length and pointer field and create strings from null-terminated byte arrays. In practice, this is only used for 190 | structs that are returned by the API, but Goify is implemented on all structs. 191 | 192 | Note that you should never need to directly call Vulkanize() or Goify() (with one expection, noted below). Conversions are 193 | automatically handled in the background when you call a Vulkan command. 194 | 195 | ### Extended Structs 196 | If you use pNext to extend any structures, you will need to manually build the chain by calling Vulkanize() and setting the returned pointer in the 197 | base struct. 198 | 199 | ```go 200 | instanceCI := vk.InstanceCreateInfo{ 201 | // ... 202 | } 203 | 204 | validationFeatures := vk.ValidationFeaturesEXT{ 205 | PEnabledValidationFeatures: []vk.ValidationFeatureEnableEXT{vk.VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT} 206 | // ... 207 | } 208 | 209 | instanceCI.PNext = unsafe.Pointer(validationFeatures.Vulkanize()) 210 | ``` 211 | 212 | Leaving these as unsafe.Pointers was the simplest implementation to get the binding up and running. The next level of 213 | implementation is to define pNext as a Vulkanizer interface type, and have Vulkanize build the chain. I've also 214 | considered more specific interfaces flagged with empty functions, 215 | since the spec does indicate for each struct with what other structs it extends (e.g., VkValidationFlagsEXT has a 216 | structextends="VkInstanceCreateInfo" attribute). 217 | 218 | ## Mapped memory and copying data 219 | 220 | Any practical Vulkan application will need to copy raw data between the CPU and GPU...loads to uniform buffers, texture 221 | data, etc. are exposed through vkMapMemory. Unfortunately for us, Go is designed to avoid directly 222 | managing and copying memory. To handle this, three specific utility functions are included with go-vk: MemCopySlice, 223 | MemCopyObj, and MemCopy. 224 | 225 | The first two two functions use generics to copy your data byte-for-byte to Vulkan in an abstract way, so Go 1.18 or higher is a 226 | requirement. 227 | 228 | The MemCopy function that accepts two unsafe.Pointers and a number of bytes to copy, but it is recommended 229 | that you use MemCopyObj or MemCopySlice instead. It is really only offered in case you need to target a Go version less 230 | than 1.18 (and hence do not have access to generics). In that case you could vendor a copy of go-vk in your project and 231 | delete the two generic functions. 232 | 233 | **There are no guardrails on any of these functions! You, the developer, are repsonbile for allocating enough memory 234 | at the destination before calling them.** 235 | 236 | They do not (and cannot) check how much space is available behind the pointer you give them. Under the hood, they create "fake" 237 | byte slices at the destination pointer and the source pointer or at the head of the input slice. It then uses Go's copy macro 238 | to copy the data over. 239 | 240 | Go version 1.20 includes some new functions in the unsafe package for copying slices to pointers, allowing you to "cast" 241 | between pointers and slices and use the `copy()` macro. The MemCopy functions above were written before the 1.20 release and do 242 | effectively the same thing. You are free to use whichever method you prefer. 243 | 244 | In Go 1.20+, this: 245 | ```go 246 | ptr, err := vk.MapMemory(/* ... */) 247 | 248 | sl := unsafe.Slice((*VertexFormat)(ptr), len(vertices)) 249 | copy(sl, vertices) 250 | ``` 251 | ...is functionally the same as this: 252 | ```go 253 | ptr, err := vk.MapMemory(/* ... */) 254 | 255 | vk.MemCopySlice(ptr, vertices) 256 | ``` 257 | 258 | ## A note on unions 259 | 260 | Vulkan includes a small number of C-union types, VkClearValue and VkClearColorValue probably being the most commonly used. 261 | However, Go does not have any concept of unions in the language. In go-vk, those unions are implemented as a struct 262 | containing all of the members of the union, which is resolved behind the scenes to the correct member. You will need to 263 | set the field you intend to use by calling the `As` method on those structs. The struct's Vulkanize() method will 264 | then extract the correct member for passing into the Vulkan API. 265 | 266 | ```go 267 | var ccv vk.ClearColorValue 268 | ccv.AsTypeFloat32(float32[4]{0.0, 0.0, 0.0, 1.0}) 269 | // The spec names this field float32, which is a reserved word in Go. vk-gen 270 | // renames these fields to TypeFloat32, TypeInt32, etc. to avoid any conflicts. 271 | ``` 272 | 273 | ## Examples 274 | 275 | See the [go-vk-samples](https://github.com/bbredesen/go-vk-samples) repo for a number of working Vulkan samples using 276 | this library. The samples currently run on Windows and Mac. 277 | 278 | ## Known Issues 279 | 280 | * VkAccelerationStructureMatrixMotionInstanceNV - embedded bit fields in uint32_t are not handled at all...this 281 | structure will not behave as intended and will likely cause a crash if used. 282 | * H.264 and H.265 commands and types are almost certainly broken. Vulkan does provide a separate XML file in the vk.xml format for those 283 | types, but reading that file has not yet been implemented in vk-gen. As a placeholder, all of these types are defined 284 | as int32 through exceptions.json. 285 | * The union type VkPipelineExecutableStatisticValueKHR is returned from Vulkan through VkPipelineExecutableStatisticKHR. 286 | Returned unions are not supported and there is no Goify() function associated. VkPipelineExecutableStatisticKHR is 287 | returned to the developer without the Value member populated. -------------------------------------------------------------------------------- /basetype.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.53584 -0500 EST m=+3.061284658. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | import "unsafe" 6 | 7 | // DeviceAddress: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddress.html 8 | type DeviceAddress uint64 9 | 10 | // DeviceSize: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceSize.html 11 | type DeviceSize uint64 12 | 13 | // Flags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags.html 14 | type Flags uint32 15 | 16 | // Flags64: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags64.html 17 | type Flags64 uint64 18 | 19 | // PFN_vkAllocationFunction: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkAllocationFunction.html 20 | type PFN_vkAllocationFunction unsafe.Pointer 21 | 22 | // PFN_vkDebugReportCallbackEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugReportCallbackEXT.html 23 | type PFN_vkDebugReportCallbackEXT unsafe.Pointer 24 | 25 | // PFN_vkDebugUtilsMessengerCallbackEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html 26 | type PFN_vkDebugUtilsMessengerCallbackEXT unsafe.Pointer 27 | 28 | // PFN_vkDeviceMemoryReportCallbackEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html 29 | type PFN_vkDeviceMemoryReportCallbackEXT unsafe.Pointer 30 | 31 | // PFN_vkFreeFunction: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkFreeFunction.html 32 | type PFN_vkFreeFunction unsafe.Pointer 33 | 34 | // PFN_vkGetInstanceProcAddrLUNARG: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkGetInstanceProcAddrLUNARG.html 35 | type PFN_vkGetInstanceProcAddrLUNARG unsafe.Pointer 36 | 37 | // PFN_vkInternalAllocationNotification: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalAllocationNotification.html 38 | type PFN_vkInternalAllocationNotification unsafe.Pointer 39 | 40 | // PFN_vkInternalFreeNotification: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalFreeNotification.html 41 | type PFN_vkInternalFreeNotification unsafe.Pointer 42 | 43 | // PFN_vkReallocationFunction: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkReallocationFunction.html 44 | type PFN_vkReallocationFunction unsafe.Pointer 45 | 46 | // PFN_vkVoidFunction: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkVoidFunction.html 47 | type PFN_vkVoidFunction unsafe.Pointer 48 | 49 | // RemoteAddressNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRemoteAddressNV.html 50 | type RemoteAddressNV unsafe.Pointer 51 | 52 | // SampleMask: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html 53 | type SampleMask uint32 54 | 55 | // Bool32: Note that go-vk uses standard Go bools throughout the public API. Bool32 is only used internally and is automatically translated for you. 56 | // See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBool32.html 57 | type Bool32 uint32 58 | -------------------------------------------------------------------------------- /basetype_metal.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.738365 -0500 EST m=+3.263810870. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import "unsafe" 7 | 8 | // CAMetalLayer: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/CAMetalLayer.html 9 | type CAMetalLayer struct{} 10 | 11 | // IOSurfaceRef: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/IOSurfaceRef.html 12 | type IOSurfaceRef unsafe.Pointer 13 | 14 | // MTLBuffer_id: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/MTLBuffer_id.html 15 | type MTLBuffer_id unsafe.Pointer 16 | 17 | // MTLCommandQueue_id: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/MTLCommandQueue_id.html 18 | type MTLCommandQueue_id unsafe.Pointer 19 | 20 | // MTLDevice_id: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/MTLDevice_id.html 21 | type MTLDevice_id unsafe.Pointer 22 | 23 | // MTLSharedEvent_id: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/MTLSharedEvent_id.html 24 | type MTLSharedEvent_id unsafe.Pointer 25 | 26 | // MTLTexture_id: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/MTLTexture_id.html 27 | type MTLTexture_id unsafe.Pointer 28 | -------------------------------------------------------------------------------- /bitmask.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.526479 -0500 EST m=+3.051923781. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // AccelerationStructureCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateFlagsKHR.html 6 | type AccelerationStructureCreateFlagsKHR Flags 7 | 8 | // AccelerationStructureMotionInfoFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html 9 | type AccelerationStructureMotionInfoFlagsNV Flags 10 | 11 | // AccelerationStructureMotionInstanceFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html 12 | type AccelerationStructureMotionInstanceFlagsNV Flags 13 | 14 | // AccessFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlags.html 15 | type AccessFlags Flags 16 | 17 | // AccessFlags2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlags2.html 18 | type AccessFlags2 Flags64 19 | 20 | // AccessFlags2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlags2KHR.html 21 | type AccessFlags2KHR = AccessFlags2 22 | 23 | // AcquireProfilingLockFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockFlagsKHR.html 24 | type AcquireProfilingLockFlagsKHR Flags 25 | 26 | // AttachmentDescriptionFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionFlags.html 27 | type AttachmentDescriptionFlags Flags 28 | 29 | // BufferCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateFlags.html 30 | type BufferCreateFlags Flags 31 | 32 | // BufferUsageFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferUsageFlags.html 33 | type BufferUsageFlags Flags 34 | 35 | // BufferUsageFlags2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferUsageFlags2KHR.html 36 | type BufferUsageFlags2KHR Flags64 37 | 38 | // BufferViewCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html 39 | type BufferViewCreateFlags Flags 40 | 41 | // BuildAccelerationStructureFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildAccelerationStructureFlagsKHR.html 42 | type BuildAccelerationStructureFlagsKHR Flags 43 | 44 | // BuildAccelerationStructureFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildAccelerationStructureFlagsNV.html 45 | type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR 46 | 47 | // BuildMicromapFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildMicromapFlagsEXT.html 48 | type BuildMicromapFlagsEXT Flags 49 | 50 | // ColorComponentFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorComponentFlags.html 51 | type ColorComponentFlags Flags 52 | 53 | // CommandBufferResetFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferResetFlags.html 54 | type CommandBufferResetFlags Flags 55 | 56 | // CommandBufferUsageFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferUsageFlags.html 57 | type CommandBufferUsageFlags Flags 58 | 59 | // CommandPoolCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateFlags.html 60 | type CommandPoolCreateFlags Flags 61 | 62 | // CommandPoolResetFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolResetFlags.html 63 | type CommandPoolResetFlags Flags 64 | 65 | // CommandPoolTrimFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlags.html 66 | type CommandPoolTrimFlags Flags 67 | 68 | // CommandPoolTrimFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlagsKHR.html 69 | type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags 70 | 71 | // CompositeAlphaFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCompositeAlphaFlagsKHR.html 72 | type CompositeAlphaFlagsKHR Flags 73 | 74 | // ConditionalRenderingFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingFlagsEXT.html 75 | type ConditionalRenderingFlagsEXT Flags 76 | 77 | // CullModeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCullModeFlags.html 78 | type CullModeFlags Flags 79 | 80 | // DebugReportFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportFlagsEXT.html 81 | type DebugReportFlagsEXT Flags 82 | 83 | // DebugUtilsMessageSeverityFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageSeverityFlagsEXT.html 84 | type DebugUtilsMessageSeverityFlagsEXT Flags 85 | 86 | // DebugUtilsMessageTypeFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageTypeFlagsEXT.html 87 | type DebugUtilsMessageTypeFlagsEXT Flags 88 | 89 | // DebugUtilsMessengerCallbackDataFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html 90 | type DebugUtilsMessengerCallbackDataFlagsEXT Flags 91 | 92 | // DebugUtilsMessengerCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html 93 | type DebugUtilsMessengerCreateFlagsEXT Flags 94 | 95 | // DependencyFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyFlags.html 96 | type DependencyFlags Flags 97 | 98 | // DescriptorBindingFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBindingFlags.html 99 | type DescriptorBindingFlags Flags 100 | 101 | // DescriptorBindingFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBindingFlagsEXT.html 102 | type DescriptorBindingFlagsEXT = DescriptorBindingFlags 103 | 104 | // DescriptorPoolCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateFlags.html 105 | type DescriptorPoolCreateFlags Flags 106 | 107 | // DescriptorPoolResetFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html 108 | type DescriptorPoolResetFlags Flags 109 | 110 | // DescriptorSetLayoutCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateFlags.html 111 | type DescriptorSetLayoutCreateFlags Flags 112 | 113 | // DescriptorUpdateTemplateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html 114 | type DescriptorUpdateTemplateCreateFlags Flags 115 | 116 | // DescriptorUpdateTemplateCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlagsKHR.html 117 | type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags 118 | 119 | // DeviceAddressBindingFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingFlagsEXT.html 120 | type DeviceAddressBindingFlagsEXT Flags 121 | 122 | // DeviceCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html 123 | type DeviceCreateFlags Flags 124 | 125 | // DeviceDiagnosticsConfigFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigFlagsNV.html 126 | type DeviceDiagnosticsConfigFlagsNV Flags 127 | 128 | // DeviceGroupPresentModeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentModeFlagsKHR.html 129 | type DeviceGroupPresentModeFlagsKHR Flags 130 | 131 | // DeviceMemoryReportFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html 132 | type DeviceMemoryReportFlagsEXT Flags 133 | 134 | // DeviceQueueCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateFlags.html 135 | type DeviceQueueCreateFlags Flags 136 | 137 | // DirectDriverLoadingFlagsLUNARG: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingFlagsLUNARG.html 138 | type DirectDriverLoadingFlagsLUNARG Flags 139 | 140 | // DisplayModeCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateFlagsKHR.html 141 | type DisplayModeCreateFlagsKHR Flags 142 | 143 | // DisplayPlaneAlphaFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneAlphaFlagsKHR.html 144 | type DisplayPlaneAlphaFlagsKHR Flags 145 | 146 | // DisplaySurfaceCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html 147 | type DisplaySurfaceCreateFlagsKHR Flags 148 | 149 | // EventCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateFlags.html 150 | type EventCreateFlags Flags 151 | 152 | // ExternalFenceFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceFeatureFlags.html 153 | type ExternalFenceFeatureFlags Flags 154 | 155 | // ExternalFenceFeatureFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceFeatureFlagsKHR.html 156 | type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags 157 | 158 | // ExternalFenceHandleTypeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceHandleTypeFlags.html 159 | type ExternalFenceHandleTypeFlags Flags 160 | 161 | // ExternalFenceHandleTypeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceHandleTypeFlagsKHR.html 162 | type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags 163 | 164 | // ExternalMemoryFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlags.html 165 | type ExternalMemoryFeatureFlags Flags 166 | 167 | // ExternalMemoryFeatureFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagsKHR.html 168 | type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags 169 | 170 | // ExternalMemoryFeatureFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagsNV.html 171 | type ExternalMemoryFeatureFlagsNV Flags 172 | 173 | // ExternalMemoryHandleTypeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlags.html 174 | type ExternalMemoryHandleTypeFlags Flags 175 | 176 | // ExternalMemoryHandleTypeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagsKHR.html 177 | type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags 178 | 179 | // ExternalMemoryHandleTypeFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagsNV.html 180 | type ExternalMemoryHandleTypeFlagsNV Flags 181 | 182 | // ExternalSemaphoreFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreFeatureFlags.html 183 | type ExternalSemaphoreFeatureFlags Flags 184 | 185 | // ExternalSemaphoreFeatureFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreFeatureFlagsKHR.html 186 | type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags 187 | 188 | // ExternalSemaphoreHandleTypeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreHandleTypeFlags.html 189 | type ExternalSemaphoreHandleTypeFlags Flags 190 | 191 | // ExternalSemaphoreHandleTypeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreHandleTypeFlagsKHR.html 192 | type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags 193 | 194 | // FenceCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateFlags.html 195 | type FenceCreateFlags Flags 196 | 197 | // FenceImportFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceImportFlags.html 198 | type FenceImportFlags Flags 199 | 200 | // FenceImportFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceImportFlagsKHR.html 201 | type FenceImportFlagsKHR = FenceImportFlags 202 | 203 | // FormatFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlags.html 204 | type FormatFeatureFlags Flags 205 | 206 | // FormatFeatureFlags2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlags2.html 207 | type FormatFeatureFlags2 Flags64 208 | 209 | // FormatFeatureFlags2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlags2KHR.html 210 | type FormatFeatureFlags2KHR = FormatFeatureFlags2 211 | 212 | // FrameBoundaryFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrameBoundaryFlagsEXT.html 213 | type FrameBoundaryFlagsEXT Flags 214 | 215 | // FramebufferCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateFlags.html 216 | type FramebufferCreateFlags Flags 217 | 218 | // GeometryFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryFlagsKHR.html 219 | type GeometryFlagsKHR Flags 220 | 221 | // GeometryFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryFlagsNV.html 222 | type GeometryFlagsNV = GeometryFlagsKHR 223 | 224 | // GeometryInstanceFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryInstanceFlagsKHR.html 225 | type GeometryInstanceFlagsKHR Flags 226 | 227 | // GeometryInstanceFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryInstanceFlagsNV.html 228 | type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR 229 | 230 | // GraphicsPipelineLibraryFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryFlagsEXT.html 231 | type GraphicsPipelineLibraryFlagsEXT Flags 232 | 233 | // HeadlessSurfaceCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html 234 | type HeadlessSurfaceCreateFlagsEXT Flags 235 | 236 | // HostImageCopyFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHostImageCopyFlagsEXT.html 237 | type HostImageCopyFlagsEXT Flags 238 | 239 | // ImageAspectFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageAspectFlags.html 240 | type ImageAspectFlags Flags 241 | 242 | // ImageCompressionFixedRateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFixedRateFlagsEXT.html 243 | type ImageCompressionFixedRateFlagsEXT Flags 244 | 245 | // ImageCompressionFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFlagsEXT.html 246 | type ImageCompressionFlagsEXT Flags 247 | 248 | // ImageCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateFlags.html 249 | type ImageCreateFlags Flags 250 | 251 | // ImageUsageFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageUsageFlags.html 252 | type ImageUsageFlags Flags 253 | 254 | // ImageViewCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateFlags.html 255 | type ImageViewCreateFlags Flags 256 | 257 | // IndirectCommandsLayoutUsageFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutUsageFlagsNV.html 258 | type IndirectCommandsLayoutUsageFlagsNV Flags 259 | 260 | // IndirectStateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectStateFlagsNV.html 261 | type IndirectStateFlagsNV Flags 262 | 263 | // InstanceCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateFlags.html 264 | type InstanceCreateFlags Flags 265 | 266 | // MemoryAllocateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlags.html 267 | type MemoryAllocateFlags Flags 268 | 269 | // MemoryAllocateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsKHR.html 270 | type MemoryAllocateFlagsKHR = MemoryAllocateFlags 271 | 272 | // MemoryDecompressionMethodFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDecompressionMethodFlagsNV.html 273 | type MemoryDecompressionMethodFlagsNV Flags64 274 | 275 | // MemoryHeapFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeapFlags.html 276 | type MemoryHeapFlags Flags 277 | 278 | // MemoryMapFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html 279 | type MemoryMapFlags Flags 280 | 281 | // MemoryPropertyFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPropertyFlags.html 282 | type MemoryPropertyFlags Flags 283 | 284 | // MemoryUnmapFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapFlagsKHR.html 285 | type MemoryUnmapFlagsKHR Flags 286 | 287 | // MicromapCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateFlagsEXT.html 288 | type MicromapCreateFlagsEXT Flags 289 | 290 | // OpticalFlowExecuteFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteFlagsNV.html 291 | type OpticalFlowExecuteFlagsNV Flags 292 | 293 | // OpticalFlowGridSizeFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowGridSizeFlagsNV.html 294 | type OpticalFlowGridSizeFlagsNV Flags 295 | 296 | // OpticalFlowSessionCreateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateFlagsNV.html 297 | type OpticalFlowSessionCreateFlagsNV Flags 298 | 299 | // OpticalFlowUsageFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowUsageFlagsNV.html 300 | type OpticalFlowUsageFlagsNV Flags 301 | 302 | // PeerMemoryFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPeerMemoryFeatureFlags.html 303 | type PeerMemoryFeatureFlags Flags 304 | 305 | // PeerMemoryFeatureFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPeerMemoryFeatureFlagsKHR.html 306 | type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags 307 | 308 | // PerformanceCounterDescriptionFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionFlagsKHR.html 309 | type PerformanceCounterDescriptionFlagsKHR Flags 310 | 311 | // PhysicalDeviceSchedulingControlsFlagsARM: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSchedulingControlsFlagsARM.html 312 | type PhysicalDeviceSchedulingControlsFlagsARM Flags64 313 | 314 | // PipelineCacheCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateFlags.html 315 | type PipelineCacheCreateFlags Flags 316 | 317 | // PipelineColorBlendStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html 318 | type PipelineColorBlendStateCreateFlags Flags 319 | 320 | // PipelineCompilerControlFlagsAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlFlagsAMD.html 321 | type PipelineCompilerControlFlagsAMD Flags 322 | 323 | // PipelineCoverageModulationStateCreateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html 324 | type PipelineCoverageModulationStateCreateFlagsNV Flags 325 | 326 | // PipelineCoverageReductionStateCreateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html 327 | type PipelineCoverageReductionStateCreateFlagsNV Flags 328 | 329 | // PipelineCoverageToColorStateCreateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html 330 | type PipelineCoverageToColorStateCreateFlagsNV Flags 331 | 332 | // PipelineCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlags.html 333 | type PipelineCreateFlags Flags 334 | 335 | // PipelineCreateFlags2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlags2KHR.html 336 | type PipelineCreateFlags2KHR Flags64 337 | 338 | // PipelineCreationFeedbackFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackFlags.html 339 | type PipelineCreationFeedbackFlags Flags 340 | 341 | // PipelineCreationFeedbackFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackFlagsEXT.html 342 | type PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags 343 | 344 | // PipelineDepthStencilStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html 345 | type PipelineDepthStencilStateCreateFlags Flags 346 | 347 | // PipelineDiscardRectangleStateCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html 348 | type PipelineDiscardRectangleStateCreateFlagsEXT Flags 349 | 350 | // PipelineDynamicStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html 351 | type PipelineDynamicStateCreateFlags Flags 352 | 353 | // PipelineInputAssemblyStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html 354 | type PipelineInputAssemblyStateCreateFlags Flags 355 | 356 | // PipelineLayoutCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateFlags.html 357 | type PipelineLayoutCreateFlags Flags 358 | 359 | // PipelineMultisampleStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html 360 | type PipelineMultisampleStateCreateFlags Flags 361 | 362 | // PipelineRasterizationConservativeStateCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html 363 | type PipelineRasterizationConservativeStateCreateFlagsEXT Flags 364 | 365 | // PipelineRasterizationDepthClipStateCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html 366 | type PipelineRasterizationDepthClipStateCreateFlagsEXT Flags 367 | 368 | // PipelineRasterizationStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html 369 | type PipelineRasterizationStateCreateFlags Flags 370 | 371 | // PipelineRasterizationStateStreamCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html 372 | type PipelineRasterizationStateStreamCreateFlagsEXT Flags 373 | 374 | // PipelineShaderStageCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateFlags.html 375 | type PipelineShaderStageCreateFlags Flags 376 | 377 | // PipelineStageFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlags.html 378 | type PipelineStageFlags Flags 379 | 380 | // PipelineStageFlags2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlags2.html 381 | type PipelineStageFlags2 Flags64 382 | 383 | // PipelineStageFlags2KHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlags2KHR.html 384 | type PipelineStageFlags2KHR = PipelineStageFlags2 385 | 386 | // PipelineTessellationStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html 387 | type PipelineTessellationStateCreateFlags Flags 388 | 389 | // PipelineVertexInputStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html 390 | type PipelineVertexInputStateCreateFlags Flags 391 | 392 | // PipelineViewportStateCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html 393 | type PipelineViewportStateCreateFlags Flags 394 | 395 | // PipelineViewportSwizzleStateCreateFlagsNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html 396 | type PipelineViewportSwizzleStateCreateFlagsNV Flags 397 | 398 | // PresentGravityFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentGravityFlagsEXT.html 399 | type PresentGravityFlagsEXT Flags 400 | 401 | // PresentScalingFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagsEXT.html 402 | type PresentScalingFlagsEXT Flags 403 | 404 | // PrivateDataSlotCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateFlags.html 405 | type PrivateDataSlotCreateFlags Flags 406 | 407 | // PrivateDataSlotCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateFlagsEXT.html 408 | type PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags 409 | 410 | // QueryControlFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryControlFlags.html 411 | type QueryControlFlags Flags 412 | 413 | // QueryPipelineStatisticFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPipelineStatisticFlags.html 414 | type QueryPipelineStatisticFlags Flags 415 | 416 | // QueryPoolCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html 417 | type QueryPoolCreateFlags Flags 418 | 419 | // QueryResultFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultFlags.html 420 | type QueryResultFlags Flags 421 | 422 | // QueueFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFlags.html 423 | type QueueFlags Flags 424 | 425 | // RefreshObjectFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshObjectFlagsKHR.html 426 | type RefreshObjectFlagsKHR Flags 427 | 428 | // RenderPassCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateFlags.html 429 | type RenderPassCreateFlags Flags 430 | 431 | // RenderingFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFlags.html 432 | type RenderingFlags Flags 433 | 434 | // RenderingFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFlagsKHR.html 435 | type RenderingFlagsKHR = RenderingFlags 436 | 437 | // ResolveModeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveModeFlags.html 438 | type ResolveModeFlags Flags 439 | 440 | // ResolveModeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveModeFlagsKHR.html 441 | type ResolveModeFlagsKHR = ResolveModeFlags 442 | 443 | // SampleCountFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleCountFlags.html 444 | type SampleCountFlags Flags 445 | 446 | // SamplerCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateFlags.html 447 | type SamplerCreateFlags Flags 448 | 449 | // SemaphoreCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateFlags.html 450 | type SemaphoreCreateFlags Flags 451 | 452 | // SemaphoreImportFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreImportFlags.html 453 | type SemaphoreImportFlags Flags 454 | 455 | // SemaphoreImportFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreImportFlagsKHR.html 456 | type SemaphoreImportFlagsKHR = SemaphoreImportFlags 457 | 458 | // SemaphoreWaitFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitFlags.html 459 | type SemaphoreWaitFlags Flags 460 | 461 | // SemaphoreWaitFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitFlagsKHR.html 462 | type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags 463 | 464 | // ShaderCorePropertiesFlagsAMD: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCorePropertiesFlagsAMD.html 465 | type ShaderCorePropertiesFlagsAMD Flags 466 | 467 | // ShaderCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateFlagsEXT.html 468 | type ShaderCreateFlagsEXT Flags 469 | 470 | // ShaderModuleCreateFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateFlags.html 471 | type ShaderModuleCreateFlags Flags 472 | 473 | // ShaderStageFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStageFlags.html 474 | type ShaderStageFlags Flags 475 | 476 | // SparseImageFormatFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatFlags.html 477 | type SparseImageFormatFlags Flags 478 | 479 | // SparseMemoryBindFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBindFlags.html 480 | type SparseMemoryBindFlags Flags 481 | 482 | // StencilFaceFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilFaceFlags.html 483 | type StencilFaceFlags Flags 484 | 485 | // SubgroupFeatureFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubgroupFeatureFlags.html 486 | type SubgroupFeatureFlags Flags 487 | 488 | // SubmitFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitFlags.html 489 | type SubmitFlags Flags 490 | 491 | // SubmitFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitFlagsKHR.html 492 | type SubmitFlagsKHR = SubmitFlags 493 | 494 | // SubpassDescriptionFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionFlags.html 495 | type SubpassDescriptionFlags Flags 496 | 497 | // SurfaceCounterFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCounterFlagsEXT.html 498 | type SurfaceCounterFlagsEXT Flags 499 | 500 | // SurfaceTransformFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceTransformFlagsKHR.html 501 | type SurfaceTransformFlagsKHR Flags 502 | 503 | // SwapchainCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateFlagsKHR.html 504 | type SwapchainCreateFlagsKHR Flags 505 | 506 | // ToolPurposeFlags: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkToolPurposeFlags.html 507 | type ToolPurposeFlags Flags 508 | 509 | // ToolPurposeFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkToolPurposeFlagsEXT.html 510 | type ToolPurposeFlagsEXT = ToolPurposeFlags 511 | 512 | // ValidationCacheCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html 513 | type ValidationCacheCreateFlagsEXT Flags 514 | 515 | // VideoBeginCodingFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html 516 | type VideoBeginCodingFlagsKHR Flags 517 | 518 | // VideoCapabilityFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilityFlagsKHR.html 519 | type VideoCapabilityFlagsKHR Flags 520 | 521 | // VideoChromaSubsamplingFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoChromaSubsamplingFlagsKHR.html 522 | type VideoChromaSubsamplingFlagsKHR Flags 523 | 524 | // VideoCodecOperationFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagsKHR.html 525 | type VideoCodecOperationFlagsKHR Flags 526 | 527 | // VideoCodingControlFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlFlagsKHR.html 528 | type VideoCodingControlFlagsKHR Flags 529 | 530 | // VideoComponentBitDepthFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoComponentBitDepthFlagsKHR.html 531 | type VideoComponentBitDepthFlagsKHR Flags 532 | 533 | // VideoDecodeCapabilityFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilityFlagsKHR.html 534 | type VideoDecodeCapabilityFlagsKHR Flags 535 | 536 | // VideoDecodeFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeFlagsKHR.html 537 | type VideoDecodeFlagsKHR Flags 538 | 539 | // VideoDecodeH264PictureLayoutFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagsKHR.html 540 | type VideoDecodeH264PictureLayoutFlagsKHR Flags 541 | 542 | // VideoDecodeUsageFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageFlagsKHR.html 543 | type VideoDecodeUsageFlagsKHR Flags 544 | 545 | // VideoEndCodingFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html 546 | type VideoEndCodingFlagsKHR Flags 547 | 548 | // VideoSessionCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateFlagsKHR.html 549 | type VideoSessionCreateFlagsKHR Flags 550 | 551 | // VideoSessionParametersCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateFlagsKHR.html 552 | type VideoSessionParametersCreateFlagsKHR Flags 553 | -------------------------------------------------------------------------------- /bitmask_macos.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.178609 -0500 EST m=+3.704057488. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // MacOSSurfaceCreateFlagsMVK: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html 6 | type MacOSSurfaceCreateFlagsMVK Flags 7 | -------------------------------------------------------------------------------- /bitmask_metal.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.937563 -0500 EST m=+3.463010520. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // ExportMetalObjectTypeFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectTypeFlagsEXT.html 6 | type ExportMetalObjectTypeFlagsEXT Flags 7 | 8 | // MetalSurfaceCreateFlagsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html 9 | type MetalSurfaceCreateFlagsEXT Flags 10 | -------------------------------------------------------------------------------- /bitmask_win32.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.047211 -0500 EST m=+3.572658855. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // Win32SurfaceCreateFlagsKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html 6 | type Win32SurfaceCreateFlagsKHR Flags 7 | -------------------------------------------------------------------------------- /command_macos.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.284361 -0500 EST m=+3.809810145. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import "unsafe" 7 | 8 | // CreateMacOSSurfaceMVK: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMacOSSurfaceMVK.html 9 | func CreateMacOSSurfaceMVK(instance Instance, createInfo *MacOSSurfaceCreateInfoMVK, allocator *AllocationCallbacks) (surface SurfaceKHR, r error) { 10 | // Parameter is a singular input, requires translation - createInfo 11 | var pCreateInfo *_vkMacOSSurfaceCreateInfoMVK 12 | if createInfo != nil { 13 | pCreateInfo = createInfo.Vulkanize() 14 | } 15 | 16 | // Parameter is a singular input, pass direct - allocator 17 | var pAllocator unsafe.Pointer 18 | if allocator != nil { 19 | pAllocator = unsafe.Pointer(allocator) 20 | } 21 | 22 | // surface is a binding-allocated single return value and will be populated by Vulkan 23 | ptr_pSurface := &surface 24 | 25 | r = Result(execTrampoline(vkCreateMacOSSurfaceMVK, uintptr(instance), uintptr(unsafe.Pointer(pCreateInfo)), uintptr(unsafe.Pointer(pAllocator)), uintptr(unsafe.Pointer(ptr_pSurface)))) 26 | 27 | if r == Result(0) { 28 | r = SUCCESS 29 | } 30 | return 31 | } 32 | 33 | var vkCreateMacOSSurfaceMVK = &vkCommand{"vkCreateMacOSSurfaceMVK", 4, true, nil} 34 | -------------------------------------------------------------------------------- /command_metal.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.831983 -0500 EST m=+3.357429502. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import "unsafe" 7 | 8 | // CreateMetalSurfaceEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMetalSurfaceEXT.html 9 | func CreateMetalSurfaceEXT(instance Instance, createInfo *MetalSurfaceCreateInfoEXT, allocator *AllocationCallbacks) (surface SurfaceKHR, r error) { 10 | // Parameter is a singular input, requires translation - createInfo 11 | var pCreateInfo *_vkMetalSurfaceCreateInfoEXT 12 | if createInfo != nil { 13 | pCreateInfo = createInfo.Vulkanize() 14 | } 15 | 16 | // Parameter is a singular input, pass direct - allocator 17 | var pAllocator unsafe.Pointer 18 | if allocator != nil { 19 | pAllocator = unsafe.Pointer(allocator) 20 | } 21 | 22 | // surface is a binding-allocated single return value and will be populated by Vulkan 23 | ptr_pSurface := &surface 24 | 25 | r = Result(execTrampoline(vkCreateMetalSurfaceEXT, uintptr(instance), uintptr(unsafe.Pointer(pCreateInfo)), uintptr(unsafe.Pointer(pAllocator)), uintptr(unsafe.Pointer(ptr_pSurface)))) 26 | 27 | if r == Result(0) { 28 | r = SUCCESS 29 | } 30 | return 31 | } 32 | 33 | var vkCreateMetalSurfaceEXT = &vkCommand{"vkCreateMetalSurfaceEXT", 4, true, nil} 34 | 35 | // ExportMetalObjectsEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkExportMetalObjectsEXT.html 36 | func ExportMetalObjectsEXT(device Device) (metalObjectsInfo ExportMetalObjectsInfoEXT) { 37 | // metalObjectsInfo is a binding-allocated single return value and will be populated by Vulkan, but requiring translation 38 | var pMetalObjectsInfo *_vkExportMetalObjectsInfoEXT = metalObjectsInfo.Vulkanize() 39 | 40 | execTrampoline(vkExportMetalObjectsEXT, uintptr(device), uintptr(unsafe.Pointer(pMetalObjectsInfo))) 41 | 42 | metalObjectsInfo = *(pMetalObjectsInfo.Goify()) 43 | return 44 | } 45 | 46 | var vkExportMetalObjectsEXT = &vkCommand{"vkExportMetalObjectsEXT", 2, true, nil} 47 | -------------------------------------------------------------------------------- /command_win32.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.949411 -0500 EST m=+3.474858711. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import ( 7 | "unsafe" 8 | 9 | "golang.org/x/sys/windows" 10 | ) 11 | 12 | // AcquireFullScreenExclusiveModeEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireFullScreenExclusiveModeEXT.html 13 | func AcquireFullScreenExclusiveModeEXT(device Device, swapchain SwapchainKHR) (r error) { 14 | 15 | r = Result(execTrampoline(vkAcquireFullScreenExclusiveModeEXT, uintptr(device), uintptr(swapchain))) 16 | 17 | if r == Result(0) { 18 | r = SUCCESS 19 | } 20 | return 21 | } 22 | 23 | var vkAcquireFullScreenExclusiveModeEXT = &vkCommand{"vkAcquireFullScreenExclusiveModeEXT", 2, true, nil} 24 | 25 | // AcquireWinrtDisplayNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireWinrtDisplayNV.html 26 | func AcquireWinrtDisplayNV(physicalDevice PhysicalDevice, display DisplayKHR) (r error) { 27 | 28 | r = Result(execTrampoline(vkAcquireWinrtDisplayNV, uintptr(physicalDevice), uintptr(display))) 29 | 30 | if r == Result(0) { 31 | r = SUCCESS 32 | } 33 | return 34 | } 35 | 36 | var vkAcquireWinrtDisplayNV = &vkCommand{"vkAcquireWinrtDisplayNV", 2, true, nil} 37 | 38 | // CreateWin32SurfaceKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateWin32SurfaceKHR.html 39 | func CreateWin32SurfaceKHR(instance Instance, createInfo *Win32SurfaceCreateInfoKHR, allocator *AllocationCallbacks) (surface SurfaceKHR, r error) { 40 | // Parameter is a singular input, requires translation - createInfo 41 | var pCreateInfo *_vkWin32SurfaceCreateInfoKHR 42 | if createInfo != nil { 43 | pCreateInfo = createInfo.Vulkanize() 44 | } 45 | 46 | // Parameter is a singular input, pass direct - allocator 47 | var pAllocator unsafe.Pointer 48 | if allocator != nil { 49 | pAllocator = unsafe.Pointer(allocator) 50 | } 51 | 52 | // surface is a binding-allocated single return value and will be populated by Vulkan 53 | ptr_pSurface := &surface 54 | 55 | r = Result(execTrampoline(vkCreateWin32SurfaceKHR, uintptr(instance), uintptr(unsafe.Pointer(pCreateInfo)), uintptr(unsafe.Pointer(pAllocator)), uintptr(unsafe.Pointer(ptr_pSurface)))) 56 | 57 | if r == Result(0) { 58 | r = SUCCESS 59 | } 60 | return 61 | } 62 | 63 | var vkCreateWin32SurfaceKHR = &vkCommand{"vkCreateWin32SurfaceKHR", 4, true, nil} 64 | 65 | // GetDeviceGroupSurfacePresentModes2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html 66 | func GetDeviceGroupSurfacePresentModes2EXT(device Device, surfaceInfo *PhysicalDeviceSurfaceInfo2KHR) (modes DeviceGroupPresentModeFlagsKHR, r error) { 67 | // Parameter is a singular input, requires translation - surfaceInfo 68 | var pSurfaceInfo *_vkPhysicalDeviceSurfaceInfo2KHR 69 | if surfaceInfo != nil { 70 | pSurfaceInfo = surfaceInfo.Vulkanize() 71 | } 72 | 73 | // modes is a binding-allocated single return value and will be populated by Vulkan 74 | ptr_pModes := &modes 75 | 76 | r = Result(execTrampoline(vkGetDeviceGroupSurfacePresentModes2EXT, uintptr(device), uintptr(unsafe.Pointer(pSurfaceInfo)), uintptr(unsafe.Pointer(ptr_pModes)))) 77 | 78 | if r == Result(0) { 79 | r = SUCCESS 80 | } 81 | return 82 | } 83 | 84 | var vkGetDeviceGroupSurfacePresentModes2EXT = &vkCommand{"vkGetDeviceGroupSurfacePresentModes2EXT", 3, true, nil} 85 | 86 | // GetFenceWin32HandleKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceWin32HandleKHR.html 87 | func GetFenceWin32HandleKHR(device Device, getWin32HandleInfo *FenceGetWin32HandleInfoKHR) (handle windows.Handle, r error) { 88 | // Parameter is a singular input, requires translation - getWin32HandleInfo 89 | var pGetWin32HandleInfo *_vkFenceGetWin32HandleInfoKHR 90 | if getWin32HandleInfo != nil { 91 | pGetWin32HandleInfo = getWin32HandleInfo.Vulkanize() 92 | } 93 | 94 | // handle is a binding-allocated single return value and will be populated by Vulkan 95 | ptr_pHandle := &handle 96 | 97 | r = Result(execTrampoline(vkGetFenceWin32HandleKHR, uintptr(device), uintptr(unsafe.Pointer(pGetWin32HandleInfo)), uintptr(unsafe.Pointer(ptr_pHandle)))) 98 | 99 | if r == Result(0) { 100 | r = SUCCESS 101 | } 102 | return 103 | } 104 | 105 | var vkGetFenceWin32HandleKHR = &vkCommand{"vkGetFenceWin32HandleKHR", 3, true, nil} 106 | 107 | // GetMemoryWin32HandleKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandleKHR.html 108 | func GetMemoryWin32HandleKHR(device Device, getWin32HandleInfo *MemoryGetWin32HandleInfoKHR) (handle windows.Handle, r error) { 109 | // Parameter is a singular input, requires translation - getWin32HandleInfo 110 | var pGetWin32HandleInfo *_vkMemoryGetWin32HandleInfoKHR 111 | if getWin32HandleInfo != nil { 112 | pGetWin32HandleInfo = getWin32HandleInfo.Vulkanize() 113 | } 114 | 115 | // handle is a binding-allocated single return value and will be populated by Vulkan 116 | ptr_pHandle := &handle 117 | 118 | r = Result(execTrampoline(vkGetMemoryWin32HandleKHR, uintptr(device), uintptr(unsafe.Pointer(pGetWin32HandleInfo)), uintptr(unsafe.Pointer(ptr_pHandle)))) 119 | 120 | if r == Result(0) { 121 | r = SUCCESS 122 | } 123 | return 124 | } 125 | 126 | var vkGetMemoryWin32HandleKHR = &vkCommand{"vkGetMemoryWin32HandleKHR", 3, true, nil} 127 | 128 | // GetMemoryWin32HandleNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandleNV.html 129 | func GetMemoryWin32HandleNV(device Device, memory DeviceMemory, handleType ExternalMemoryHandleTypeFlagsNV) (handle windows.Handle, r error) { 130 | // handle is a binding-allocated single return value and will be populated by Vulkan 131 | ptr_pHandle := &handle 132 | 133 | r = Result(execTrampoline(vkGetMemoryWin32HandleNV, uintptr(device), uintptr(memory), uintptr(handleType), uintptr(unsafe.Pointer(ptr_pHandle)))) 134 | 135 | if r == Result(0) { 136 | r = SUCCESS 137 | } 138 | return 139 | } 140 | 141 | var vkGetMemoryWin32HandleNV = &vkCommand{"vkGetMemoryWin32HandleNV", 4, true, nil} 142 | 143 | // GetMemoryWin32HandlePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandlePropertiesKHR.html 144 | func GetMemoryWin32HandlePropertiesKHR(device Device, handleType ExternalMemoryHandleTypeFlagBits, handle windows.Handle) (memoryWin32HandleProperties MemoryWin32HandlePropertiesKHR, r error) { 145 | // memoryWin32HandleProperties is a binding-allocated single return value and will be populated by Vulkan, but requiring translation 146 | var pMemoryWin32HandleProperties *_vkMemoryWin32HandlePropertiesKHR = memoryWin32HandleProperties.Vulkanize() 147 | 148 | r = Result(execTrampoline(vkGetMemoryWin32HandlePropertiesKHR, uintptr(device), uintptr(handleType), uintptr(handle), uintptr(unsafe.Pointer(pMemoryWin32HandleProperties)))) 149 | 150 | memoryWin32HandleProperties = *(pMemoryWin32HandleProperties.Goify()) 151 | if r == Result(0) { 152 | r = SUCCESS 153 | } 154 | return 155 | } 156 | 157 | var vkGetMemoryWin32HandlePropertiesKHR = &vkCommand{"vkGetMemoryWin32HandlePropertiesKHR", 4, true, nil} 158 | 159 | // GetPhysicalDeviceSurfacePresentModes2EXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html 160 | func GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice PhysicalDevice, surfaceInfo *PhysicalDeviceSurfaceInfo2KHR) (presentModes []PresentModeKHR, r error) { 161 | // Parameter is a singular input, requires translation - surfaceInfo 162 | var pSurfaceInfo *_vkPhysicalDeviceSurfaceInfo2KHR 163 | if surfaceInfo != nil { 164 | pSurfaceInfo = surfaceInfo.Vulkanize() 165 | } 166 | 167 | // presentModes is a double-call array output 168 | var presentModeCount uint32 169 | pPresentModeCount := &presentModeCount 170 | // first trampoline happens here; also, still need to check returned Result value 171 | // NOT identical internal and external, result needs translation 172 | var pPresentModes *PresentModeKHR 173 | 174 | r = Result(execTrampoline(vkGetPhysicalDeviceSurfacePresentModes2EXT, uintptr(physicalDevice), uintptr(unsafe.Pointer(pSurfaceInfo)), uintptr(unsafe.Pointer(pPresentModeCount)), uintptr(unsafe.Pointer(pPresentModes)))) 175 | 176 | sl_pPresentModes := make([]PresentModeKHR, presentModeCount) 177 | presentModes = make([]PresentModeKHR, presentModeCount) 178 | pPresentModes = &sl_pPresentModes[0] 179 | 180 | // Trampoline call after last array allocation 181 | r = Result(execTrampoline(vkGetPhysicalDeviceSurfacePresentModes2EXT, uintptr(physicalDevice), uintptr(unsafe.Pointer(pSurfaceInfo)), uintptr(unsafe.Pointer(pPresentModeCount)), uintptr(unsafe.Pointer(pPresentModes)))) 182 | 183 | for i := range sl_pPresentModes { 184 | presentModes[i] = *&sl_pPresentModes[i] 185 | } 186 | if r == Result(0) { 187 | r = SUCCESS 188 | } 189 | return 190 | } 191 | 192 | var vkGetPhysicalDeviceSurfacePresentModes2EXT = &vkCommand{"vkGetPhysicalDeviceSurfacePresentModes2EXT", 4, true, nil} 193 | 194 | // GetPhysicalDeviceWin32PresentationSupportKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html 195 | func GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice PhysicalDevice, queueFamilyIndex uint32) (r bool) { 196 | 197 | rval := Bool32(execTrampoline(vkGetPhysicalDeviceWin32PresentationSupportKHR, uintptr(physicalDevice), uintptr(queueFamilyIndex))) 198 | r = translatePublic_Bool32(rval) 199 | 200 | return 201 | } 202 | 203 | var vkGetPhysicalDeviceWin32PresentationSupportKHR = &vkCommand{"vkGetPhysicalDeviceWin32PresentationSupportKHR", 2, true, nil} 204 | 205 | // GetSemaphoreWin32HandleKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreWin32HandleKHR.html 206 | func GetSemaphoreWin32HandleKHR(device Device, getWin32HandleInfo *SemaphoreGetWin32HandleInfoKHR) (handle windows.Handle, r error) { 207 | // Parameter is a singular input, requires translation - getWin32HandleInfo 208 | var pGetWin32HandleInfo *_vkSemaphoreGetWin32HandleInfoKHR 209 | if getWin32HandleInfo != nil { 210 | pGetWin32HandleInfo = getWin32HandleInfo.Vulkanize() 211 | } 212 | 213 | // handle is a binding-allocated single return value and will be populated by Vulkan 214 | ptr_pHandle := &handle 215 | 216 | r = Result(execTrampoline(vkGetSemaphoreWin32HandleKHR, uintptr(device), uintptr(unsafe.Pointer(pGetWin32HandleInfo)), uintptr(unsafe.Pointer(ptr_pHandle)))) 217 | 218 | if r == Result(0) { 219 | r = SUCCESS 220 | } 221 | return 222 | } 223 | 224 | var vkGetSemaphoreWin32HandleKHR = &vkCommand{"vkGetSemaphoreWin32HandleKHR", 3, true, nil} 225 | 226 | // GetWinrtDisplayNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetWinrtDisplayNV.html 227 | func GetWinrtDisplayNV(physicalDevice PhysicalDevice, deviceRelativeId uint32) (display DisplayKHR, r error) { 228 | // display is a binding-allocated single return value and will be populated by Vulkan 229 | ptr_pDisplay := &display 230 | 231 | r = Result(execTrampoline(vkGetWinrtDisplayNV, uintptr(physicalDevice), uintptr(deviceRelativeId), uintptr(unsafe.Pointer(ptr_pDisplay)))) 232 | 233 | if r == Result(0) { 234 | r = SUCCESS 235 | } 236 | return 237 | } 238 | 239 | var vkGetWinrtDisplayNV = &vkCommand{"vkGetWinrtDisplayNV", 3, true, nil} 240 | 241 | // ImportFenceWin32HandleKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportFenceWin32HandleKHR.html 242 | func ImportFenceWin32HandleKHR(device Device, importFenceWin32HandleInfo *ImportFenceWin32HandleInfoKHR) (r error) { 243 | // Parameter is a singular input, requires translation - importFenceWin32HandleInfo 244 | var pImportFenceWin32HandleInfo *_vkImportFenceWin32HandleInfoKHR 245 | if importFenceWin32HandleInfo != nil { 246 | pImportFenceWin32HandleInfo = importFenceWin32HandleInfo.Vulkanize() 247 | } 248 | 249 | r = Result(execTrampoline(vkImportFenceWin32HandleKHR, uintptr(device), uintptr(unsafe.Pointer(pImportFenceWin32HandleInfo)))) 250 | 251 | if r == Result(0) { 252 | r = SUCCESS 253 | } 254 | return 255 | } 256 | 257 | var vkImportFenceWin32HandleKHR = &vkCommand{"vkImportFenceWin32HandleKHR", 2, true, nil} 258 | 259 | // ImportSemaphoreWin32HandleKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportSemaphoreWin32HandleKHR.html 260 | func ImportSemaphoreWin32HandleKHR(device Device, importSemaphoreWin32HandleInfo *ImportSemaphoreWin32HandleInfoKHR) (r error) { 261 | // Parameter is a singular input, requires translation - importSemaphoreWin32HandleInfo 262 | var pImportSemaphoreWin32HandleInfo *_vkImportSemaphoreWin32HandleInfoKHR 263 | if importSemaphoreWin32HandleInfo != nil { 264 | pImportSemaphoreWin32HandleInfo = importSemaphoreWin32HandleInfo.Vulkanize() 265 | } 266 | 267 | r = Result(execTrampoline(vkImportSemaphoreWin32HandleKHR, uintptr(device), uintptr(unsafe.Pointer(pImportSemaphoreWin32HandleInfo)))) 268 | 269 | if r == Result(0) { 270 | r = SUCCESS 271 | } 272 | return 273 | } 274 | 275 | var vkImportSemaphoreWin32HandleKHR = &vkCommand{"vkImportSemaphoreWin32HandleKHR", 2, true, nil} 276 | 277 | // ReleaseFullScreenExclusiveModeEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkReleaseFullScreenExclusiveModeEXT.html 278 | func ReleaseFullScreenExclusiveModeEXT(device Device, swapchain SwapchainKHR) (r error) { 279 | 280 | r = Result(execTrampoline(vkReleaseFullScreenExclusiveModeEXT, uintptr(device), uintptr(swapchain))) 281 | 282 | if r == Result(0) { 283 | r = SUCCESS 284 | } 285 | return 286 | } 287 | 288 | var vkReleaseFullScreenExclusiveModeEXT = &vkCommand{"vkReleaseFullScreenExclusiveModeEXT", 2, true, nil} 289 | -------------------------------------------------------------------------------- /define.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.126508 -0500 EST m=+2.651950186. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // API_VERSION: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION.html 6 | var API_VERSION = MAKE_API_VERSION(0, 1, 0, 0) 7 | 8 | // API_VERSION_1_0: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_0.html 9 | var API_VERSION_1_0 = MAKE_API_VERSION(0, 1, 0, 0) 10 | 11 | // API_VERSION_1_1: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_1.html 12 | var API_VERSION_1_1 = MAKE_API_VERSION(0, 1, 1, 0) 13 | 14 | // API_VERSION_1_2: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_2.html 15 | var API_VERSION_1_2 = MAKE_API_VERSION(0, 1, 2, 0) 16 | 17 | // API_VERSION_MAJOR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MAJOR.html 18 | var API_VERSION_MAJOR = apiVersionMajor 19 | 20 | // API_VERSION_MINOR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MINOR.html 21 | var API_VERSION_MINOR = apiVersionMinor 22 | 23 | // API_VERSION_PATCH: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_PATCH.html 24 | var API_VERSION_PATCH = apiVersionPatch 25 | 26 | // API_VERSION_VARIANT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_VARIANT.html 27 | var API_VERSION_VARIANT = apiVersionVariant 28 | 29 | // HEADER_VERSION: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION.html 30 | var HEADER_VERSION = uint32(270) 31 | 32 | // HEADER_VERSION_COMPLETE: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html 33 | var HEADER_VERSION_COMPLETE = MAKE_API_VERSION(0, 1, 3, HEADER_VERSION) 34 | 35 | // MAKE_API_VERSION: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_API_VERSION.html 36 | var MAKE_API_VERSION = makeApiVersion 37 | 38 | // MAKE_VERSION: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_VERSION.html 39 | var MAKE_VERSION = deprecatedMakeVersion 40 | 41 | // VERSION_MAJOR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MAJOR.html 42 | var VERSION_MAJOR = deprecatedVersionMajor 43 | 44 | // VERSION_MINOR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MINOR.html 45 | var VERSION_MINOR = deprecatedVersionMinor 46 | 47 | // VERSION_PATCH: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_PATCH.html 48 | var VERSION_PATCH = deprecatedVersionPatch 49 | -------------------------------------------------------------------------------- /dlload.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include "dlload.h" 5 | 6 | #ifndef _WIN32 7 | #include 8 | 9 | 10 | void* OpenLibrary(const char *name) { 11 | void* lib_handle = dlopen(name, RTLD_LOCAL|RTLD_LAZY); 12 | if (!lib_handle) { 13 | printf("Unable to load %s: %s\n", name, dlerror()); 14 | return NULL; 15 | } 16 | return lib_handle; 17 | } 18 | 19 | void CloseLibrary(void *lib_handle) { 20 | if (dlclose(lib_handle) != 0) { 21 | printf("Problem closing library: %s", dlerror()); 22 | } 23 | } 24 | 25 | void* SymbolFromName(void *lib_handle, const void *name) { 26 | return dlsym(lib_handle, (const char*) name); 27 | } 28 | 29 | 30 | #endif 31 | 32 | 33 | #ifdef _WIN32 34 | 35 | #include 36 | 37 | void* OpenLibrary(const char *name) { 38 | return LoadLibrary(name); 39 | } 40 | 41 | void* SymbolFromName(void *lib_handle, const void *name) { 42 | return GetProcAddress(lib_handle, name); 43 | } 44 | 45 | void CloseLibrary(void *lib_handle) { 46 | FreeLibrary(lib_handle); 47 | } 48 | 49 | 50 | #endif 51 | 52 | typedef size_t (*vkGeneric_func3)(uintptr_t, uintptr_t, uintptr_t); 53 | typedef size_t (*vkGeneric_func6)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); 54 | typedef size_t (*vkGeneric_func9)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); 55 | typedef size_t (*vkGeneric_func12)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); 56 | 57 | size_t Trampoline3(void *symbol, size_t p0, size_t p1, size_t p2) { 58 | return ((vkGeneric_func3) symbol)(p0, p1, p2); 59 | } 60 | size_t Trampoline6(void *symbol, size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5) { 61 | return ((vkGeneric_func6) symbol)(p0, p1, p2, p3, p4, p5); 62 | } 63 | size_t Trampoline9(void *symbol, size_t p0, size_t p1, size_t p2, size_t p3, size_t p4, size_t p5, size_t p6, size_t p7, size_t p8) { 64 | return ((vkGeneric_func9) symbol)(p0, p1, p2, p3, p4, p5, p6, p7, p8); 65 | } 66 | 67 | size_t Trampoline12(void *symbol, uintptr_t p0, uintptr_t p1, uintptr_t p2, uintptr_t p3, uintptr_t p4, uintptr_t p5, uintptr_t p6, uintptr_t p7, uintptr_t p8, uintptr_t p9, uintptr_t p10, uintptr_t p11) { 68 | return ((vkGeneric_func12) symbol)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); 69 | } 70 | -------------------------------------------------------------------------------- /dlload.h: -------------------------------------------------------------------------------- 1 | #ifndef __DLLOAD_H__ 2 | #define __DLLOAD_H__ 3 | 4 | #include 5 | 6 | void* OpenLibrary(const char *name); 7 | void CloseLibrary(void *lib_handle); 8 | 9 | size_t Trampoline3(void *symbol, uintptr_t p0, uintptr_t p1, uintptr_t p2); 10 | size_t Trampoline6(void *symbol, uintptr_t p0, uintptr_t p1, uintptr_t p2, uintptr_t p3, uintptr_t p4, uintptr_t p5); 11 | size_t Trampoline9(void *symbol, uintptr_t p0, uintptr_t p1, uintptr_t p2, uintptr_t p3, uintptr_t p4, uintptr_t p5, uintptr_t p6, uintptr_t p7, uintptr_t p8); 12 | size_t Trampoline12(void *symbol, uintptr_t p0, uintptr_t p1, uintptr_t p2, uintptr_t p3, uintptr_t p4, uintptr_t p5, uintptr_t p6, uintptr_t p7, uintptr_t p8, uintptr_t p9, uintptr_t p10, uintptr_t p11); 13 | 14 | void* SymbolFromName(void *lib_handle, const void *name); 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /enum_macos.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.379158 -0500 EST m=+3.904608319. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // Platform-specific values for VkStructureType 6 | const ( 7 | STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK StructureType = 1000123000 8 | ) 9 | -------------------------------------------------------------------------------- /enum_metal.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.927145 -0500 EST m=+3.452591969. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | //go:generate stringer -output=enum_metal_string_0.go -type=ExportMetalObjectTypeFlagBitsEXT 6 | type ExportMetalObjectTypeFlagBitsEXT = ExportMetalObjectTypeFlagsEXT 7 | 8 | const ( 9 | EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 0 10 | EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 1 11 | EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 2 12 | EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 3 13 | EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 4 14 | EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT ExportMetalObjectTypeFlagBitsEXT = 1 << 5 15 | ) 16 | 17 | // Platform-specific values for VkStructureType 18 | const ( 19 | STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT StructureType = 1000217000 20 | STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT StructureType = 1000311000 21 | STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT StructureType = 1000311001 22 | STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT StructureType = 1000311002 23 | STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT StructureType = 1000311003 24 | STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT StructureType = 1000311004 25 | STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT StructureType = 1000311005 26 | STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT StructureType = 1000311006 27 | STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT StructureType = 1000311007 28 | STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT StructureType = 1000311008 29 | STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT StructureType = 1000311009 30 | STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT StructureType = 1000311010 31 | STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT StructureType = 1000311011 32 | ) 33 | -------------------------------------------------------------------------------- /enum_metal_string_0.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -output=enum_metal_string_0.go -type=ExportMetalObjectTypeFlagBitsEXT"; DO NOT EDIT. 2 | 3 | package vk 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT-1] 12 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT-2] 13 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT-4] 14 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT-8] 15 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT-16] 16 | _ = x[EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT-32] 17 | } 18 | 19 | const ( 20 | _ExportMetalObjectTypeFlagBitsEXT_name_0 = "EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXTEXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT" 21 | _ExportMetalObjectTypeFlagBitsEXT_name_1 = "EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT" 22 | _ExportMetalObjectTypeFlagBitsEXT_name_2 = "EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT" 23 | _ExportMetalObjectTypeFlagBitsEXT_name_3 = "EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT" 24 | _ExportMetalObjectTypeFlagBitsEXT_name_4 = "EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT" 25 | ) 26 | 27 | var ( 28 | _ExportMetalObjectTypeFlagBitsEXT_index_0 = [...]uint8{0, 45, 97} 29 | ) 30 | 31 | func (i ExportMetalObjectTypeFlagBitsEXT) String() string { 32 | switch { 33 | case 1 <= i && i <= 2: 34 | i -= 1 35 | return _ExportMetalObjectTypeFlagBitsEXT_name_0[_ExportMetalObjectTypeFlagBitsEXT_index_0[i]:_ExportMetalObjectTypeFlagBitsEXT_index_0[i+1]] 36 | case i == 4: 37 | return _ExportMetalObjectTypeFlagBitsEXT_name_1 38 | case i == 8: 39 | return _ExportMetalObjectTypeFlagBitsEXT_name_2 40 | case i == 16: 41 | return _ExportMetalObjectTypeFlagBitsEXT_name_3 42 | case i == 32: 43 | return _ExportMetalObjectTypeFlagBitsEXT_name_4 44 | default: 45 | return "ExportMetalObjectTypeFlagBitsEXT(" + strconv.FormatInt(int64(i), 10) + ")" 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /enum_string_7.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -output=enum_string_7.go -type=ToolPurposeFlagBits,ValidationCacheHeaderVersionEXT,ValidationCheckEXT,ValidationFeatureDisableEXT,ValidationFeatureEnableEXT,VendorId,VertexInputRate,VideoCapabilityFlagBitsKHR,VideoChromaSubsamplingFlagBitsKHR,VideoCodecOperationFlagBitsKHR,VideoCodingControlFlagBitsKHR,VideoComponentBitDepthFlagBitsKHR,VideoDecodeCapabilityFlagBitsKHR,VideoDecodeH264PictureLayoutFlagBitsKHR,VideoDecodeUsageFlagBitsKHR,VideoSessionCreateFlagBitsKHR,ViewportCoordinateSwizzleNV"; DO NOT EDIT. 2 | 3 | package vk 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[TOOL_PURPOSE_VALIDATION_BIT-1] 12 | _ = x[TOOL_PURPOSE_PROFILING_BIT-2] 13 | _ = x[TOOL_PURPOSE_TRACING_BIT-4] 14 | _ = x[TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT-8] 15 | _ = x[TOOL_PURPOSE_MODIFYING_FEATURES_BIT-16] 16 | _ = x[TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT-1000245000] 17 | _ = x[TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT-1000245000] 18 | _ = x[TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT-8] 19 | _ = x[TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT-16] 20 | _ = x[TOOL_PURPOSE_PROFILING_BIT_EXT-2] 21 | _ = x[TOOL_PURPOSE_TRACING_BIT_EXT-4] 22 | _ = x[TOOL_PURPOSE_VALIDATION_BIT_EXT-1] 23 | } 24 | 25 | const ( 26 | _ToolPurposeFlagBits_name_0 = "TOOL_PURPOSE_VALIDATION_BITTOOL_PURPOSE_PROFILING_BIT" 27 | _ToolPurposeFlagBits_name_1 = "TOOL_PURPOSE_TRACING_BIT" 28 | _ToolPurposeFlagBits_name_2 = "TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT" 29 | _ToolPurposeFlagBits_name_3 = "TOOL_PURPOSE_MODIFYING_FEATURES_BIT" 30 | _ToolPurposeFlagBits_name_4 = "TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT" 31 | ) 32 | 33 | var ( 34 | _ToolPurposeFlagBits_index_0 = [...]uint8{0, 27, 53} 35 | ) 36 | 37 | func (i ToolPurposeFlagBits) String() string { 38 | switch { 39 | case 1 <= i && i <= 2: 40 | i -= 1 41 | return _ToolPurposeFlagBits_name_0[_ToolPurposeFlagBits_index_0[i]:_ToolPurposeFlagBits_index_0[i+1]] 42 | case i == 4: 43 | return _ToolPurposeFlagBits_name_1 44 | case i == 8: 45 | return _ToolPurposeFlagBits_name_2 46 | case i == 16: 47 | return _ToolPurposeFlagBits_name_3 48 | case i == 1000245000: 49 | return _ToolPurposeFlagBits_name_4 50 | default: 51 | return "ToolPurposeFlagBits(" + strconv.FormatInt(int64(i), 10) + ")" 52 | } 53 | } 54 | func _() { 55 | // An "invalid array index" compiler error signifies that the constant values have changed. 56 | // Re-run the stringer command to generate them again. 57 | var x [1]struct{} 58 | _ = x[VALIDATION_CACHE_HEADER_VERSION_ONE_EXT-1] 59 | } 60 | 61 | const _ValidationCacheHeaderVersionEXT_name = "VALIDATION_CACHE_HEADER_VERSION_ONE_EXT" 62 | 63 | var _ValidationCacheHeaderVersionEXT_index = [...]uint8{0, 39} 64 | 65 | func (i ValidationCacheHeaderVersionEXT) String() string { 66 | i -= 1 67 | if i < 0 || i >= ValidationCacheHeaderVersionEXT(len(_ValidationCacheHeaderVersionEXT_index)-1) { 68 | return "ValidationCacheHeaderVersionEXT(" + strconv.FormatInt(int64(i+1), 10) + ")" 69 | } 70 | return _ValidationCacheHeaderVersionEXT_name[_ValidationCacheHeaderVersionEXT_index[i]:_ValidationCacheHeaderVersionEXT_index[i+1]] 71 | } 72 | func _() { 73 | // An "invalid array index" compiler error signifies that the constant values have changed. 74 | // Re-run the stringer command to generate them again. 75 | var x [1]struct{} 76 | _ = x[VALIDATION_CHECK_ALL_EXT-0] 77 | _ = x[VALIDATION_CHECK_SHADERS_EXT-1] 78 | } 79 | 80 | const _ValidationCheckEXT_name = "VALIDATION_CHECK_ALL_EXTVALIDATION_CHECK_SHADERS_EXT" 81 | 82 | var _ValidationCheckEXT_index = [...]uint8{0, 24, 52} 83 | 84 | func (i ValidationCheckEXT) String() string { 85 | if i < 0 || i >= ValidationCheckEXT(len(_ValidationCheckEXT_index)-1) { 86 | return "ValidationCheckEXT(" + strconv.FormatInt(int64(i), 10) + ")" 87 | } 88 | return _ValidationCheckEXT_name[_ValidationCheckEXT_index[i]:_ValidationCheckEXT_index[i+1]] 89 | } 90 | func _() { 91 | // An "invalid array index" compiler error signifies that the constant values have changed. 92 | // Re-run the stringer command to generate them again. 93 | var x [1]struct{} 94 | _ = x[VALIDATION_FEATURE_DISABLE_ALL_EXT-0] 95 | _ = x[VALIDATION_FEATURE_DISABLE_SHADERS_EXT-1] 96 | _ = x[VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT-2] 97 | _ = x[VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT-3] 98 | _ = x[VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT-4] 99 | _ = x[VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT-5] 100 | _ = x[VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT-6] 101 | _ = x[VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT-7] 102 | } 103 | 104 | const _ValidationFeatureDisableEXT_name = "VALIDATION_FEATURE_DISABLE_ALL_EXTVALIDATION_FEATURE_DISABLE_SHADERS_EXTVALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXTVALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXTVALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXTVALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXTVALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXTVALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT" 105 | 106 | var _ValidationFeatureDisableEXT_index = [...]uint16{0, 34, 72, 116, 161, 208, 250, 295, 349} 107 | 108 | func (i ValidationFeatureDisableEXT) String() string { 109 | if i < 0 || i >= ValidationFeatureDisableEXT(len(_ValidationFeatureDisableEXT_index)-1) { 110 | return "ValidationFeatureDisableEXT(" + strconv.FormatInt(int64(i), 10) + ")" 111 | } 112 | return _ValidationFeatureDisableEXT_name[_ValidationFeatureDisableEXT_index[i]:_ValidationFeatureDisableEXT_index[i+1]] 113 | } 114 | func _() { 115 | // An "invalid array index" compiler error signifies that the constant values have changed. 116 | // Re-run the stringer command to generate them again. 117 | var x [1]struct{} 118 | _ = x[VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT-0] 119 | _ = x[VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT-1] 120 | _ = x[VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT-2] 121 | _ = x[VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT-3] 122 | _ = x[VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT-4] 123 | } 124 | 125 | const _ValidationFeatureEnableEXT_name = "VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXTVALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXTVALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXTVALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXTVALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT" 126 | 127 | var _ValidationFeatureEnableEXT_index = [...]uint8{0, 42, 105, 149, 191, 247} 128 | 129 | func (i ValidationFeatureEnableEXT) String() string { 130 | if i < 0 || i >= ValidationFeatureEnableEXT(len(_ValidationFeatureEnableEXT_index)-1) { 131 | return "ValidationFeatureEnableEXT(" + strconv.FormatInt(int64(i), 10) + ")" 132 | } 133 | return _ValidationFeatureEnableEXT_name[_ValidationFeatureEnableEXT_index[i]:_ValidationFeatureEnableEXT_index[i+1]] 134 | } 135 | func _() { 136 | // An "invalid array index" compiler error signifies that the constant values have changed. 137 | // Re-run the stringer command to generate them again. 138 | var x [1]struct{} 139 | _ = x[VENDOR_ID_VIV-65537] 140 | _ = x[VENDOR_ID_VSI-65538] 141 | _ = x[VENDOR_ID_KAZAN-65539] 142 | _ = x[VENDOR_ID_CODEPLAY-65540] 143 | _ = x[VENDOR_ID_MESA-65541] 144 | _ = x[VENDOR_ID_POCL-65542] 145 | _ = x[VENDOR_ID_MOBILEYE-65543] 146 | } 147 | 148 | const _VendorId_name = "VENDOR_ID_VIVVENDOR_ID_VSIVENDOR_ID_KAZANVENDOR_ID_CODEPLAYVENDOR_ID_MESAVENDOR_ID_POCLVENDOR_ID_MOBILEYE" 149 | 150 | var _VendorId_index = [...]uint8{0, 13, 26, 41, 59, 73, 87, 105} 151 | 152 | func (i VendorId) String() string { 153 | i -= 65537 154 | if i < 0 || i >= VendorId(len(_VendorId_index)-1) { 155 | return "VendorId(" + strconv.FormatInt(int64(i+65537), 10) + ")" 156 | } 157 | return _VendorId_name[_VendorId_index[i]:_VendorId_index[i+1]] 158 | } 159 | func _() { 160 | // An "invalid array index" compiler error signifies that the constant values have changed. 161 | // Re-run the stringer command to generate them again. 162 | var x [1]struct{} 163 | _ = x[VERTEX_INPUT_RATE_VERTEX-0] 164 | _ = x[VERTEX_INPUT_RATE_INSTANCE-1] 165 | } 166 | 167 | const _VertexInputRate_name = "VERTEX_INPUT_RATE_VERTEXVERTEX_INPUT_RATE_INSTANCE" 168 | 169 | var _VertexInputRate_index = [...]uint8{0, 24, 50} 170 | 171 | func (i VertexInputRate) String() string { 172 | if i < 0 || i >= VertexInputRate(len(_VertexInputRate_index)-1) { 173 | return "VertexInputRate(" + strconv.FormatInt(int64(i), 10) + ")" 174 | } 175 | return _VertexInputRate_name[_VertexInputRate_index[i]:_VertexInputRate_index[i+1]] 176 | } 177 | func _() { 178 | // An "invalid array index" compiler error signifies that the constant values have changed. 179 | // Re-run the stringer command to generate them again. 180 | var x [1]struct{} 181 | _ = x[VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR-1] 182 | _ = x[VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR-2] 183 | } 184 | 185 | const _VideoCapabilityFlagBitsKHR_name = "VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHRVIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR" 186 | 187 | var _VideoCapabilityFlagBitsKHR_index = [...]uint8{0, 42, 92} 188 | 189 | func (i VideoCapabilityFlagBitsKHR) String() string { 190 | i -= 1 191 | if i >= VideoCapabilityFlagBitsKHR(len(_VideoCapabilityFlagBitsKHR_index)-1) { 192 | return "VideoCapabilityFlagBitsKHR(" + strconv.FormatInt(int64(i+1), 10) + ")" 193 | } 194 | return _VideoCapabilityFlagBitsKHR_name[_VideoCapabilityFlagBitsKHR_index[i]:_VideoCapabilityFlagBitsKHR_index[i+1]] 195 | } 196 | func _() { 197 | // An "invalid array index" compiler error signifies that the constant values have changed. 198 | // Re-run the stringer command to generate them again. 199 | var x [1]struct{} 200 | _ = x[VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR-0] 201 | _ = x[VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR-1] 202 | _ = x[VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR-2] 203 | _ = x[VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR-4] 204 | _ = x[VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR-8] 205 | } 206 | 207 | const ( 208 | _VideoChromaSubsamplingFlagBitsKHR_name_0 = "VIDEO_CHROMA_SUBSAMPLING_INVALID_KHRVIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHRVIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR" 209 | _VideoChromaSubsamplingFlagBitsKHR_name_1 = "VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR" 210 | _VideoChromaSubsamplingFlagBitsKHR_name_2 = "VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR" 211 | ) 212 | 213 | var ( 214 | _VideoChromaSubsamplingFlagBitsKHR_index_0 = [...]uint8{0, 36, 79, 115} 215 | ) 216 | 217 | func (i VideoChromaSubsamplingFlagBitsKHR) String() string { 218 | switch { 219 | case i <= 2: 220 | return _VideoChromaSubsamplingFlagBitsKHR_name_0[_VideoChromaSubsamplingFlagBitsKHR_index_0[i]:_VideoChromaSubsamplingFlagBitsKHR_index_0[i+1]] 221 | case i == 4: 222 | return _VideoChromaSubsamplingFlagBitsKHR_name_1 223 | case i == 8: 224 | return _VideoChromaSubsamplingFlagBitsKHR_name_2 225 | default: 226 | return "VideoChromaSubsamplingFlagBitsKHR(" + strconv.FormatInt(int64(i), 10) + ")" 227 | } 228 | } 229 | func _() { 230 | // An "invalid array index" compiler error signifies that the constant values have changed. 231 | // Re-run the stringer command to generate them again. 232 | var x [1]struct{} 233 | _ = x[VIDEO_CODEC_OPERATION_NONE_KHR-0] 234 | _ = x[VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR-1000040000] 235 | _ = x[VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR-1000187000] 236 | } 237 | 238 | const ( 239 | _VideoCodecOperationFlagBitsKHR_name_0 = "VIDEO_CODEC_OPERATION_NONE_KHR" 240 | _VideoCodecOperationFlagBitsKHR_name_1 = "VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR" 241 | _VideoCodecOperationFlagBitsKHR_name_2 = "VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR" 242 | ) 243 | 244 | func (i VideoCodecOperationFlagBitsKHR) String() string { 245 | switch { 246 | case i == 0: 247 | return _VideoCodecOperationFlagBitsKHR_name_0 248 | case i == 1000040000: 249 | return _VideoCodecOperationFlagBitsKHR_name_1 250 | case i == 1000187000: 251 | return _VideoCodecOperationFlagBitsKHR_name_2 252 | default: 253 | return "VideoCodecOperationFlagBitsKHR(" + strconv.FormatInt(int64(i), 10) + ")" 254 | } 255 | } 256 | func _() { 257 | // An "invalid array index" compiler error signifies that the constant values have changed. 258 | // Re-run the stringer command to generate them again. 259 | var x [1]struct{} 260 | _ = x[VIDEO_CODING_CONTROL_RESET_BIT_KHR-1] 261 | } 262 | 263 | const _VideoCodingControlFlagBitsKHR_name = "VIDEO_CODING_CONTROL_RESET_BIT_KHR" 264 | 265 | var _VideoCodingControlFlagBitsKHR_index = [...]uint8{0, 34} 266 | 267 | func (i VideoCodingControlFlagBitsKHR) String() string { 268 | i -= 1 269 | if i >= VideoCodingControlFlagBitsKHR(len(_VideoCodingControlFlagBitsKHR_index)-1) { 270 | return "VideoCodingControlFlagBitsKHR(" + strconv.FormatInt(int64(i+1), 10) + ")" 271 | } 272 | return _VideoCodingControlFlagBitsKHR_name[_VideoCodingControlFlagBitsKHR_index[i]:_VideoCodingControlFlagBitsKHR_index[i+1]] 273 | } 274 | func _() { 275 | // An "invalid array index" compiler error signifies that the constant values have changed. 276 | // Re-run the stringer command to generate them again. 277 | var x [1]struct{} 278 | _ = x[VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR-0] 279 | _ = x[VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR-1] 280 | _ = x[VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR-4] 281 | _ = x[VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR-16] 282 | } 283 | 284 | const ( 285 | _VideoComponentBitDepthFlagBitsKHR_name_0 = "VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHRVIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR" 286 | _VideoComponentBitDepthFlagBitsKHR_name_1 = "VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR" 287 | _VideoComponentBitDepthFlagBitsKHR_name_2 = "VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR" 288 | ) 289 | 290 | var ( 291 | _VideoComponentBitDepthFlagBitsKHR_index_0 = [...]uint8{0, 37, 72} 292 | ) 293 | 294 | func (i VideoComponentBitDepthFlagBitsKHR) String() string { 295 | switch { 296 | case i <= 1: 297 | return _VideoComponentBitDepthFlagBitsKHR_name_0[_VideoComponentBitDepthFlagBitsKHR_index_0[i]:_VideoComponentBitDepthFlagBitsKHR_index_0[i+1]] 298 | case i == 4: 299 | return _VideoComponentBitDepthFlagBitsKHR_name_1 300 | case i == 16: 301 | return _VideoComponentBitDepthFlagBitsKHR_name_2 302 | default: 303 | return "VideoComponentBitDepthFlagBitsKHR(" + strconv.FormatInt(int64(i), 10) + ")" 304 | } 305 | } 306 | func _() { 307 | // An "invalid array index" compiler error signifies that the constant values have changed. 308 | // Re-run the stringer command to generate them again. 309 | var x [1]struct{} 310 | _ = x[VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR-1] 311 | _ = x[VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR-2] 312 | } 313 | 314 | const _VideoDecodeCapabilityFlagBitsKHR_name = "VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHRVIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR" 315 | 316 | var _VideoDecodeCapabilityFlagBitsKHR_index = [...]uint8{0, 55, 110} 317 | 318 | func (i VideoDecodeCapabilityFlagBitsKHR) String() string { 319 | i -= 1 320 | if i >= VideoDecodeCapabilityFlagBitsKHR(len(_VideoDecodeCapabilityFlagBitsKHR_index)-1) { 321 | return "VideoDecodeCapabilityFlagBitsKHR(" + strconv.FormatInt(int64(i+1), 10) + ")" 322 | } 323 | return _VideoDecodeCapabilityFlagBitsKHR_name[_VideoDecodeCapabilityFlagBitsKHR_index[i]:_VideoDecodeCapabilityFlagBitsKHR_index[i+1]] 324 | } 325 | func _() { 326 | // An "invalid array index" compiler error signifies that the constant values have changed. 327 | // Re-run the stringer command to generate them again. 328 | var x [1]struct{} 329 | _ = x[VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR-0] 330 | _ = x[VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR-1] 331 | _ = x[VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR-2] 332 | } 333 | 334 | const _VideoDecodeH264PictureLayoutFlagBitsKHR_name = "VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHRVIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHRVIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR" 335 | 336 | var _VideoDecodeH264PictureLayoutFlagBitsKHR_index = [...]uint8{0, 48, 117, 184} 337 | 338 | func (i VideoDecodeH264PictureLayoutFlagBitsKHR) String() string { 339 | if i >= VideoDecodeH264PictureLayoutFlagBitsKHR(len(_VideoDecodeH264PictureLayoutFlagBitsKHR_index)-1) { 340 | return "VideoDecodeH264PictureLayoutFlagBitsKHR(" + strconv.FormatInt(int64(i), 10) + ")" 341 | } 342 | return _VideoDecodeH264PictureLayoutFlagBitsKHR_name[_VideoDecodeH264PictureLayoutFlagBitsKHR_index[i]:_VideoDecodeH264PictureLayoutFlagBitsKHR_index[i+1]] 343 | } 344 | func _() { 345 | // An "invalid array index" compiler error signifies that the constant values have changed. 346 | // Re-run the stringer command to generate them again. 347 | var x [1]struct{} 348 | _ = x[VIDEO_DECODE_USAGE_DEFAULT_KHR-0] 349 | _ = x[VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR-1] 350 | _ = x[VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR-2] 351 | _ = x[VIDEO_DECODE_USAGE_STREAMING_BIT_KHR-4] 352 | } 353 | 354 | const ( 355 | _VideoDecodeUsageFlagBitsKHR_name_0 = "VIDEO_DECODE_USAGE_DEFAULT_KHRVIDEO_DECODE_USAGE_TRANSCODING_BIT_KHRVIDEO_DECODE_USAGE_OFFLINE_BIT_KHR" 356 | _VideoDecodeUsageFlagBitsKHR_name_1 = "VIDEO_DECODE_USAGE_STREAMING_BIT_KHR" 357 | ) 358 | 359 | var ( 360 | _VideoDecodeUsageFlagBitsKHR_index_0 = [...]uint8{0, 30, 68, 102} 361 | ) 362 | 363 | func (i VideoDecodeUsageFlagBitsKHR) String() string { 364 | switch { 365 | case i <= 2: 366 | return _VideoDecodeUsageFlagBitsKHR_name_0[_VideoDecodeUsageFlagBitsKHR_index_0[i]:_VideoDecodeUsageFlagBitsKHR_index_0[i+1]] 367 | case i == 4: 368 | return _VideoDecodeUsageFlagBitsKHR_name_1 369 | default: 370 | return "VideoDecodeUsageFlagBitsKHR(" + strconv.FormatInt(int64(i), 10) + ")" 371 | } 372 | } 373 | func _() { 374 | // An "invalid array index" compiler error signifies that the constant values have changed. 375 | // Re-run the stringer command to generate them again. 376 | var x [1]struct{} 377 | _ = x[VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR-1] 378 | } 379 | 380 | const _VideoSessionCreateFlagBitsKHR_name = "VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR" 381 | 382 | var _VideoSessionCreateFlagBitsKHR_index = [...]uint8{0, 46} 383 | 384 | func (i VideoSessionCreateFlagBitsKHR) String() string { 385 | i -= 1 386 | if i >= VideoSessionCreateFlagBitsKHR(len(_VideoSessionCreateFlagBitsKHR_index)-1) { 387 | return "VideoSessionCreateFlagBitsKHR(" + strconv.FormatInt(int64(i+1), 10) + ")" 388 | } 389 | return _VideoSessionCreateFlagBitsKHR_name[_VideoSessionCreateFlagBitsKHR_index[i]:_VideoSessionCreateFlagBitsKHR_index[i+1]] 390 | } 391 | func _() { 392 | // An "invalid array index" compiler error signifies that the constant values have changed. 393 | // Re-run the stringer command to generate them again. 394 | var x [1]struct{} 395 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV-0] 396 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV-1] 397 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV-2] 398 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV-3] 399 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV-4] 400 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV-5] 401 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV-6] 402 | _ = x[VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV-7] 403 | } 404 | 405 | const _ViewportCoordinateSwizzleNV_name = "VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NVVIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NVVIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NVVIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NVVIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NVVIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NVVIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NVVIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV" 406 | 407 | var _ViewportCoordinateSwizzleNV_index = [...]uint16{0, 41, 82, 123, 164, 205, 246, 287, 328} 408 | 409 | func (i ViewportCoordinateSwizzleNV) String() string { 410 | if i < 0 || i >= ViewportCoordinateSwizzleNV(len(_ViewportCoordinateSwizzleNV_index)-1) { 411 | return "ViewportCoordinateSwizzleNV(" + strconv.FormatInt(int64(i), 10) + ")" 412 | } 413 | return _ViewportCoordinateSwizzleNV_name[_ViewportCoordinateSwizzleNV_index[i]:_ViewportCoordinateSwizzleNV_index[i+1]] 414 | } 415 | -------------------------------------------------------------------------------- /enum_win32.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.055108 -0500 EST m=+3.580555565. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | //go:generate stringer -output=enum_win32_string_0.go -type=FullScreenExclusiveEXT 6 | // FullScreenExclusiveEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFullScreenExclusiveEXT.html 7 | type FullScreenExclusiveEXT int32 8 | 9 | const ( 10 | FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT FullScreenExclusiveEXT = 0 11 | FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT FullScreenExclusiveEXT = 1 12 | FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT FullScreenExclusiveEXT = 2 13 | FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT FullScreenExclusiveEXT = 3 14 | ) 15 | 16 | // Platform-specific values for VkStructureType 17 | const ( 18 | STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR StructureType = 1000009000 19 | STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV StructureType = 1000057000 20 | STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV StructureType = 1000057001 21 | STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV StructureType = 1000058000 22 | STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR StructureType = 1000073000 23 | STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR StructureType = 1000073001 24 | STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR StructureType = 1000073002 25 | STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR StructureType = 1000073003 26 | STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR StructureType = 1000075000 27 | STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR StructureType = 1000078000 28 | STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR StructureType = 1000078001 29 | STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR StructureType = 1000078002 30 | STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR StructureType = 1000078003 31 | STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR StructureType = 1000114000 32 | STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR StructureType = 1000114001 33 | STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR StructureType = 1000114002 34 | STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT StructureType = 1000255000 35 | STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT StructureType = 1000255001 36 | STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT StructureType = 1000255002 37 | ) 38 | 39 | // Platform-specific values for VkResult 40 | const ( 41 | ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT Result = -1000255000 42 | ) 43 | -------------------------------------------------------------------------------- /enum_win32_string_0.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -output=enum_win32_string_0.go -type=FullScreenExclusiveEXT"; DO NOT EDIT. 2 | 3 | package vk 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT-0] 12 | _ = x[FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT-1] 13 | _ = x[FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT-2] 14 | _ = x[FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT-3] 15 | } 16 | 17 | const _FullScreenExclusiveEXT_name = "FULL_SCREEN_EXCLUSIVE_DEFAULT_EXTFULL_SCREEN_EXCLUSIVE_ALLOWED_EXTFULL_SCREEN_EXCLUSIVE_DISALLOWED_EXTFULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT" 18 | 19 | var _FullScreenExclusiveEXT_index = [...]uint8{0, 33, 66, 102, 150} 20 | 21 | func (i FullScreenExclusiveEXT) String() string { 22 | if i < 0 || i >= FullScreenExclusiveEXT(len(_FullScreenExclusiveEXT_index)-1) { 23 | return "FullScreenExclusiveEXT(" + strconv.FormatInt(int64(i), 10) + ")" 24 | } 25 | return _FullScreenExclusiveEXT_name[_FullScreenExclusiveEXT_index[i]:_FullScreenExclusiveEXT_index[i+1]] 26 | } 27 | -------------------------------------------------------------------------------- /exten_macos.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.386387 -0500 EST m=+3.911837579. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | // Extension names and versions 7 | const ( 8 | MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface" 9 | MVK_MACOS_SURFACE_SPEC_VERSION = 3 10 | ) 11 | -------------------------------------------------------------------------------- /exten_metal.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.63304 -0500 EST m=+3.158485251. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | // Extension names and versions 7 | const ( 8 | EXT_METAL_OBJECTS_EXTENSION_NAME = "VK_EXT_metal_objects" 9 | EXT_METAL_OBJECTS_SPEC_VERSION = 1 10 | EXT_METAL_SURFACE_EXTENSION_NAME = "VK_EXT_metal_surface" 11 | EXT_METAL_SURFACE_SPEC_VERSION = 1 12 | ) 13 | -------------------------------------------------------------------------------- /exten_win32.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.064033 -0500 EST m=+3.589481050. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | // Extension names and versions 7 | const ( 8 | EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME = "VK_EXT_full_screen_exclusive" 9 | EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION = 4 10 | KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME = "VK_KHR_external_fence_win32" 11 | KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION = 1 12 | KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHR_external_memory_win32" 13 | KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 14 | KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHR_external_semaphore_win32" 15 | KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1 16 | KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHR_win32_keyed_mutex" 17 | KHR_WIN32_KEYED_MUTEX_SPEC_VERSION = 1 18 | KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface" 19 | KHR_WIN32_SURFACE_SPEC_VERSION = 6 20 | NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME = "VK_NV_acquire_winrt_display" 21 | NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION = 1 22 | NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32" 23 | NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1 24 | NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex" 25 | NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 2 26 | ) 27 | -------------------------------------------------------------------------------- /external.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.281097 -0500 EST m=+2.806539829. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | const ( 6 | LOD_CLAMP_NONE float32 = 1000.0 7 | ) 8 | 9 | const ( 10 | FALSE uint32 = 0 11 | TRUE uint32 = 1 12 | LUID_SIZE uint32 = 8 13 | UUID_SIZE uint32 = 16 14 | MAX_GLOBAL_PRIORITY_SIZE_KHR uint32 = 16 15 | MAX_MEMORY_HEAPS uint32 = 16 // The maximum number of unique memory heaps, each of which supporting 1 or more memory types 16 | MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT uint32 = 32 17 | MAX_MEMORY_TYPES uint32 = 32 18 | MAX_DEVICE_GROUP_SIZE uint32 = 32 19 | MAX_EXTENSION_NAME_SIZE uint32 = 256 20 | MAX_DRIVER_NAME_SIZE uint32 = 256 21 | MAX_PHYSICAL_DEVICE_NAME_SIZE uint32 = 256 22 | MAX_DESCRIPTION_SIZE uint32 = 256 23 | MAX_DRIVER_INFO_SIZE uint32 = 256 24 | SHADER_UNUSED_KHR uint32 = ^uint32(0) 25 | QUEUE_FAMILY_IGNORED uint32 = ^uint32(0) 26 | REMAINING_MIP_LEVELS uint32 = ^uint32(0) 27 | SUBPASS_EXTERNAL uint32 = ^uint32(0) 28 | REMAINING_ARRAY_LAYERS uint32 = ^uint32(0) 29 | ATTACHMENT_UNUSED uint32 = ^uint32(0) 30 | REMAINING_3D_SLICES_EXT uint32 = ^uint32(0) 31 | SHADER_INDEX_UNUSED_AMDX uint32 = ^uint32(0) 32 | QUEUE_FAMILY_EXTERNAL uint32 = ^uint32(1) 33 | QUEUE_FAMILY_FOREIGN_EXT uint32 = ^uint32(2) 34 | ) 35 | 36 | const ( 37 | WHOLE_SIZE uint64 = ^uint64(0) 38 | ) 39 | 40 | // Extension names and versions 41 | const ( 42 | LUID_SIZE_KHR uint32 = LUID_SIZE 43 | MAX_DEVICE_GROUP_SIZE_KHR uint32 = MAX_DEVICE_GROUP_SIZE 44 | MAX_DRIVER_INFO_SIZE_KHR uint32 = MAX_DRIVER_INFO_SIZE 45 | MAX_DRIVER_NAME_SIZE_KHR uint32 = MAX_DRIVER_NAME_SIZE 46 | MAX_GLOBAL_PRIORITY_SIZE_EXT uint32 = MAX_GLOBAL_PRIORITY_SIZE_KHR 47 | QUEUE_FAMILY_EXTERNAL_KHR uint32 = QUEUE_FAMILY_EXTERNAL 48 | SHADER_UNUSED_NV uint32 = SHADER_UNUSED_KHR 49 | ) 50 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/bbredesen/go-vk 2 | 3 | go 1.18 4 | 5 | require golang.org/x/sys v0.6.0 6 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18= 2 | golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 3 | golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ= 4 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 5 | -------------------------------------------------------------------------------- /handle.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.273333 -0500 EST m=+2.798776048. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | // AccelerationStructureKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureKHR.html 6 | type AccelerationStructureKHR nonDispatchableHandle 7 | 8 | // AccelerationStructureNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureNV.html 9 | type AccelerationStructureNV nonDispatchableHandle 10 | 11 | // Buffer: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html 12 | type Buffer nonDispatchableHandle 13 | 14 | // BufferView: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html 15 | type BufferView nonDispatchableHandle 16 | 17 | // CommandBuffer: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html 18 | type CommandBuffer handle 19 | 20 | // CommandPool: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html 21 | type CommandPool nonDispatchableHandle 22 | 23 | // CuFunctionNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionNVX.html 24 | type CuFunctionNVX nonDispatchableHandle 25 | 26 | // CuModuleNVX: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleNVX.html 27 | type CuModuleNVX nonDispatchableHandle 28 | 29 | // CudaFunctionNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCudaFunctionNV.html 30 | type CudaFunctionNV nonDispatchableHandle 31 | 32 | // CudaModuleNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCudaModuleNV.html 33 | type CudaModuleNV nonDispatchableHandle 34 | 35 | // DebugReportCallbackEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackEXT.html 36 | type DebugReportCallbackEXT nonDispatchableHandle 37 | 38 | // DebugUtilsMessengerEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerEXT.html 39 | type DebugUtilsMessengerEXT nonDispatchableHandle 40 | 41 | // DeferredOperationKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeferredOperationKHR.html 42 | type DeferredOperationKHR nonDispatchableHandle 43 | 44 | // DescriptorPool: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html 45 | type DescriptorPool nonDispatchableHandle 46 | 47 | // DescriptorSet: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html 48 | type DescriptorSet nonDispatchableHandle 49 | 50 | // DescriptorSetLayout: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html 51 | type DescriptorSetLayout nonDispatchableHandle 52 | 53 | // DescriptorUpdateTemplate: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplate.html 54 | type DescriptorUpdateTemplate nonDispatchableHandle 55 | 56 | // DescriptorUpdateTemplateKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateKHR.html 57 | type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate 58 | 59 | // Device: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html 60 | type Device handle 61 | 62 | // DeviceMemory: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html 63 | type DeviceMemory nonDispatchableHandle 64 | 65 | // DisplayKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayKHR.html 66 | type DisplayKHR nonDispatchableHandle 67 | 68 | // DisplayModeKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeKHR.html 69 | type DisplayModeKHR nonDispatchableHandle 70 | 71 | // Event: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html 72 | type Event nonDispatchableHandle 73 | 74 | // Fence: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html 75 | type Fence nonDispatchableHandle 76 | 77 | // Framebuffer: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html 78 | type Framebuffer nonDispatchableHandle 79 | 80 | // Image: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html 81 | type Image nonDispatchableHandle 82 | 83 | // ImageView: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html 84 | type ImageView nonDispatchableHandle 85 | 86 | // IndirectCommandsLayoutNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutNV.html 87 | type IndirectCommandsLayoutNV nonDispatchableHandle 88 | 89 | // Instance: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html 90 | type Instance handle 91 | 92 | // MicromapEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapEXT.html 93 | type MicromapEXT nonDispatchableHandle 94 | 95 | // OpticalFlowSessionNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionNV.html 96 | type OpticalFlowSessionNV nonDispatchableHandle 97 | 98 | // PerformanceConfigurationINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationINTEL.html 99 | type PerformanceConfigurationINTEL nonDispatchableHandle 100 | 101 | // PhysicalDevice: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html 102 | type PhysicalDevice handle 103 | 104 | // Pipeline: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html 105 | type Pipeline nonDispatchableHandle 106 | 107 | // PipelineCache: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html 108 | type PipelineCache nonDispatchableHandle 109 | 110 | // PipelineLayout: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html 111 | type PipelineLayout nonDispatchableHandle 112 | 113 | // PrivateDataSlot: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlot.html 114 | type PrivateDataSlot nonDispatchableHandle 115 | 116 | // PrivateDataSlotEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotEXT.html 117 | type PrivateDataSlotEXT = PrivateDataSlot 118 | 119 | // QueryPool: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html 120 | type QueryPool nonDispatchableHandle 121 | 122 | // Queue: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html 123 | type Queue handle 124 | 125 | // RenderPass: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html 126 | type RenderPass nonDispatchableHandle 127 | 128 | // Sampler: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html 129 | type Sampler nonDispatchableHandle 130 | 131 | // SamplerYcbcrConversion: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversion.html 132 | type SamplerYcbcrConversion nonDispatchableHandle 133 | 134 | // SamplerYcbcrConversionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionKHR.html 135 | type SamplerYcbcrConversionKHR = SamplerYcbcrConversion 136 | 137 | // Semaphore: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html 138 | type Semaphore nonDispatchableHandle 139 | 140 | // ShaderEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderEXT.html 141 | type ShaderEXT nonDispatchableHandle 142 | 143 | // ShaderModule: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html 144 | type ShaderModule nonDispatchableHandle 145 | 146 | // SurfaceKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html 147 | type SurfaceKHR nonDispatchableHandle 148 | 149 | // SwapchainKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainKHR.html 150 | type SwapchainKHR nonDispatchableHandle 151 | 152 | // ValidationCacheEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html 153 | type ValidationCacheEXT nonDispatchableHandle 154 | 155 | // VideoSessionKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html 156 | type VideoSessionKHR nonDispatchableHandle 157 | 158 | // VideoSessionParametersKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html 159 | type VideoSessionParametersKHR nonDispatchableHandle 160 | 161 | // handle: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_DEFINE_HANDLE.html 162 | type handle uintptr 163 | 164 | const ( 165 | NULL_HANDLE handle = 0 166 | ) 167 | 168 | // nonDispatchableHandle: The Vulkan spec specifically defines a handle as a platform pointer type (i.e., could be 32 bits) and a non-dispatchable handle as a 64 bit type. 169 | // See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_DEFINE_NON_DISPATCHABLE_HANDLE.html 170 | type nonDispatchableHandle uint64 171 | -------------------------------------------------------------------------------- /static_basetype.go: -------------------------------------------------------------------------------- 1 | package vk 2 | 3 | // translatePublic_Bool32 is a type conversion function for special handling of Bool32 to bool. It is associated with the Bool32 type through exceptions.json 4 | func translatePublic_Bool32(val Bool32) bool { 5 | return val != Bool32(FALSE) 6 | } 7 | 8 | // translateInternal_Bool32 is a type conversion function for special handling of bool to Bool32. It is associated with the Bool32 type through exceptions.json 9 | func translateInternal_Bool32(val bool) Bool32 { 10 | if val { 11 | return Bool32(TRUE) 12 | } else { 13 | return Bool32(FALSE) 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /static_common.go: -------------------------------------------------------------------------------- 1 | package vk 2 | 3 | import ( 4 | "bytes" 5 | "runtime" 6 | "unsafe" 7 | ) 8 | 9 | // #include 10 | // #include "dlload.h" 11 | import "C" 12 | 13 | // Vulkanizer allows conversion from go-vk style structs to Vulkan-native structs. This 14 | // includes setting the structure type flag, converting slices to pointers, etc. 15 | type Vulkanizer interface { 16 | Vulkanize() unsafe.Pointer 17 | } 18 | 19 | // Goifier converts Vulkan-native structs back into go-vk style structs 20 | type Goifier interface { 21 | Goify() Vulkanizer 22 | } 23 | 24 | // max is an internal utility function, used in processing struct member slice/array lengths 25 | func max(nums ...int) int { 26 | rval := 0 27 | for _, v := range nums { 28 | if rval < v { 29 | rval = v 30 | } 31 | } 32 | return rval 33 | } 34 | 35 | // Error implements the error interface 36 | // TODO: A way for commands to indicate if the Result code is an error for that command, or an unexpected return value? 37 | func (r Result) Error() string { 38 | return r.String() 39 | } 40 | 41 | type vkCommand struct { 42 | protoName string 43 | argCount int 44 | hasReturn bool 45 | fnHandle unsafe.Pointer 46 | } 47 | 48 | var dlHandle unsafe.Pointer 49 | 50 | var overrideLibName string 51 | 52 | // OverrideDefaultVulkanLibrary allows you to set a specific Vulkan library name to be used in your program. For 53 | // example, if you want to enable the validation layers, those layers are only available in the Vulkan SDK libary. go-vk 54 | // passes the name to the host operating system's library opening/search method, so you must provide a relative or 55 | // absolute path if your Vulkan library is not in the default search path for the platform. 56 | func OverrideDefaultVulkanLibrary(nameOrPath string) { 57 | overrideLibName = nameOrPath 58 | } 59 | 60 | func execTrampoline(cmd *vkCommand, args ...uintptr) uintptr { 61 | if dlHandle == nil { 62 | var libName string 63 | switch runtime.GOOS { 64 | case "windows": 65 | libName = "vulkan-1.dll" 66 | case "darwin": 67 | // TODO: Running on Mac/Darwin is tested only to the point of creating and 68 | // destroying a Vulkan instance. 69 | libName = "libMoltenVK.dylib" 70 | case "linux": 71 | // TODO: Running on Linux is tested only to the point of creating and 72 | // destroying a Vulkan instance. 73 | libName = "libvulkan.so" 74 | default: 75 | panic("Unsupported GOOS at OpenLibrary: " + runtime.GOOS) 76 | } 77 | 78 | if overrideLibName != "" { 79 | libName = overrideLibName 80 | } 81 | 82 | cstr := C.CString(libName) 83 | dlHandle = C.OpenLibrary(cstr) 84 | C.free(unsafe.Pointer(cstr)) 85 | } 86 | 87 | // cmd := lazyCommands[commandKey] 88 | if cmd.fnHandle == nil { 89 | cmd.fnHandle = C.SymbolFromName(dlHandle, unsafe.Pointer(sys_stringToBytePointer(cmd.protoName))) 90 | // lazyCommands[commandKey] = cmd 91 | } 92 | 93 | if len(args) != cmd.argCount { 94 | panic("Wrong number of arguments passed for cmd " + cmd.protoName) 95 | } 96 | 97 | var result C.uintptr_t 98 | 99 | switch cmd.argCount { 100 | case 1: 101 | result = C.Trampoline3(cmd.fnHandle, C.uintptr_t(args[0]), 0, 0) 102 | case 2: 103 | result = C.Trampoline3(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), 0) 104 | case 3: 105 | result = C.Trampoline3(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2])) 106 | case 4: 107 | result = C.Trampoline6(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), 0, 0) 108 | case 5: 109 | result = C.Trampoline6(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), 0) 110 | case 6: 111 | result = C.Trampoline6(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5])) 112 | case 7: 113 | result = C.Trampoline9(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5]), C.uintptr_t(args[6]), 0, 0) 114 | case 8: 115 | result = C.Trampoline9(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5]), C.uintptr_t(args[6]), C.uintptr_t(args[7]), 0) 116 | case 9: 117 | result = C.Trampoline9(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5]), C.uintptr_t(args[6]), C.uintptr_t(args[7]), C.uintptr_t(args[8])) 118 | case 10: 119 | result = C.Trampoline12(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5]), C.uintptr_t(args[6]), C.uintptr_t(args[7]), C.uintptr_t(args[8]), C.uintptr_t(args[9]), 0, 0) 120 | case 11: 121 | result = C.Trampoline12(cmd.fnHandle, C.uintptr_t(args[0]), C.uintptr_t(args[1]), C.uintptr_t(args[2]), C.uintptr_t(args[3]), C.uintptr_t(args[4]), C.uintptr_t(args[5]), C.uintptr_t(args[6]), C.uintptr_t(args[7]), C.uintptr_t(args[8]), C.uintptr_t(args[9]), C.uintptr_t(args[10]), 0) 122 | default: 123 | // There are no commands with 0 or 12+ arguments as of Vulkan 1.3.204 124 | panic("Unhandled number of arguments passed for cmd " + cmd.protoName) 125 | } 126 | 127 | return uintptr(result) 128 | } 129 | 130 | func stringToNullTermBytes(s string) *byte { 131 | b := []byte(s) 132 | b = append(b, 0) 133 | return &b[0] 134 | } 135 | 136 | func nullTermBytesToString(b []byte) string { 137 | n := bytes.IndexByte(b, 0) 138 | return string(b[:n]) 139 | } 140 | -------------------------------------------------------------------------------- /static_defines.go: -------------------------------------------------------------------------------- 1 | package vk 2 | 3 | // The functions in this file are Go versions of C preprocessor macros from vk.xml. Each function here is associated with its 4 | // Vulkan name through exceptions.json 5 | 6 | func deprecatedMakeVersion(major, minor, patch uint32) uint32 { 7 | return major<<22 | minor<<12 | patch 8 | } 9 | func deprecatedVersionMajor(version uint32) uint32 { 10 | return version >> 22 11 | } 12 | func deprecatedVersionMinor(version uint32) uint32 { 13 | return version >> 12 & 0x3FF 14 | } 15 | func deprecatedVersionPatch(version uint32) uint32 { 16 | return version & 0xFFF 17 | } 18 | 19 | func makeVersion(major, minor, patch uint32) uint32 { 20 | return major<<22 | minor<<12 | patch 21 | } 22 | 23 | func makeApiVersion(variant, major, minor, patch uint32) uint32 { 24 | return variant<<29 | major<<22 | minor<<12 | patch 25 | } 26 | 27 | func apiVersionVariant(version uint32) uint32 { 28 | return version >> 29 29 | } 30 | func apiVersionMajor(version uint32) uint32 { 31 | return version >> 22 & 0x7F 32 | } 33 | func apiVersionMinor(version uint32) uint32 { 34 | return version >> 12 & 0x3FF 35 | } 36 | func apiVersionPatch(version uint32) uint32 { 37 | return version & 0xFFF 38 | } 39 | -------------------------------------------------------------------------------- /static_mem.go: -------------------------------------------------------------------------------- 1 | package vk 2 | 3 | import "unsafe" 4 | 5 | // sl is a Go slice header (or rather, it matches a slice header byte-for-byte). 6 | type sl struct { 7 | addr uintptr 8 | len int 9 | cap int 10 | } 11 | 12 | /* MemCopySlice provides an abstracted memory copy function, intended for use with mapped memory ranges. Note that the 13 | destination is passed as an unsafe.Pointer and this function cannot determine if you have allocated enough 14 | memory at that location. You are responsible for requesting enough memory from Vulkan! Unexpected behavior or crashes 15 | are very possible if this function is misused or abused. 16 | */ 17 | func MemCopySlice[T any](dest unsafe.Pointer, src []T) { 18 | if len(src) == 0 { 19 | return 20 | } 21 | 22 | bytes := len(src) * int(unsafe.Sizeof(src[0])) 23 | 24 | sl_src := *(*[]byte)(unsafe.Pointer(&sl{uintptr(unsafe.Pointer(&src[0])), bytes, bytes})) 25 | sl_dest := *(*[]byte)(unsafe.Pointer(&sl{uintptr(dest), bytes, bytes})) 26 | 27 | copy(sl_dest, sl_src) 28 | } 29 | 30 | /* MemCopyObj provides an abstracted memory copy function for a single piece of data (a struct or primitive type), 31 | intended for use with mapped memory ranges. Note that the destination is passed as an unsafe.Pointer and this function 32 | cannot determine if you have allocated enough memory at that location. You are responsible for requesting enough memory 33 | from Vulkan! Unexpected behavior or crashes are very possible if this function is misused or abused. 34 | 35 | NOTE: If you pass a slice to this function, the slice header will be copied, not the contents! Use [MemCopySlice] instead. 36 | */ 37 | func MemCopyObj[T any](dest unsafe.Pointer, src *T) { 38 | bytes := int(unsafe.Sizeof(*src)) 39 | 40 | sl_src := *(*[]byte)(unsafe.Pointer(&sl{uintptr(unsafe.Pointer(src)), bytes, bytes})) 41 | sl_dest := *(*[]byte)(unsafe.Pointer(&(sl{uintptr(dest), bytes, bytes}))) 42 | 43 | copy(sl_dest, sl_src) 44 | } 45 | 46 | /* MemCopy is the closest to C's memcpy...you provide two pointers and a number of bytes to copy, and it will move the 47 | data around. Using [MemCopySlice] or [MemCopyObj] instead is highly recommended. There are no guardrails on this function! 48 | */ 49 | func MemCopy(dest, src unsafe.Pointer, len int) { 50 | sl_src := *(*[]byte)(unsafe.Pointer(&sl{uintptr(src), len, len})) 51 | sl_dest := *(*[]byte)(unsafe.Pointer(&sl{uintptr(dest), len, len})) 52 | 53 | copy(sl_dest, sl_src) 54 | } 55 | -------------------------------------------------------------------------------- /struct_macos.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.186034 -0500 EST m=+3.711483193. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import "unsafe" 7 | 8 | // MacOSSurfaceCreateInfoMVK: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html 9 | type MacOSSurfaceCreateInfoMVK struct { 10 | // SType = STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK 11 | PNext unsafe.Pointer 12 | Flags MacOSSurfaceCreateFlagsMVK 13 | PView unsafe.Pointer 14 | } 15 | 16 | type _vkMacOSSurfaceCreateInfoMVK struct { 17 | sType StructureType 18 | pNext unsafe.Pointer 19 | flags MacOSSurfaceCreateFlagsMVK 20 | pView unsafe.Pointer 21 | } 22 | 23 | func (s *_vkMacOSSurfaceCreateInfoMVK) Goify() *MacOSSurfaceCreateInfoMVK { 24 | rval := &MacOSSurfaceCreateInfoMVK{ 25 | PNext: (unsafe.Pointer)(s.pNext), 26 | Flags: (MacOSSurfaceCreateFlagsMVK)(s.flags), 27 | PView: (unsafe.Pointer)(s.pView), 28 | } 29 | return rval 30 | } 31 | func (s *MacOSSurfaceCreateInfoMVK) Vulkanize() *_vkMacOSSurfaceCreateInfoMVK { 32 | if s == nil { 33 | return nil 34 | } 35 | rval := &_vkMacOSSurfaceCreateInfoMVK{ 36 | sType: STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, /*c1*/ 37 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 38 | flags: (MacOSSurfaceCreateFlagsMVK)(s.Flags), /*cb*/ 39 | pView: (unsafe.Pointer)(s.PView), /*cb*/ 40 | } 41 | return rval 42 | } 43 | -------------------------------------------------------------------------------- /struct_metal.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.641701 -0500 EST m=+3.167146284. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import "unsafe" 7 | 8 | // ExportMetalBufferInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalBufferInfoEXT.html 9 | type ExportMetalBufferInfoEXT struct { 10 | // SType = STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT 11 | PNext unsafe.Pointer 12 | Memory DeviceMemory 13 | MtlBuffer MTLBuffer_id 14 | } 15 | 16 | type _vkExportMetalBufferInfoEXT struct { 17 | sType StructureType 18 | pNext unsafe.Pointer 19 | memory DeviceMemory 20 | mtlBuffer MTLBuffer_id 21 | } 22 | 23 | func (s *_vkExportMetalBufferInfoEXT) Goify() *ExportMetalBufferInfoEXT { 24 | rval := &ExportMetalBufferInfoEXT{ 25 | PNext: (unsafe.Pointer)(s.pNext), 26 | Memory: (DeviceMemory)(s.memory), 27 | MtlBuffer: (MTLBuffer_id)(s.mtlBuffer), 28 | } 29 | return rval 30 | } 31 | func (s *ExportMetalBufferInfoEXT) Vulkanize() *_vkExportMetalBufferInfoEXT { 32 | if s == nil { 33 | return nil 34 | } 35 | rval := &_vkExportMetalBufferInfoEXT{ 36 | sType: STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT, /*c1*/ 37 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 38 | memory: (DeviceMemory)(s.Memory), /*cb*/ 39 | mtlBuffer: (MTLBuffer_id)(s.MtlBuffer), /*cb*/ 40 | } 41 | return rval 42 | } 43 | 44 | // ExportMetalCommandQueueInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalCommandQueueInfoEXT.html 45 | type ExportMetalCommandQueueInfoEXT struct { 46 | // SType = STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT 47 | PNext unsafe.Pointer 48 | Queue Queue 49 | MtlCommandQueue MTLCommandQueue_id 50 | } 51 | 52 | type _vkExportMetalCommandQueueInfoEXT struct { 53 | sType StructureType 54 | pNext unsafe.Pointer 55 | queue Queue 56 | mtlCommandQueue MTLCommandQueue_id 57 | } 58 | 59 | func (s *_vkExportMetalCommandQueueInfoEXT) Goify() *ExportMetalCommandQueueInfoEXT { 60 | rval := &ExportMetalCommandQueueInfoEXT{ 61 | PNext: (unsafe.Pointer)(s.pNext), 62 | Queue: (Queue)(s.queue), 63 | MtlCommandQueue: (MTLCommandQueue_id)(s.mtlCommandQueue), 64 | } 65 | return rval 66 | } 67 | func (s *ExportMetalCommandQueueInfoEXT) Vulkanize() *_vkExportMetalCommandQueueInfoEXT { 68 | if s == nil { 69 | return nil 70 | } 71 | rval := &_vkExportMetalCommandQueueInfoEXT{ 72 | sType: STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT, /*c1*/ 73 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 74 | queue: (Queue)(s.Queue), /*cb*/ 75 | mtlCommandQueue: (MTLCommandQueue_id)(s.MtlCommandQueue), /*cb*/ 76 | } 77 | return rval 78 | } 79 | 80 | // ExportMetalDeviceInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalDeviceInfoEXT.html 81 | type ExportMetalDeviceInfoEXT struct { 82 | // SType = STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT 83 | PNext unsafe.Pointer 84 | MtlDevice MTLDevice_id 85 | } 86 | 87 | type _vkExportMetalDeviceInfoEXT struct { 88 | sType StructureType 89 | pNext unsafe.Pointer 90 | mtlDevice MTLDevice_id 91 | } 92 | 93 | func (s *_vkExportMetalDeviceInfoEXT) Goify() *ExportMetalDeviceInfoEXT { 94 | rval := &ExportMetalDeviceInfoEXT{ 95 | PNext: (unsafe.Pointer)(s.pNext), 96 | MtlDevice: (MTLDevice_id)(s.mtlDevice), 97 | } 98 | return rval 99 | } 100 | func (s *ExportMetalDeviceInfoEXT) Vulkanize() *_vkExportMetalDeviceInfoEXT { 101 | if s == nil { 102 | return nil 103 | } 104 | rval := &_vkExportMetalDeviceInfoEXT{ 105 | sType: STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT, /*c1*/ 106 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 107 | mtlDevice: (MTLDevice_id)(s.MtlDevice), /*cb*/ 108 | } 109 | return rval 110 | } 111 | 112 | // ExportMetalIOSurfaceInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalIOSurfaceInfoEXT.html 113 | type ExportMetalIOSurfaceInfoEXT struct { 114 | // SType = STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT 115 | PNext unsafe.Pointer 116 | Image Image 117 | IoSurface IOSurfaceRef 118 | } 119 | 120 | type _vkExportMetalIOSurfaceInfoEXT struct { 121 | sType StructureType 122 | pNext unsafe.Pointer 123 | image Image 124 | ioSurface IOSurfaceRef 125 | } 126 | 127 | func (s *_vkExportMetalIOSurfaceInfoEXT) Goify() *ExportMetalIOSurfaceInfoEXT { 128 | rval := &ExportMetalIOSurfaceInfoEXT{ 129 | PNext: (unsafe.Pointer)(s.pNext), 130 | Image: (Image)(s.image), 131 | IoSurface: (IOSurfaceRef)(s.ioSurface), 132 | } 133 | return rval 134 | } 135 | func (s *ExportMetalIOSurfaceInfoEXT) Vulkanize() *_vkExportMetalIOSurfaceInfoEXT { 136 | if s == nil { 137 | return nil 138 | } 139 | rval := &_vkExportMetalIOSurfaceInfoEXT{ 140 | sType: STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT, /*c1*/ 141 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 142 | image: (Image)(s.Image), /*cb*/ 143 | ioSurface: (IOSurfaceRef)(s.IoSurface), /*cb*/ 144 | } 145 | return rval 146 | } 147 | 148 | // ExportMetalObjectCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectCreateInfoEXT.html 149 | type ExportMetalObjectCreateInfoEXT struct { 150 | // SType = STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT 151 | PNext unsafe.Pointer 152 | ExportObjectType ExportMetalObjectTypeFlagBitsEXT 153 | } 154 | 155 | type _vkExportMetalObjectCreateInfoEXT struct { 156 | sType StructureType 157 | pNext unsafe.Pointer 158 | exportObjectType ExportMetalObjectTypeFlagBitsEXT 159 | } 160 | 161 | func (s *_vkExportMetalObjectCreateInfoEXT) Goify() *ExportMetalObjectCreateInfoEXT { 162 | rval := &ExportMetalObjectCreateInfoEXT{ 163 | PNext: (unsafe.Pointer)(s.pNext), 164 | ExportObjectType: (ExportMetalObjectTypeFlagBitsEXT)(s.exportObjectType), 165 | } 166 | return rval 167 | } 168 | func (s *ExportMetalObjectCreateInfoEXT) Vulkanize() *_vkExportMetalObjectCreateInfoEXT { 169 | if s == nil { 170 | return nil 171 | } 172 | rval := &_vkExportMetalObjectCreateInfoEXT{ 173 | sType: STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, /*c1*/ 174 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 175 | exportObjectType: (ExportMetalObjectTypeFlagBitsEXT)(s.ExportObjectType), /*cb*/ 176 | } 177 | return rval 178 | } 179 | 180 | // ExportMetalObjectsInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectsInfoEXT.html 181 | type ExportMetalObjectsInfoEXT struct { 182 | // SType = STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT 183 | PNext unsafe.Pointer 184 | } 185 | 186 | type _vkExportMetalObjectsInfoEXT struct { 187 | sType StructureType 188 | pNext unsafe.Pointer 189 | } 190 | 191 | func (s *_vkExportMetalObjectsInfoEXT) Goify() *ExportMetalObjectsInfoEXT { 192 | rval := &ExportMetalObjectsInfoEXT{ 193 | PNext: (unsafe.Pointer)(s.pNext), 194 | } 195 | return rval 196 | } 197 | func (s *ExportMetalObjectsInfoEXT) Vulkanize() *_vkExportMetalObjectsInfoEXT { 198 | if s == nil { 199 | return nil 200 | } 201 | rval := &_vkExportMetalObjectsInfoEXT{ 202 | sType: STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT, /*c1*/ 203 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 204 | } 205 | return rval 206 | } 207 | 208 | // ExportMetalSharedEventInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalSharedEventInfoEXT.html 209 | type ExportMetalSharedEventInfoEXT struct { 210 | // SType = STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT 211 | PNext unsafe.Pointer 212 | Semaphore Semaphore 213 | Event Event 214 | MtlSharedEvent MTLSharedEvent_id 215 | } 216 | 217 | type _vkExportMetalSharedEventInfoEXT struct { 218 | sType StructureType 219 | pNext unsafe.Pointer 220 | semaphore Semaphore 221 | event Event 222 | mtlSharedEvent MTLSharedEvent_id 223 | } 224 | 225 | func (s *_vkExportMetalSharedEventInfoEXT) Goify() *ExportMetalSharedEventInfoEXT { 226 | rval := &ExportMetalSharedEventInfoEXT{ 227 | PNext: (unsafe.Pointer)(s.pNext), 228 | Semaphore: (Semaphore)(s.semaphore), 229 | Event: (Event)(s.event), 230 | MtlSharedEvent: (MTLSharedEvent_id)(s.mtlSharedEvent), 231 | } 232 | return rval 233 | } 234 | func (s *ExportMetalSharedEventInfoEXT) Vulkanize() *_vkExportMetalSharedEventInfoEXT { 235 | if s == nil { 236 | return nil 237 | } 238 | rval := &_vkExportMetalSharedEventInfoEXT{ 239 | sType: STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT, /*c1*/ 240 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 241 | semaphore: (Semaphore)(s.Semaphore), /*cb*/ 242 | event: (Event)(s.Event), /*cb*/ 243 | mtlSharedEvent: (MTLSharedEvent_id)(s.MtlSharedEvent), /*cb*/ 244 | } 245 | return rval 246 | } 247 | 248 | // ExportMetalTextureInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalTextureInfoEXT.html 249 | type ExportMetalTextureInfoEXT struct { 250 | // SType = STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT 251 | PNext unsafe.Pointer 252 | Image Image 253 | ImageView ImageView 254 | BufferView BufferView 255 | Plane ImageAspectFlagBits 256 | MtlTexture MTLTexture_id 257 | } 258 | 259 | type _vkExportMetalTextureInfoEXT struct { 260 | sType StructureType 261 | pNext unsafe.Pointer 262 | image Image 263 | imageView ImageView 264 | bufferView BufferView 265 | plane ImageAspectFlagBits 266 | mtlTexture MTLTexture_id 267 | } 268 | 269 | func (s *_vkExportMetalTextureInfoEXT) Goify() *ExportMetalTextureInfoEXT { 270 | rval := &ExportMetalTextureInfoEXT{ 271 | PNext: (unsafe.Pointer)(s.pNext), 272 | Image: (Image)(s.image), 273 | ImageView: (ImageView)(s.imageView), 274 | BufferView: (BufferView)(s.bufferView), 275 | Plane: (ImageAspectFlagBits)(s.plane), 276 | MtlTexture: (MTLTexture_id)(s.mtlTexture), 277 | } 278 | return rval 279 | } 280 | func (s *ExportMetalTextureInfoEXT) Vulkanize() *_vkExportMetalTextureInfoEXT { 281 | if s == nil { 282 | return nil 283 | } 284 | rval := &_vkExportMetalTextureInfoEXT{ 285 | sType: STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT, /*c1*/ 286 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 287 | image: (Image)(s.Image), /*cb*/ 288 | imageView: (ImageView)(s.ImageView), /*cb*/ 289 | bufferView: (BufferView)(s.BufferView), /*cb*/ 290 | plane: (ImageAspectFlagBits)(s.Plane), /*cb*/ 291 | mtlTexture: (MTLTexture_id)(s.MtlTexture), /*cb*/ 292 | } 293 | return rval 294 | } 295 | 296 | // ImportMetalBufferInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalBufferInfoEXT.html 297 | type ImportMetalBufferInfoEXT struct { 298 | // SType = STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT 299 | PNext unsafe.Pointer 300 | MtlBuffer MTLBuffer_id 301 | } 302 | 303 | type _vkImportMetalBufferInfoEXT struct { 304 | sType StructureType 305 | pNext unsafe.Pointer 306 | mtlBuffer MTLBuffer_id 307 | } 308 | 309 | func (s *_vkImportMetalBufferInfoEXT) Goify() *ImportMetalBufferInfoEXT { 310 | rval := &ImportMetalBufferInfoEXT{ 311 | PNext: (unsafe.Pointer)(s.pNext), 312 | MtlBuffer: (MTLBuffer_id)(s.mtlBuffer), 313 | } 314 | return rval 315 | } 316 | func (s *ImportMetalBufferInfoEXT) Vulkanize() *_vkImportMetalBufferInfoEXT { 317 | if s == nil { 318 | return nil 319 | } 320 | rval := &_vkImportMetalBufferInfoEXT{ 321 | sType: STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, /*c1*/ 322 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 323 | mtlBuffer: (MTLBuffer_id)(s.MtlBuffer), /*cb*/ 324 | } 325 | return rval 326 | } 327 | 328 | // ImportMetalIOSurfaceInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalIOSurfaceInfoEXT.html 329 | type ImportMetalIOSurfaceInfoEXT struct { 330 | // SType = STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT 331 | PNext unsafe.Pointer 332 | IoSurface IOSurfaceRef 333 | } 334 | 335 | type _vkImportMetalIOSurfaceInfoEXT struct { 336 | sType StructureType 337 | pNext unsafe.Pointer 338 | ioSurface IOSurfaceRef 339 | } 340 | 341 | func (s *_vkImportMetalIOSurfaceInfoEXT) Goify() *ImportMetalIOSurfaceInfoEXT { 342 | rval := &ImportMetalIOSurfaceInfoEXT{ 343 | PNext: (unsafe.Pointer)(s.pNext), 344 | IoSurface: (IOSurfaceRef)(s.ioSurface), 345 | } 346 | return rval 347 | } 348 | func (s *ImportMetalIOSurfaceInfoEXT) Vulkanize() *_vkImportMetalIOSurfaceInfoEXT { 349 | if s == nil { 350 | return nil 351 | } 352 | rval := &_vkImportMetalIOSurfaceInfoEXT{ 353 | sType: STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, /*c1*/ 354 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 355 | ioSurface: (IOSurfaceRef)(s.IoSurface), /*cb*/ 356 | } 357 | return rval 358 | } 359 | 360 | // ImportMetalSharedEventInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalSharedEventInfoEXT.html 361 | type ImportMetalSharedEventInfoEXT struct { 362 | // SType = STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT 363 | PNext unsafe.Pointer 364 | MtlSharedEvent MTLSharedEvent_id 365 | } 366 | 367 | type _vkImportMetalSharedEventInfoEXT struct { 368 | sType StructureType 369 | pNext unsafe.Pointer 370 | mtlSharedEvent MTLSharedEvent_id 371 | } 372 | 373 | func (s *_vkImportMetalSharedEventInfoEXT) Goify() *ImportMetalSharedEventInfoEXT { 374 | rval := &ImportMetalSharedEventInfoEXT{ 375 | PNext: (unsafe.Pointer)(s.pNext), 376 | MtlSharedEvent: (MTLSharedEvent_id)(s.mtlSharedEvent), 377 | } 378 | return rval 379 | } 380 | func (s *ImportMetalSharedEventInfoEXT) Vulkanize() *_vkImportMetalSharedEventInfoEXT { 381 | if s == nil { 382 | return nil 383 | } 384 | rval := &_vkImportMetalSharedEventInfoEXT{ 385 | sType: STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT, /*c1*/ 386 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 387 | mtlSharedEvent: (MTLSharedEvent_id)(s.MtlSharedEvent), /*cb*/ 388 | } 389 | return rval 390 | } 391 | 392 | // ImportMetalTextureInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalTextureInfoEXT.html 393 | type ImportMetalTextureInfoEXT struct { 394 | // SType = STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT 395 | PNext unsafe.Pointer 396 | Plane ImageAspectFlagBits 397 | MtlTexture MTLTexture_id 398 | } 399 | 400 | type _vkImportMetalTextureInfoEXT struct { 401 | sType StructureType 402 | pNext unsafe.Pointer 403 | plane ImageAspectFlagBits 404 | mtlTexture MTLTexture_id 405 | } 406 | 407 | func (s *_vkImportMetalTextureInfoEXT) Goify() *ImportMetalTextureInfoEXT { 408 | rval := &ImportMetalTextureInfoEXT{ 409 | PNext: (unsafe.Pointer)(s.pNext), 410 | Plane: (ImageAspectFlagBits)(s.plane), 411 | MtlTexture: (MTLTexture_id)(s.mtlTexture), 412 | } 413 | return rval 414 | } 415 | func (s *ImportMetalTextureInfoEXT) Vulkanize() *_vkImportMetalTextureInfoEXT { 416 | if s == nil { 417 | return nil 418 | } 419 | rval := &_vkImportMetalTextureInfoEXT{ 420 | sType: STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, /*c1*/ 421 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 422 | plane: (ImageAspectFlagBits)(s.Plane), /*cb*/ 423 | mtlTexture: (MTLTexture_id)(s.MtlTexture), /*cb*/ 424 | } 425 | return rval 426 | } 427 | 428 | // MetalSurfaceCreateInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html 429 | type MetalSurfaceCreateInfoEXT struct { 430 | // SType = STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT 431 | PNext unsafe.Pointer 432 | Flags MetalSurfaceCreateFlagsEXT 433 | PLayer *CAMetalLayer 434 | } 435 | 436 | type _vkMetalSurfaceCreateInfoEXT struct { 437 | sType StructureType 438 | pNext unsafe.Pointer 439 | flags MetalSurfaceCreateFlagsEXT 440 | pLayer *CAMetalLayer 441 | } 442 | 443 | func (s *_vkMetalSurfaceCreateInfoEXT) Goify() *MetalSurfaceCreateInfoEXT { 444 | rval := &MetalSurfaceCreateInfoEXT{ 445 | PNext: (unsafe.Pointer)(s.pNext), 446 | Flags: (MetalSurfaceCreateFlagsEXT)(s.flags), 447 | PLayer: (*CAMetalLayer)(s.pLayer), 448 | } 449 | return rval 450 | } 451 | func (s *MetalSurfaceCreateInfoEXT) Vulkanize() *_vkMetalSurfaceCreateInfoEXT { 452 | if s == nil { 453 | return nil 454 | } 455 | rval := &_vkMetalSurfaceCreateInfoEXT{ 456 | sType: STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, /*c1*/ 457 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 458 | flags: (MetalSurfaceCreateFlagsEXT)(s.Flags), /*cb*/ 459 | pLayer: (*CAMetalLayer)(s.PLayer), /*cb*/ 460 | } 461 | return rval 462 | } 463 | -------------------------------------------------------------------------------- /struct_win32.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:11.073982 -0500 EST m=+3.599429886. DO NOT EDIT. 3 | 4 | package vk 5 | 6 | import ( 7 | "unsafe" 8 | 9 | "golang.org/x/sys/windows" 10 | ) 11 | 12 | // D3D12FenceSubmitInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html 13 | type D3D12FenceSubmitInfoKHR struct { 14 | // SType = STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR 15 | PNext unsafe.Pointer 16 | // waitSemaphoreValuesCount 17 | PWaitSemaphoreValues []uint64 18 | // signalSemaphoreValuesCount 19 | PSignalSemaphoreValues []uint64 20 | } 21 | 22 | type _vkD3D12FenceSubmitInfoKHR struct { 23 | sType StructureType 24 | pNext unsafe.Pointer 25 | waitSemaphoreValuesCount uint32 26 | pWaitSemaphoreValues *uint64 27 | signalSemaphoreValuesCount uint32 28 | pSignalSemaphoreValues *uint64 29 | } 30 | 31 | func (s *_vkD3D12FenceSubmitInfoKHR) Goify() *D3D12FenceSubmitInfoKHR { 32 | rval := &D3D12FenceSubmitInfoKHR{ 33 | PNext: (unsafe.Pointer)(s.pNext), 34 | // Unexpected 'isLenForAnotherMember'! 35 | // Unexpected pointer member pWaitSemaphoreValues in returned struct 36 | // Unexpected 'isLenForAnotherMember'! 37 | // Unexpected pointer member pSignalSemaphoreValues in returned struct 38 | } 39 | return rval 40 | } 41 | func (s *D3D12FenceSubmitInfoKHR) Vulkanize() *_vkD3D12FenceSubmitInfoKHR { 42 | if s == nil { 43 | return nil 44 | } 45 | 46 | var psl_pWaitSemaphoreValues *uint64 47 | if len(s.PWaitSemaphoreValues) > 0 { 48 | psl_pWaitSemaphoreValues = &s.PWaitSemaphoreValues[0] 49 | } 50 | 51 | var psl_pSignalSemaphoreValues *uint64 52 | if len(s.PSignalSemaphoreValues) > 0 { 53 | psl_pSignalSemaphoreValues = &s.PSignalSemaphoreValues[0] 54 | } 55 | rval := &_vkD3D12FenceSubmitInfoKHR{ 56 | sType: STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, /*c1*/ 57 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 58 | waitSemaphoreValuesCount: uint32(len(s.PWaitSemaphoreValues)), /*c6-a*/ 59 | pWaitSemaphoreValues: psl_pWaitSemaphoreValues, /*c rem*/ 60 | signalSemaphoreValuesCount: uint32(len(s.PSignalSemaphoreValues)), /*c6-a*/ 61 | pSignalSemaphoreValues: psl_pSignalSemaphoreValues, /*c rem*/ 62 | } 63 | return rval 64 | } 65 | 66 | // ExportFenceWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html 67 | type ExportFenceWin32HandleInfoKHR struct { 68 | // SType = STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR 69 | PNext unsafe.Pointer 70 | PAttributes *windows.SecurityAttributes 71 | DwAccess uint32 72 | Name unsafe.Pointer 73 | } 74 | 75 | type _vkExportFenceWin32HandleInfoKHR struct { 76 | sType StructureType 77 | pNext unsafe.Pointer 78 | pAttributes *windows.SecurityAttributes 79 | dwAccess uint32 80 | name unsafe.Pointer 81 | } 82 | 83 | func (s *_vkExportFenceWin32HandleInfoKHR) Goify() *ExportFenceWin32HandleInfoKHR { 84 | rval := &ExportFenceWin32HandleInfoKHR{ 85 | PNext: (unsafe.Pointer)(s.pNext), 86 | PAttributes: (*windows.SecurityAttributes)(s.pAttributes), 87 | DwAccess: (uint32)(s.dwAccess), 88 | Name: (unsafe.Pointer)(s.name), 89 | } 90 | return rval 91 | } 92 | func (s *ExportFenceWin32HandleInfoKHR) Vulkanize() *_vkExportFenceWin32HandleInfoKHR { 93 | if s == nil { 94 | return nil 95 | } 96 | rval := &_vkExportFenceWin32HandleInfoKHR{ 97 | sType: STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, /*c1*/ 98 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 99 | pAttributes: (*windows.SecurityAttributes)(s.PAttributes), /*cb*/ 100 | dwAccess: (uint32)(s.DwAccess), /*cb*/ 101 | name: (unsafe.Pointer)(s.Name), /*cb*/ 102 | } 103 | return rval 104 | } 105 | 106 | // ExportMemoryWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html 107 | type ExportMemoryWin32HandleInfoKHR struct { 108 | // SType = STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR 109 | PNext unsafe.Pointer 110 | PAttributes *windows.SecurityAttributes 111 | DwAccess uint32 112 | Name unsafe.Pointer 113 | } 114 | 115 | type _vkExportMemoryWin32HandleInfoKHR struct { 116 | sType StructureType 117 | pNext unsafe.Pointer 118 | pAttributes *windows.SecurityAttributes 119 | dwAccess uint32 120 | name unsafe.Pointer 121 | } 122 | 123 | func (s *_vkExportMemoryWin32HandleInfoKHR) Goify() *ExportMemoryWin32HandleInfoKHR { 124 | rval := &ExportMemoryWin32HandleInfoKHR{ 125 | PNext: (unsafe.Pointer)(s.pNext), 126 | PAttributes: (*windows.SecurityAttributes)(s.pAttributes), 127 | DwAccess: (uint32)(s.dwAccess), 128 | Name: (unsafe.Pointer)(s.name), 129 | } 130 | return rval 131 | } 132 | func (s *ExportMemoryWin32HandleInfoKHR) Vulkanize() *_vkExportMemoryWin32HandleInfoKHR { 133 | if s == nil { 134 | return nil 135 | } 136 | rval := &_vkExportMemoryWin32HandleInfoKHR{ 137 | sType: STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, /*c1*/ 138 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 139 | pAttributes: (*windows.SecurityAttributes)(s.PAttributes), /*cb*/ 140 | dwAccess: (uint32)(s.DwAccess), /*cb*/ 141 | name: (unsafe.Pointer)(s.Name), /*cb*/ 142 | } 143 | return rval 144 | } 145 | 146 | // ExportMemoryWin32HandleInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html 147 | type ExportMemoryWin32HandleInfoNV struct { 148 | // SType = STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV 149 | PNext unsafe.Pointer 150 | PAttributes *windows.SecurityAttributes 151 | DwAccess uint32 152 | } 153 | 154 | type _vkExportMemoryWin32HandleInfoNV struct { 155 | sType StructureType 156 | pNext unsafe.Pointer 157 | pAttributes *windows.SecurityAttributes 158 | dwAccess uint32 159 | } 160 | 161 | func (s *_vkExportMemoryWin32HandleInfoNV) Goify() *ExportMemoryWin32HandleInfoNV { 162 | rval := &ExportMemoryWin32HandleInfoNV{ 163 | PNext: (unsafe.Pointer)(s.pNext), 164 | PAttributes: (*windows.SecurityAttributes)(s.pAttributes), 165 | DwAccess: (uint32)(s.dwAccess), 166 | } 167 | return rval 168 | } 169 | func (s *ExportMemoryWin32HandleInfoNV) Vulkanize() *_vkExportMemoryWin32HandleInfoNV { 170 | if s == nil { 171 | return nil 172 | } 173 | rval := &_vkExportMemoryWin32HandleInfoNV{ 174 | sType: STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, /*c1*/ 175 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 176 | pAttributes: (*windows.SecurityAttributes)(s.PAttributes), /*cb*/ 177 | dwAccess: (uint32)(s.DwAccess), /*cb*/ 178 | } 179 | return rval 180 | } 181 | 182 | // ExportSemaphoreWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html 183 | type ExportSemaphoreWin32HandleInfoKHR struct { 184 | // SType = STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR 185 | PNext unsafe.Pointer 186 | PAttributes *windows.SecurityAttributes 187 | DwAccess uint32 188 | Name unsafe.Pointer 189 | } 190 | 191 | type _vkExportSemaphoreWin32HandleInfoKHR struct { 192 | sType StructureType 193 | pNext unsafe.Pointer 194 | pAttributes *windows.SecurityAttributes 195 | dwAccess uint32 196 | name unsafe.Pointer 197 | } 198 | 199 | func (s *_vkExportSemaphoreWin32HandleInfoKHR) Goify() *ExportSemaphoreWin32HandleInfoKHR { 200 | rval := &ExportSemaphoreWin32HandleInfoKHR{ 201 | PNext: (unsafe.Pointer)(s.pNext), 202 | PAttributes: (*windows.SecurityAttributes)(s.pAttributes), 203 | DwAccess: (uint32)(s.dwAccess), 204 | Name: (unsafe.Pointer)(s.name), 205 | } 206 | return rval 207 | } 208 | func (s *ExportSemaphoreWin32HandleInfoKHR) Vulkanize() *_vkExportSemaphoreWin32HandleInfoKHR { 209 | if s == nil { 210 | return nil 211 | } 212 | rval := &_vkExportSemaphoreWin32HandleInfoKHR{ 213 | sType: STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, /*c1*/ 214 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 215 | pAttributes: (*windows.SecurityAttributes)(s.PAttributes), /*cb*/ 216 | dwAccess: (uint32)(s.DwAccess), /*cb*/ 217 | name: (unsafe.Pointer)(s.Name), /*cb*/ 218 | } 219 | return rval 220 | } 221 | 222 | // FenceGetWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html 223 | type FenceGetWin32HandleInfoKHR struct { 224 | // SType = STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR 225 | PNext unsafe.Pointer 226 | Fence Fence 227 | HandleType ExternalFenceHandleTypeFlagBits 228 | } 229 | 230 | type _vkFenceGetWin32HandleInfoKHR struct { 231 | sType StructureType 232 | pNext unsafe.Pointer 233 | fence Fence 234 | handleType ExternalFenceHandleTypeFlagBits 235 | } 236 | 237 | func (s *_vkFenceGetWin32HandleInfoKHR) Goify() *FenceGetWin32HandleInfoKHR { 238 | rval := &FenceGetWin32HandleInfoKHR{ 239 | PNext: (unsafe.Pointer)(s.pNext), 240 | Fence: (Fence)(s.fence), 241 | HandleType: (ExternalFenceHandleTypeFlagBits)(s.handleType), 242 | } 243 | return rval 244 | } 245 | func (s *FenceGetWin32HandleInfoKHR) Vulkanize() *_vkFenceGetWin32HandleInfoKHR { 246 | if s == nil { 247 | return nil 248 | } 249 | rval := &_vkFenceGetWin32HandleInfoKHR{ 250 | sType: STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, /*c1*/ 251 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 252 | fence: (Fence)(s.Fence), /*cb*/ 253 | handleType: (ExternalFenceHandleTypeFlagBits)(s.HandleType), /*cb*/ 254 | } 255 | return rval 256 | } 257 | 258 | // ImportFenceWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html 259 | type ImportFenceWin32HandleInfoKHR struct { 260 | // SType = STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR 261 | PNext unsafe.Pointer 262 | Fence Fence 263 | Flags FenceImportFlags 264 | HandleType ExternalFenceHandleTypeFlagBits 265 | Handle windows.Handle 266 | Name unsafe.Pointer 267 | } 268 | 269 | type _vkImportFenceWin32HandleInfoKHR struct { 270 | sType StructureType 271 | pNext unsafe.Pointer 272 | fence Fence 273 | flags FenceImportFlags 274 | handleType ExternalFenceHandleTypeFlagBits 275 | handle windows.Handle 276 | name unsafe.Pointer 277 | } 278 | 279 | func (s *_vkImportFenceWin32HandleInfoKHR) Goify() *ImportFenceWin32HandleInfoKHR { 280 | rval := &ImportFenceWin32HandleInfoKHR{ 281 | PNext: (unsafe.Pointer)(s.pNext), 282 | Fence: (Fence)(s.fence), 283 | Flags: (FenceImportFlags)(s.flags), 284 | HandleType: (ExternalFenceHandleTypeFlagBits)(s.handleType), 285 | Handle: (windows.Handle)(s.handle), 286 | Name: (unsafe.Pointer)(s.name), 287 | } 288 | return rval 289 | } 290 | func (s *ImportFenceWin32HandleInfoKHR) Vulkanize() *_vkImportFenceWin32HandleInfoKHR { 291 | if s == nil { 292 | return nil 293 | } 294 | rval := &_vkImportFenceWin32HandleInfoKHR{ 295 | sType: STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, /*c1*/ 296 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 297 | fence: (Fence)(s.Fence), /*cb*/ 298 | flags: (FenceImportFlags)(s.Flags), /*cb*/ 299 | handleType: (ExternalFenceHandleTypeFlagBits)(s.HandleType), /*cb*/ 300 | handle: (windows.Handle)(s.Handle), /*cb*/ 301 | name: (unsafe.Pointer)(s.Name), /*cb*/ 302 | } 303 | return rval 304 | } 305 | 306 | // ImportMemoryWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html 307 | type ImportMemoryWin32HandleInfoKHR struct { 308 | // SType = STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR 309 | PNext unsafe.Pointer 310 | HandleType ExternalMemoryHandleTypeFlagBits 311 | Handle windows.Handle 312 | Name unsafe.Pointer 313 | } 314 | 315 | type _vkImportMemoryWin32HandleInfoKHR struct { 316 | sType StructureType 317 | pNext unsafe.Pointer 318 | handleType ExternalMemoryHandleTypeFlagBits 319 | handle windows.Handle 320 | name unsafe.Pointer 321 | } 322 | 323 | func (s *_vkImportMemoryWin32HandleInfoKHR) Goify() *ImportMemoryWin32HandleInfoKHR { 324 | rval := &ImportMemoryWin32HandleInfoKHR{ 325 | PNext: (unsafe.Pointer)(s.pNext), 326 | HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType), 327 | Handle: (windows.Handle)(s.handle), 328 | Name: (unsafe.Pointer)(s.name), 329 | } 330 | return rval 331 | } 332 | func (s *ImportMemoryWin32HandleInfoKHR) Vulkanize() *_vkImportMemoryWin32HandleInfoKHR { 333 | if s == nil { 334 | return nil 335 | } 336 | rval := &_vkImportMemoryWin32HandleInfoKHR{ 337 | sType: STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, /*c1*/ 338 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 339 | handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType), /*cb*/ 340 | handle: (windows.Handle)(s.Handle), /*cb*/ 341 | name: (unsafe.Pointer)(s.Name), /*cb*/ 342 | } 343 | return rval 344 | } 345 | 346 | // ImportMemoryWin32HandleInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html 347 | type ImportMemoryWin32HandleInfoNV struct { 348 | // SType = STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV 349 | PNext unsafe.Pointer 350 | HandleType ExternalMemoryHandleTypeFlagsNV 351 | Handle windows.Handle 352 | } 353 | 354 | type _vkImportMemoryWin32HandleInfoNV struct { 355 | sType StructureType 356 | pNext unsafe.Pointer 357 | handleType ExternalMemoryHandleTypeFlagsNV 358 | handle windows.Handle 359 | } 360 | 361 | func (s *_vkImportMemoryWin32HandleInfoNV) Goify() *ImportMemoryWin32HandleInfoNV { 362 | rval := &ImportMemoryWin32HandleInfoNV{ 363 | PNext: (unsafe.Pointer)(s.pNext), 364 | HandleType: (ExternalMemoryHandleTypeFlagsNV)(s.handleType), 365 | Handle: (windows.Handle)(s.handle), 366 | } 367 | return rval 368 | } 369 | func (s *ImportMemoryWin32HandleInfoNV) Vulkanize() *_vkImportMemoryWin32HandleInfoNV { 370 | if s == nil { 371 | return nil 372 | } 373 | rval := &_vkImportMemoryWin32HandleInfoNV{ 374 | sType: STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, /*c1*/ 375 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 376 | handleType: (ExternalMemoryHandleTypeFlagsNV)(s.HandleType), /*cb*/ 377 | handle: (windows.Handle)(s.Handle), /*cb*/ 378 | } 379 | return rval 380 | } 381 | 382 | // ImportSemaphoreWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html 383 | type ImportSemaphoreWin32HandleInfoKHR struct { 384 | // SType = STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR 385 | PNext unsafe.Pointer 386 | Semaphore Semaphore 387 | Flags SemaphoreImportFlags 388 | HandleType ExternalSemaphoreHandleTypeFlagBits 389 | Handle windows.Handle 390 | Name unsafe.Pointer 391 | } 392 | 393 | type _vkImportSemaphoreWin32HandleInfoKHR struct { 394 | sType StructureType 395 | pNext unsafe.Pointer 396 | semaphore Semaphore 397 | flags SemaphoreImportFlags 398 | handleType ExternalSemaphoreHandleTypeFlagBits 399 | handle windows.Handle 400 | name unsafe.Pointer 401 | } 402 | 403 | func (s *_vkImportSemaphoreWin32HandleInfoKHR) Goify() *ImportSemaphoreWin32HandleInfoKHR { 404 | rval := &ImportSemaphoreWin32HandleInfoKHR{ 405 | PNext: (unsafe.Pointer)(s.pNext), 406 | Semaphore: (Semaphore)(s.semaphore), 407 | Flags: (SemaphoreImportFlags)(s.flags), 408 | HandleType: (ExternalSemaphoreHandleTypeFlagBits)(s.handleType), 409 | Handle: (windows.Handle)(s.handle), 410 | Name: (unsafe.Pointer)(s.name), 411 | } 412 | return rval 413 | } 414 | func (s *ImportSemaphoreWin32HandleInfoKHR) Vulkanize() *_vkImportSemaphoreWin32HandleInfoKHR { 415 | if s == nil { 416 | return nil 417 | } 418 | rval := &_vkImportSemaphoreWin32HandleInfoKHR{ 419 | sType: STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, /*c1*/ 420 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 421 | semaphore: (Semaphore)(s.Semaphore), /*cb*/ 422 | flags: (SemaphoreImportFlags)(s.Flags), /*cb*/ 423 | handleType: (ExternalSemaphoreHandleTypeFlagBits)(s.HandleType), /*cb*/ 424 | handle: (windows.Handle)(s.Handle), /*cb*/ 425 | name: (unsafe.Pointer)(s.Name), /*cb*/ 426 | } 427 | return rval 428 | } 429 | 430 | // MemoryGetWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html 431 | type MemoryGetWin32HandleInfoKHR struct { 432 | // SType = STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR 433 | PNext unsafe.Pointer 434 | Memory DeviceMemory 435 | HandleType ExternalMemoryHandleTypeFlagBits 436 | } 437 | 438 | type _vkMemoryGetWin32HandleInfoKHR struct { 439 | sType StructureType 440 | pNext unsafe.Pointer 441 | memory DeviceMemory 442 | handleType ExternalMemoryHandleTypeFlagBits 443 | } 444 | 445 | func (s *_vkMemoryGetWin32HandleInfoKHR) Goify() *MemoryGetWin32HandleInfoKHR { 446 | rval := &MemoryGetWin32HandleInfoKHR{ 447 | PNext: (unsafe.Pointer)(s.pNext), 448 | Memory: (DeviceMemory)(s.memory), 449 | HandleType: (ExternalMemoryHandleTypeFlagBits)(s.handleType), 450 | } 451 | return rval 452 | } 453 | func (s *MemoryGetWin32HandleInfoKHR) Vulkanize() *_vkMemoryGetWin32HandleInfoKHR { 454 | if s == nil { 455 | return nil 456 | } 457 | rval := &_vkMemoryGetWin32HandleInfoKHR{ 458 | sType: STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, /*c1*/ 459 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 460 | memory: (DeviceMemory)(s.Memory), /*cb*/ 461 | handleType: (ExternalMemoryHandleTypeFlagBits)(s.HandleType), /*cb*/ 462 | } 463 | return rval 464 | } 465 | 466 | // MemoryWin32HandlePropertiesKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html 467 | type MemoryWin32HandlePropertiesKHR struct { 468 | // SType = STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR 469 | PNext unsafe.Pointer 470 | MemoryTypeBits uint32 471 | } 472 | 473 | // WARNING - struct MemoryWin32HandlePropertiesKHR is returned only, which is not yet handled in the binding 474 | type _vkMemoryWin32HandlePropertiesKHR struct { 475 | sType StructureType 476 | pNext unsafe.Pointer 477 | memoryTypeBits uint32 478 | } 479 | 480 | func (s *_vkMemoryWin32HandlePropertiesKHR) Goify() *MemoryWin32HandlePropertiesKHR { 481 | rval := &MemoryWin32HandlePropertiesKHR{ 482 | PNext: (unsafe.Pointer)(s.pNext), 483 | MemoryTypeBits: (uint32)(s.memoryTypeBits), 484 | } 485 | return rval 486 | } 487 | func (s *MemoryWin32HandlePropertiesKHR) Vulkanize() *_vkMemoryWin32HandlePropertiesKHR { 488 | if s == nil { 489 | return nil 490 | } 491 | rval := &_vkMemoryWin32HandlePropertiesKHR{ 492 | sType: STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, /*c1*/ 493 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 494 | memoryTypeBits: (uint32)(s.MemoryTypeBits), /*cb*/ 495 | } 496 | return rval 497 | } 498 | 499 | // SemaphoreGetWin32HandleInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html 500 | type SemaphoreGetWin32HandleInfoKHR struct { 501 | // SType = STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR 502 | PNext unsafe.Pointer 503 | Semaphore Semaphore 504 | HandleType ExternalSemaphoreHandleTypeFlagBits 505 | } 506 | 507 | type _vkSemaphoreGetWin32HandleInfoKHR struct { 508 | sType StructureType 509 | pNext unsafe.Pointer 510 | semaphore Semaphore 511 | handleType ExternalSemaphoreHandleTypeFlagBits 512 | } 513 | 514 | func (s *_vkSemaphoreGetWin32HandleInfoKHR) Goify() *SemaphoreGetWin32HandleInfoKHR { 515 | rval := &SemaphoreGetWin32HandleInfoKHR{ 516 | PNext: (unsafe.Pointer)(s.pNext), 517 | Semaphore: (Semaphore)(s.semaphore), 518 | HandleType: (ExternalSemaphoreHandleTypeFlagBits)(s.handleType), 519 | } 520 | return rval 521 | } 522 | func (s *SemaphoreGetWin32HandleInfoKHR) Vulkanize() *_vkSemaphoreGetWin32HandleInfoKHR { 523 | if s == nil { 524 | return nil 525 | } 526 | rval := &_vkSemaphoreGetWin32HandleInfoKHR{ 527 | sType: STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, /*c1*/ 528 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 529 | semaphore: (Semaphore)(s.Semaphore), /*cb*/ 530 | handleType: (ExternalSemaphoreHandleTypeFlagBits)(s.HandleType), /*cb*/ 531 | } 532 | return rval 533 | } 534 | 535 | // SurfaceCapabilitiesFullScreenExclusiveEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html 536 | type SurfaceCapabilitiesFullScreenExclusiveEXT struct { 537 | // SType = STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT 538 | PNext unsafe.Pointer 539 | FullScreenExclusiveSupported bool 540 | } 541 | 542 | type _vkSurfaceCapabilitiesFullScreenExclusiveEXT struct { 543 | sType StructureType 544 | pNext unsafe.Pointer 545 | fullScreenExclusiveSupported Bool32 546 | } 547 | 548 | func (s *_vkSurfaceCapabilitiesFullScreenExclusiveEXT) Goify() *SurfaceCapabilitiesFullScreenExclusiveEXT { 549 | rval := &SurfaceCapabilitiesFullScreenExclusiveEXT{ 550 | PNext: (unsafe.Pointer)(s.pNext), 551 | FullScreenExclusiveSupported: translatePublic_Bool32(s.fullScreenExclusiveSupported), /*default*/ 552 | } 553 | return rval 554 | } 555 | func (s *SurfaceCapabilitiesFullScreenExclusiveEXT) Vulkanize() *_vkSurfaceCapabilitiesFullScreenExclusiveEXT { 556 | if s == nil { 557 | return nil 558 | } 559 | rval := &_vkSurfaceCapabilitiesFullScreenExclusiveEXT{ 560 | sType: STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, /*c1*/ 561 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 562 | fullScreenExclusiveSupported: translateInternal_Bool32(s.FullScreenExclusiveSupported), /*default*/ 563 | } 564 | return rval 565 | } 566 | 567 | // SurfaceFullScreenExclusiveInfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html 568 | type SurfaceFullScreenExclusiveInfoEXT struct { 569 | // SType = STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT 570 | PNext unsafe.Pointer 571 | FullScreenExclusive FullScreenExclusiveEXT 572 | } 573 | 574 | type _vkSurfaceFullScreenExclusiveInfoEXT struct { 575 | sType StructureType 576 | pNext unsafe.Pointer 577 | fullScreenExclusive FullScreenExclusiveEXT 578 | } 579 | 580 | func (s *_vkSurfaceFullScreenExclusiveInfoEXT) Goify() *SurfaceFullScreenExclusiveInfoEXT { 581 | rval := &SurfaceFullScreenExclusiveInfoEXT{ 582 | PNext: (unsafe.Pointer)(s.pNext), 583 | FullScreenExclusive: (FullScreenExclusiveEXT)(s.fullScreenExclusive), 584 | } 585 | return rval 586 | } 587 | func (s *SurfaceFullScreenExclusiveInfoEXT) Vulkanize() *_vkSurfaceFullScreenExclusiveInfoEXT { 588 | if s == nil { 589 | return nil 590 | } 591 | rval := &_vkSurfaceFullScreenExclusiveInfoEXT{ 592 | sType: STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, /*c1*/ 593 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 594 | fullScreenExclusive: (FullScreenExclusiveEXT)(s.FullScreenExclusive), /*cb*/ 595 | } 596 | return rval 597 | } 598 | 599 | // SurfaceFullScreenExclusiveWin32InfoEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html 600 | type SurfaceFullScreenExclusiveWin32InfoEXT struct { 601 | // SType = STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT 602 | PNext unsafe.Pointer 603 | Hmonitor windows.Handle 604 | } 605 | 606 | type _vkSurfaceFullScreenExclusiveWin32InfoEXT struct { 607 | sType StructureType 608 | pNext unsafe.Pointer 609 | hmonitor windows.Handle 610 | } 611 | 612 | func (s *_vkSurfaceFullScreenExclusiveWin32InfoEXT) Goify() *SurfaceFullScreenExclusiveWin32InfoEXT { 613 | rval := &SurfaceFullScreenExclusiveWin32InfoEXT{ 614 | PNext: (unsafe.Pointer)(s.pNext), 615 | Hmonitor: (windows.Handle)(s.hmonitor), 616 | } 617 | return rval 618 | } 619 | func (s *SurfaceFullScreenExclusiveWin32InfoEXT) Vulkanize() *_vkSurfaceFullScreenExclusiveWin32InfoEXT { 620 | if s == nil { 621 | return nil 622 | } 623 | rval := &_vkSurfaceFullScreenExclusiveWin32InfoEXT{ 624 | sType: STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, /*c1*/ 625 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 626 | hmonitor: (windows.Handle)(s.Hmonitor), /*cb*/ 627 | } 628 | return rval 629 | } 630 | 631 | // Win32KeyedMutexAcquireReleaseInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html 632 | type Win32KeyedMutexAcquireReleaseInfoKHR struct { 633 | // SType = STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR 634 | PNext unsafe.Pointer 635 | // acquireCount 636 | PAcquireSyncs []DeviceMemory 637 | PAcquireKeys []uint64 638 | PAcquireTimeouts []uint32 639 | // releaseCount 640 | PReleaseSyncs []DeviceMemory 641 | PReleaseKeys []uint64 642 | } 643 | 644 | type _vkWin32KeyedMutexAcquireReleaseInfoKHR struct { 645 | sType StructureType 646 | pNext unsafe.Pointer 647 | acquireCount uint32 648 | pAcquireSyncs *DeviceMemory 649 | pAcquireKeys *uint64 650 | pAcquireTimeouts *uint32 651 | releaseCount uint32 652 | pReleaseSyncs *DeviceMemory 653 | pReleaseKeys *uint64 654 | } 655 | 656 | func (s *_vkWin32KeyedMutexAcquireReleaseInfoKHR) Goify() *Win32KeyedMutexAcquireReleaseInfoKHR { 657 | rval := &Win32KeyedMutexAcquireReleaseInfoKHR{ 658 | PNext: (unsafe.Pointer)(s.pNext), 659 | // Unexpected 'isLenForAnotherMember'! 660 | // Unexpected pointer member pAcquireSyncs in returned struct 661 | // Unexpected pointer member pAcquireKeys in returned struct 662 | // Unexpected pointer member pAcquireTimeouts in returned struct 663 | // Unexpected 'isLenForAnotherMember'! 664 | // Unexpected pointer member pReleaseSyncs in returned struct 665 | // Unexpected pointer member pReleaseKeys in returned struct 666 | } 667 | return rval 668 | } 669 | func (s *Win32KeyedMutexAcquireReleaseInfoKHR) Vulkanize() *_vkWin32KeyedMutexAcquireReleaseInfoKHR { 670 | if s == nil { 671 | return nil 672 | } 673 | 674 | var psl_pAcquireSyncs *DeviceMemory 675 | if len(s.PAcquireSyncs) > 0 { 676 | psl_pAcquireSyncs = &s.PAcquireSyncs[0] 677 | } 678 | 679 | var psl_pAcquireKeys *uint64 680 | if len(s.PAcquireKeys) > 0 { 681 | psl_pAcquireKeys = &s.PAcquireKeys[0] 682 | } 683 | 684 | var psl_pAcquireTimeouts *uint32 685 | if len(s.PAcquireTimeouts) > 0 { 686 | psl_pAcquireTimeouts = &s.PAcquireTimeouts[0] 687 | } 688 | 689 | var psl_pReleaseSyncs *DeviceMemory 690 | if len(s.PReleaseSyncs) > 0 { 691 | psl_pReleaseSyncs = &s.PReleaseSyncs[0] 692 | } 693 | 694 | var psl_pReleaseKeys *uint64 695 | if len(s.PReleaseKeys) > 0 { 696 | psl_pReleaseKeys = &s.PReleaseKeys[0] 697 | } 698 | rval := &_vkWin32KeyedMutexAcquireReleaseInfoKHR{ 699 | sType: STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, /*c1*/ 700 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 701 | pAcquireSyncs: psl_pAcquireSyncs, /*c rem*/ 702 | pAcquireKeys: psl_pAcquireKeys, /*c rem*/ 703 | pAcquireTimeouts: psl_pAcquireTimeouts, /*c rem*/ 704 | pReleaseSyncs: psl_pReleaseSyncs, /*c rem*/ 705 | pReleaseKeys: psl_pReleaseKeys, /*c rem*/ 706 | } 707 | rval.acquireCount = 0 // c6-b 708 | if uint32(len(s.PAcquireSyncs)) > rval.acquireCount { 709 | rval.acquireCount = uint32(len(s.PAcquireSyncs)) 710 | } 711 | if uint32(len(s.PAcquireKeys)) > rval.acquireCount { 712 | rval.acquireCount = uint32(len(s.PAcquireKeys)) 713 | } 714 | if uint32(len(s.PAcquireTimeouts)) > rval.acquireCount { 715 | rval.acquireCount = uint32(len(s.PAcquireTimeouts)) 716 | } 717 | rval.releaseCount = 0 // c6-b 718 | if uint32(len(s.PReleaseSyncs)) > rval.releaseCount { 719 | rval.releaseCount = uint32(len(s.PReleaseSyncs)) 720 | } 721 | if uint32(len(s.PReleaseKeys)) > rval.releaseCount { 722 | rval.releaseCount = uint32(len(s.PReleaseKeys)) 723 | } 724 | return rval 725 | } 726 | 727 | // Win32KeyedMutexAcquireReleaseInfoNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html 728 | type Win32KeyedMutexAcquireReleaseInfoNV struct { 729 | // SType = STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV 730 | PNext unsafe.Pointer 731 | // acquireCount 732 | PAcquireSyncs []DeviceMemory 733 | PAcquireKeys []uint64 734 | PAcquireTimeoutMilliseconds []uint32 735 | // releaseCount 736 | PReleaseSyncs []DeviceMemory 737 | PReleaseKeys []uint64 738 | } 739 | 740 | type _vkWin32KeyedMutexAcquireReleaseInfoNV struct { 741 | sType StructureType 742 | pNext unsafe.Pointer 743 | acquireCount uint32 744 | pAcquireSyncs *DeviceMemory 745 | pAcquireKeys *uint64 746 | pAcquireTimeoutMilliseconds *uint32 747 | releaseCount uint32 748 | pReleaseSyncs *DeviceMemory 749 | pReleaseKeys *uint64 750 | } 751 | 752 | func (s *_vkWin32KeyedMutexAcquireReleaseInfoNV) Goify() *Win32KeyedMutexAcquireReleaseInfoNV { 753 | rval := &Win32KeyedMutexAcquireReleaseInfoNV{ 754 | PNext: (unsafe.Pointer)(s.pNext), 755 | // Unexpected 'isLenForAnotherMember'! 756 | // Unexpected pointer member pAcquireSyncs in returned struct 757 | // Unexpected pointer member pAcquireKeys in returned struct 758 | // Unexpected pointer member pAcquireTimeoutMilliseconds in returned struct 759 | // Unexpected 'isLenForAnotherMember'! 760 | // Unexpected pointer member pReleaseSyncs in returned struct 761 | // Unexpected pointer member pReleaseKeys in returned struct 762 | } 763 | return rval 764 | } 765 | func (s *Win32KeyedMutexAcquireReleaseInfoNV) Vulkanize() *_vkWin32KeyedMutexAcquireReleaseInfoNV { 766 | if s == nil { 767 | return nil 768 | } 769 | 770 | var psl_pAcquireSyncs *DeviceMemory 771 | if len(s.PAcquireSyncs) > 0 { 772 | psl_pAcquireSyncs = &s.PAcquireSyncs[0] 773 | } 774 | 775 | var psl_pAcquireKeys *uint64 776 | if len(s.PAcquireKeys) > 0 { 777 | psl_pAcquireKeys = &s.PAcquireKeys[0] 778 | } 779 | 780 | var psl_pAcquireTimeoutMilliseconds *uint32 781 | if len(s.PAcquireTimeoutMilliseconds) > 0 { 782 | psl_pAcquireTimeoutMilliseconds = &s.PAcquireTimeoutMilliseconds[0] 783 | } 784 | 785 | var psl_pReleaseSyncs *DeviceMemory 786 | if len(s.PReleaseSyncs) > 0 { 787 | psl_pReleaseSyncs = &s.PReleaseSyncs[0] 788 | } 789 | 790 | var psl_pReleaseKeys *uint64 791 | if len(s.PReleaseKeys) > 0 { 792 | psl_pReleaseKeys = &s.PReleaseKeys[0] 793 | } 794 | rval := &_vkWin32KeyedMutexAcquireReleaseInfoNV{ 795 | sType: STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, /*c1*/ 796 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 797 | pAcquireSyncs: psl_pAcquireSyncs, /*c rem*/ 798 | pAcquireKeys: psl_pAcquireKeys, /*c rem*/ 799 | pAcquireTimeoutMilliseconds: psl_pAcquireTimeoutMilliseconds, /*c rem*/ 800 | pReleaseSyncs: psl_pReleaseSyncs, /*c rem*/ 801 | pReleaseKeys: psl_pReleaseKeys, /*c rem*/ 802 | } 803 | rval.acquireCount = 0 // c6-b 804 | if uint32(len(s.PAcquireSyncs)) > rval.acquireCount { 805 | rval.acquireCount = uint32(len(s.PAcquireSyncs)) 806 | } 807 | if uint32(len(s.PAcquireKeys)) > rval.acquireCount { 808 | rval.acquireCount = uint32(len(s.PAcquireKeys)) 809 | } 810 | if uint32(len(s.PAcquireTimeoutMilliseconds)) > rval.acquireCount { 811 | rval.acquireCount = uint32(len(s.PAcquireTimeoutMilliseconds)) 812 | } 813 | rval.releaseCount = 0 // c6-b 814 | if uint32(len(s.PReleaseSyncs)) > rval.releaseCount { 815 | rval.releaseCount = uint32(len(s.PReleaseSyncs)) 816 | } 817 | if uint32(len(s.PReleaseKeys)) > rval.releaseCount { 818 | rval.releaseCount = uint32(len(s.PReleaseKeys)) 819 | } 820 | return rval 821 | } 822 | 823 | // Win32SurfaceCreateInfoKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html 824 | type Win32SurfaceCreateInfoKHR struct { 825 | // SType = STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR 826 | PNext unsafe.Pointer 827 | Flags Win32SurfaceCreateFlagsKHR 828 | Hinstance windows.Handle 829 | Hwnd windows.HWND 830 | } 831 | 832 | type _vkWin32SurfaceCreateInfoKHR struct { 833 | sType StructureType 834 | pNext unsafe.Pointer 835 | flags Win32SurfaceCreateFlagsKHR 836 | hinstance windows.Handle 837 | hwnd windows.HWND 838 | } 839 | 840 | func (s *_vkWin32SurfaceCreateInfoKHR) Goify() *Win32SurfaceCreateInfoKHR { 841 | rval := &Win32SurfaceCreateInfoKHR{ 842 | PNext: (unsafe.Pointer)(s.pNext), 843 | Flags: (Win32SurfaceCreateFlagsKHR)(s.flags), 844 | Hinstance: (windows.Handle)(s.hinstance), 845 | Hwnd: (windows.HWND)(s.hwnd), 846 | } 847 | return rval 848 | } 849 | func (s *Win32SurfaceCreateInfoKHR) Vulkanize() *_vkWin32SurfaceCreateInfoKHR { 850 | if s == nil { 851 | return nil 852 | } 853 | rval := &_vkWin32SurfaceCreateInfoKHR{ 854 | sType: STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, /*c1*/ 855 | pNext: (unsafe.Pointer)(s.PNext), /*cb*/ 856 | flags: (Win32SurfaceCreateFlagsKHR)(s.Flags), /*cb*/ 857 | hinstance: (windows.Handle)(s.Hinstance), /*cb*/ 858 | hwnd: (windows.HWND)(s.Hwnd), /*cb*/ 859 | } 860 | return rval 861 | } 862 | -------------------------------------------------------------------------------- /sys_unix.go: -------------------------------------------------------------------------------- 1 | //go:build darwin || linux 2 | 3 | package vk 4 | 5 | import ( 6 | "golang.org/x/sys/unix" 7 | ) 8 | 9 | func sys_stringToBytePointer(s string) *byte { 10 | p, _ := unix.BytePtrFromString(s) 11 | return p 12 | } 13 | -------------------------------------------------------------------------------- /sys_windows.go: -------------------------------------------------------------------------------- 1 | //go:build windows 2 | 3 | package vk 4 | 5 | import "golang.org/x/sys/windows" 6 | 7 | func sys_stringToBytePointer(s string) *byte { 8 | p, _ := windows.BytePtrFromString(s) 9 | return p 10 | } 11 | -------------------------------------------------------------------------------- /union.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-vk from vk-1.3.270.xml at 2023-11-22 10:57:10.135751 -0500 EST m=+2.661192870. DO NOT EDIT. 2 | 3 | package vk 4 | 5 | import "unsafe" 6 | 7 | // AccelerationStructureGeometryDataKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html 8 | type AccelerationStructureGeometryDataKHR struct { 9 | Triangles AccelerationStructureGeometryTrianglesDataKHR 10 | asTriangles bool 11 | Aabbs AccelerationStructureGeometryAabbsDataKHR 12 | asAabbs bool 13 | Instances AccelerationStructureGeometryInstancesDataKHR 14 | asInstances bool 15 | } 16 | 17 | func (u *AccelerationStructureGeometryDataKHR) AsTriangles(val AccelerationStructureGeometryTrianglesDataKHR) { 18 | u.Triangles = val 19 | u.asTriangles = true 20 | u.asAabbs = false 21 | u.asInstances = false 22 | } 23 | 24 | func (u *AccelerationStructureGeometryDataKHR) AsAabbs(val AccelerationStructureGeometryAabbsDataKHR) { 25 | u.Aabbs = val 26 | u.asTriangles = false 27 | u.asAabbs = true 28 | u.asInstances = false 29 | } 30 | 31 | func (u *AccelerationStructureGeometryDataKHR) AsInstances(val AccelerationStructureGeometryInstancesDataKHR) { 32 | u.Instances = val 33 | u.asTriangles = false 34 | u.asAabbs = false 35 | u.asInstances = true 36 | } 37 | 38 | type _vkAccelerationStructureGeometryDataKHR [unsafe.Sizeof(_vkAccelerationStructureGeometryTrianglesDataKHR{})]byte 39 | 40 | func (u *AccelerationStructureGeometryDataKHR) Vulkanize() *_vkAccelerationStructureGeometryDataKHR { 41 | switch true { 42 | case u.asTriangles: 43 | return (*_vkAccelerationStructureGeometryDataKHR)(unsafe.Pointer(&u.Triangles)) 44 | case u.asAabbs: 45 | return (*_vkAccelerationStructureGeometryDataKHR)(unsafe.Pointer(&u.Aabbs)) 46 | case u.asInstances: 47 | return (*_vkAccelerationStructureGeometryDataKHR)(unsafe.Pointer(&u.Instances)) 48 | default: 49 | return &_vkAccelerationStructureGeometryDataKHR{} 50 | } 51 | } 52 | 53 | // AccelerationStructureMotionInstanceDataNV: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html 54 | type AccelerationStructureMotionInstanceDataNV struct { 55 | StaticInstance AccelerationStructureInstanceKHR 56 | asStaticInstance bool 57 | MatrixMotionInstance AccelerationStructureMatrixMotionInstanceNV 58 | asMatrixMotionInstance bool 59 | SrtMotionInstance AccelerationStructureSRTMotionInstanceNV 60 | asSrtMotionInstance bool 61 | } 62 | 63 | func (u *AccelerationStructureMotionInstanceDataNV) AsStaticInstance(val AccelerationStructureInstanceKHR) { 64 | u.StaticInstance = val 65 | u.asStaticInstance = true 66 | u.asMatrixMotionInstance = false 67 | u.asSrtMotionInstance = false 68 | } 69 | 70 | func (u *AccelerationStructureMotionInstanceDataNV) AsMatrixMotionInstance(val AccelerationStructureMatrixMotionInstanceNV) { 71 | u.MatrixMotionInstance = val 72 | u.asStaticInstance = false 73 | u.asMatrixMotionInstance = true 74 | u.asSrtMotionInstance = false 75 | } 76 | 77 | func (u *AccelerationStructureMotionInstanceDataNV) AsSrtMotionInstance(val AccelerationStructureSRTMotionInstanceNV) { 78 | u.SrtMotionInstance = val 79 | u.asStaticInstance = false 80 | u.asMatrixMotionInstance = false 81 | u.asSrtMotionInstance = true 82 | } 83 | 84 | type _vkAccelerationStructureMotionInstanceDataNV [unsafe.Sizeof(_vkAccelerationStructureMatrixMotionInstanceNV{})]byte 85 | 86 | func (u *AccelerationStructureMotionInstanceDataNV) Vulkanize() *_vkAccelerationStructureMotionInstanceDataNV { 87 | switch true { 88 | case u.asStaticInstance: 89 | return (*_vkAccelerationStructureMotionInstanceDataNV)(unsafe.Pointer(&u.StaticInstance)) 90 | case u.asMatrixMotionInstance: 91 | return (*_vkAccelerationStructureMotionInstanceDataNV)(unsafe.Pointer(&u.MatrixMotionInstance)) 92 | case u.asSrtMotionInstance: 93 | return (*_vkAccelerationStructureMotionInstanceDataNV)(unsafe.Pointer(&u.SrtMotionInstance)) 94 | default: 95 | return &_vkAccelerationStructureMotionInstanceDataNV{} 96 | } 97 | } 98 | 99 | // ClearColorValue: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearColorValue.html 100 | type ClearColorValue struct { 101 | TypeFloat32 [4]float32 102 | asTypeFloat32 bool 103 | TypeInt32 [4]int32 104 | asTypeInt32 bool 105 | TypeUint32 [4]uint32 106 | asTypeUint32 bool 107 | } 108 | 109 | func (u *ClearColorValue) AsTypeFloat32(val [4]float32) { 110 | u.TypeFloat32 = val 111 | u.asTypeFloat32 = true 112 | u.asTypeInt32 = false 113 | u.asTypeUint32 = false 114 | } 115 | 116 | func (u *ClearColorValue) AsTypeInt32(val [4]int32) { 117 | u.TypeInt32 = val 118 | u.asTypeFloat32 = false 119 | u.asTypeInt32 = true 120 | u.asTypeUint32 = false 121 | } 122 | 123 | func (u *ClearColorValue) AsTypeUint32(val [4]uint32) { 124 | u.TypeUint32 = val 125 | u.asTypeFloat32 = false 126 | u.asTypeInt32 = false 127 | u.asTypeUint32 = true 128 | } 129 | 130 | type _vkClearColorValue [unsafe.Sizeof([4]float32{})]byte 131 | 132 | func (u *ClearColorValue) Vulkanize() *_vkClearColorValue { 133 | switch true { 134 | case u.asTypeFloat32: 135 | return (*_vkClearColorValue)(unsafe.Pointer(&u.TypeFloat32)) 136 | case u.asTypeInt32: 137 | return (*_vkClearColorValue)(unsafe.Pointer(&u.TypeInt32)) 138 | case u.asTypeUint32: 139 | return (*_vkClearColorValue)(unsafe.Pointer(&u.TypeUint32)) 140 | default: 141 | return &_vkClearColorValue{} 142 | } 143 | } 144 | 145 | // ClearValue: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearValue.html 146 | type ClearValue struct { 147 | Color ClearColorValue 148 | asColor bool 149 | DepthStencil ClearDepthStencilValue 150 | asDepthStencil bool 151 | } 152 | 153 | func (u *ClearValue) AsColor(val ClearColorValue) { 154 | u.Color = val 155 | u.asColor = true 156 | u.asDepthStencil = false 157 | } 158 | 159 | func (u *ClearValue) AsDepthStencil(val ClearDepthStencilValue) { 160 | u.DepthStencil = val 161 | u.asColor = false 162 | u.asDepthStencil = true 163 | } 164 | 165 | type _vkClearValue [unsafe.Sizeof(_vkClearColorValue{})]byte 166 | 167 | func (u *ClearValue) Vulkanize() *_vkClearValue { 168 | switch true { 169 | case u.asColor: 170 | return (*_vkClearValue)(unsafe.Pointer(&u.Color)) 171 | case u.asDepthStencil: 172 | return (*_vkClearValue)(unsafe.Pointer(&u.DepthStencil)) 173 | default: 174 | return &_vkClearValue{} 175 | } 176 | } 177 | 178 | // DescriptorDataEXT: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorDataEXT.html 179 | type DescriptorDataEXT struct { 180 | PSampler *Sampler 181 | asPSampler bool 182 | PCombinedImageSampler *DescriptorImageInfo 183 | asPCombinedImageSampler bool 184 | PInputAttachmentImage *DescriptorImageInfo 185 | asPInputAttachmentImage bool 186 | PSampledImage *DescriptorImageInfo 187 | asPSampledImage bool 188 | PStorageImage *DescriptorImageInfo 189 | asPStorageImage bool 190 | PUniformTexelBuffer *DescriptorAddressInfoEXT 191 | asPUniformTexelBuffer bool 192 | PStorageTexelBuffer *DescriptorAddressInfoEXT 193 | asPStorageTexelBuffer bool 194 | PUniformBuffer *DescriptorAddressInfoEXT 195 | asPUniformBuffer bool 196 | PStorageBuffer *DescriptorAddressInfoEXT 197 | asPStorageBuffer bool 198 | AccelerationStructure DeviceAddress 199 | asAccelerationStructure bool 200 | } 201 | 202 | func (u *DescriptorDataEXT) AsPSampler(ptr *Sampler) { 203 | u.PSampler = ptr 204 | u.asPSampler = true 205 | u.asPCombinedImageSampler = false 206 | u.asPInputAttachmentImage = false 207 | u.asPSampledImage = false 208 | u.asPStorageImage = false 209 | u.asPUniformTexelBuffer = false 210 | u.asPStorageTexelBuffer = false 211 | u.asPUniformBuffer = false 212 | u.asPStorageBuffer = false 213 | u.asAccelerationStructure = false 214 | } 215 | 216 | func (u *DescriptorDataEXT) AsPCombinedImageSampler(ptr *DescriptorImageInfo) { 217 | u.PCombinedImageSampler = ptr 218 | u.asPSampler = false 219 | u.asPCombinedImageSampler = true 220 | u.asPInputAttachmentImage = false 221 | u.asPSampledImage = false 222 | u.asPStorageImage = false 223 | u.asPUniformTexelBuffer = false 224 | u.asPStorageTexelBuffer = false 225 | u.asPUniformBuffer = false 226 | u.asPStorageBuffer = false 227 | u.asAccelerationStructure = false 228 | } 229 | 230 | func (u *DescriptorDataEXT) AsPInputAttachmentImage(ptr *DescriptorImageInfo) { 231 | u.PInputAttachmentImage = ptr 232 | u.asPSampler = false 233 | u.asPCombinedImageSampler = false 234 | u.asPInputAttachmentImage = true 235 | u.asPSampledImage = false 236 | u.asPStorageImage = false 237 | u.asPUniformTexelBuffer = false 238 | u.asPStorageTexelBuffer = false 239 | u.asPUniformBuffer = false 240 | u.asPStorageBuffer = false 241 | u.asAccelerationStructure = false 242 | } 243 | 244 | func (u *DescriptorDataEXT) AsPSampledImage(ptr *DescriptorImageInfo) { 245 | u.PSampledImage = ptr 246 | u.asPSampler = false 247 | u.asPCombinedImageSampler = false 248 | u.asPInputAttachmentImage = false 249 | u.asPSampledImage = true 250 | u.asPStorageImage = false 251 | u.asPUniformTexelBuffer = false 252 | u.asPStorageTexelBuffer = false 253 | u.asPUniformBuffer = false 254 | u.asPStorageBuffer = false 255 | u.asAccelerationStructure = false 256 | } 257 | 258 | func (u *DescriptorDataEXT) AsPStorageImage(ptr *DescriptorImageInfo) { 259 | u.PStorageImage = ptr 260 | u.asPSampler = false 261 | u.asPCombinedImageSampler = false 262 | u.asPInputAttachmentImage = false 263 | u.asPSampledImage = false 264 | u.asPStorageImage = true 265 | u.asPUniformTexelBuffer = false 266 | u.asPStorageTexelBuffer = false 267 | u.asPUniformBuffer = false 268 | u.asPStorageBuffer = false 269 | u.asAccelerationStructure = false 270 | } 271 | 272 | func (u *DescriptorDataEXT) AsPUniformTexelBuffer(ptr *DescriptorAddressInfoEXT) { 273 | u.PUniformTexelBuffer = ptr 274 | u.asPSampler = false 275 | u.asPCombinedImageSampler = false 276 | u.asPInputAttachmentImage = false 277 | u.asPSampledImage = false 278 | u.asPStorageImage = false 279 | u.asPUniformTexelBuffer = true 280 | u.asPStorageTexelBuffer = false 281 | u.asPUniformBuffer = false 282 | u.asPStorageBuffer = false 283 | u.asAccelerationStructure = false 284 | } 285 | 286 | func (u *DescriptorDataEXT) AsPStorageTexelBuffer(ptr *DescriptorAddressInfoEXT) { 287 | u.PStorageTexelBuffer = ptr 288 | u.asPSampler = false 289 | u.asPCombinedImageSampler = false 290 | u.asPInputAttachmentImage = false 291 | u.asPSampledImage = false 292 | u.asPStorageImage = false 293 | u.asPUniformTexelBuffer = false 294 | u.asPStorageTexelBuffer = true 295 | u.asPUniformBuffer = false 296 | u.asPStorageBuffer = false 297 | u.asAccelerationStructure = false 298 | } 299 | 300 | func (u *DescriptorDataEXT) AsPUniformBuffer(ptr *DescriptorAddressInfoEXT) { 301 | u.PUniformBuffer = ptr 302 | u.asPSampler = false 303 | u.asPCombinedImageSampler = false 304 | u.asPInputAttachmentImage = false 305 | u.asPSampledImage = false 306 | u.asPStorageImage = false 307 | u.asPUniformTexelBuffer = false 308 | u.asPStorageTexelBuffer = false 309 | u.asPUniformBuffer = true 310 | u.asPStorageBuffer = false 311 | u.asAccelerationStructure = false 312 | } 313 | 314 | func (u *DescriptorDataEXT) AsPStorageBuffer(ptr *DescriptorAddressInfoEXT) { 315 | u.PStorageBuffer = ptr 316 | u.asPSampler = false 317 | u.asPCombinedImageSampler = false 318 | u.asPInputAttachmentImage = false 319 | u.asPSampledImage = false 320 | u.asPStorageImage = false 321 | u.asPUniformTexelBuffer = false 322 | u.asPStorageTexelBuffer = false 323 | u.asPUniformBuffer = false 324 | u.asPStorageBuffer = true 325 | u.asAccelerationStructure = false 326 | } 327 | 328 | func (u *DescriptorDataEXT) AsAccelerationStructure(val DeviceAddress) { 329 | u.AccelerationStructure = val 330 | u.asPSampler = false 331 | u.asPCombinedImageSampler = false 332 | u.asPInputAttachmentImage = false 333 | u.asPSampledImage = false 334 | u.asPStorageImage = false 335 | u.asPUniformTexelBuffer = false 336 | u.asPStorageTexelBuffer = false 337 | u.asPUniformBuffer = false 338 | u.asPStorageBuffer = false 339 | u.asAccelerationStructure = true 340 | } 341 | 342 | type _vkDescriptorDataEXT [unsafe.Sizeof((*Sampler)(nil))]byte 343 | 344 | func (u *DescriptorDataEXT) Vulkanize() *_vkDescriptorDataEXT { 345 | switch true { 346 | case u.asPSampler: 347 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PSampler)) 348 | case u.asPCombinedImageSampler: 349 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PCombinedImageSampler)) 350 | case u.asPInputAttachmentImage: 351 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PInputAttachmentImage)) 352 | case u.asPSampledImage: 353 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PSampledImage)) 354 | case u.asPStorageImage: 355 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PStorageImage)) 356 | case u.asPUniformTexelBuffer: 357 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PUniformTexelBuffer)) 358 | case u.asPStorageTexelBuffer: 359 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PStorageTexelBuffer)) 360 | case u.asPUniformBuffer: 361 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PUniformBuffer)) 362 | case u.asPStorageBuffer: 363 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.PStorageBuffer)) 364 | case u.asAccelerationStructure: 365 | return (*_vkDescriptorDataEXT)(unsafe.Pointer(&u.AccelerationStructure)) 366 | default: 367 | return &_vkDescriptorDataEXT{} 368 | } 369 | } 370 | 371 | // DeviceOrHostAddressConstKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressConstKHR.html 372 | type DeviceOrHostAddressConstKHR struct { 373 | DeviceAddress DeviceAddress 374 | asDeviceAddress bool 375 | HostAddress unsafe.Pointer 376 | asHostAddress bool 377 | } 378 | 379 | func (u *DeviceOrHostAddressConstKHR) AsDeviceAddress(val DeviceAddress) { 380 | u.DeviceAddress = val 381 | u.asDeviceAddress = true 382 | u.asHostAddress = false 383 | } 384 | 385 | func (u *DeviceOrHostAddressConstKHR) AsHostAddress(val unsafe.Pointer) { 386 | u.HostAddress = val 387 | u.asDeviceAddress = false 388 | u.asHostAddress = true 389 | } 390 | 391 | type _vkDeviceOrHostAddressConstKHR [8]byte 392 | 393 | func (u *DeviceOrHostAddressConstKHR) Vulkanize() *_vkDeviceOrHostAddressConstKHR { 394 | switch true { 395 | case u.asDeviceAddress: 396 | return (*_vkDeviceOrHostAddressConstKHR)(unsafe.Pointer(&u.DeviceAddress)) 397 | case u.asHostAddress: 398 | return (*_vkDeviceOrHostAddressConstKHR)(unsafe.Pointer(&u.HostAddress)) 399 | default: 400 | return &_vkDeviceOrHostAddressConstKHR{} 401 | } 402 | } 403 | 404 | // DeviceOrHostAddressKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressKHR.html 405 | type DeviceOrHostAddressKHR struct { 406 | DeviceAddress DeviceAddress 407 | asDeviceAddress bool 408 | HostAddress unsafe.Pointer 409 | asHostAddress bool 410 | } 411 | 412 | func (u *DeviceOrHostAddressKHR) AsDeviceAddress(val DeviceAddress) { 413 | u.DeviceAddress = val 414 | u.asDeviceAddress = true 415 | u.asHostAddress = false 416 | } 417 | 418 | func (u *DeviceOrHostAddressKHR) AsHostAddress(val unsafe.Pointer) { 419 | u.HostAddress = val 420 | u.asDeviceAddress = false 421 | u.asHostAddress = true 422 | } 423 | 424 | type _vkDeviceOrHostAddressKHR [8]byte 425 | 426 | func (u *DeviceOrHostAddressKHR) Vulkanize() *_vkDeviceOrHostAddressKHR { 427 | switch true { 428 | case u.asDeviceAddress: 429 | return (*_vkDeviceOrHostAddressKHR)(unsafe.Pointer(&u.DeviceAddress)) 430 | case u.asHostAddress: 431 | return (*_vkDeviceOrHostAddressKHR)(unsafe.Pointer(&u.HostAddress)) 432 | default: 433 | return &_vkDeviceOrHostAddressKHR{} 434 | } 435 | } 436 | 437 | // PerformanceCounterResultKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterResultKHR.html 438 | type PerformanceCounterResultKHR struct { 439 | TypeInt32 int32 440 | asTypeInt32 bool 441 | Int64 int64 442 | asInt64 bool 443 | TypeUint32 uint32 444 | asTypeUint32 bool 445 | Uint64 uint64 446 | asUint64 bool 447 | TypeFloat32 float32 448 | asTypeFloat32 bool 449 | Float64 float64 450 | asFloat64 bool 451 | } 452 | 453 | func (u *PerformanceCounterResultKHR) AsTypeInt32(val int32) { 454 | u.TypeInt32 = val 455 | u.asTypeInt32 = true 456 | u.asInt64 = false 457 | u.asTypeUint32 = false 458 | u.asUint64 = false 459 | u.asTypeFloat32 = false 460 | u.asFloat64 = false 461 | } 462 | 463 | func (u *PerformanceCounterResultKHR) AsInt64(val int64) { 464 | u.Int64 = val 465 | u.asTypeInt32 = false 466 | u.asInt64 = true 467 | u.asTypeUint32 = false 468 | u.asUint64 = false 469 | u.asTypeFloat32 = false 470 | u.asFloat64 = false 471 | } 472 | 473 | func (u *PerformanceCounterResultKHR) AsTypeUint32(val uint32) { 474 | u.TypeUint32 = val 475 | u.asTypeInt32 = false 476 | u.asInt64 = false 477 | u.asTypeUint32 = true 478 | u.asUint64 = false 479 | u.asTypeFloat32 = false 480 | u.asFloat64 = false 481 | } 482 | 483 | func (u *PerformanceCounterResultKHR) AsUint64(val uint64) { 484 | u.Uint64 = val 485 | u.asTypeInt32 = false 486 | u.asInt64 = false 487 | u.asTypeUint32 = false 488 | u.asUint64 = true 489 | u.asTypeFloat32 = false 490 | u.asFloat64 = false 491 | } 492 | 493 | func (u *PerformanceCounterResultKHR) AsTypeFloat32(val float32) { 494 | u.TypeFloat32 = val 495 | u.asTypeInt32 = false 496 | u.asInt64 = false 497 | u.asTypeUint32 = false 498 | u.asUint64 = false 499 | u.asTypeFloat32 = true 500 | u.asFloat64 = false 501 | } 502 | 503 | func (u *PerformanceCounterResultKHR) AsFloat64(val float64) { 504 | u.Float64 = val 505 | u.asTypeInt32 = false 506 | u.asInt64 = false 507 | u.asTypeUint32 = false 508 | u.asUint64 = false 509 | u.asTypeFloat32 = false 510 | u.asFloat64 = true 511 | } 512 | 513 | type _vkPerformanceCounterResultKHR [8]byte 514 | 515 | func (u *PerformanceCounterResultKHR) Vulkanize() *_vkPerformanceCounterResultKHR { 516 | switch true { 517 | case u.asTypeInt32: 518 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.TypeInt32)) 519 | case u.asInt64: 520 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.Int64)) 521 | case u.asTypeUint32: 522 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.TypeUint32)) 523 | case u.asUint64: 524 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.Uint64)) 525 | case u.asTypeFloat32: 526 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.TypeFloat32)) 527 | case u.asFloat64: 528 | return (*_vkPerformanceCounterResultKHR)(unsafe.Pointer(&u.Float64)) 529 | default: 530 | return &_vkPerformanceCounterResultKHR{} 531 | } 532 | } 533 | 534 | // PerformanceValueDataINTEL: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueDataINTEL.html 535 | type PerformanceValueDataINTEL struct { 536 | Value32 uint32 537 | asValue32 bool 538 | Value64 uint64 539 | asValue64 bool 540 | ValueFloat float32 541 | asValueFloat bool 542 | ValueBool bool 543 | asValueBool bool 544 | ValueString string 545 | asValueString bool 546 | } 547 | 548 | func (u *PerformanceValueDataINTEL) AsValue32(val uint32) { 549 | u.Value32 = val 550 | u.asValue32 = true 551 | u.asValue64 = false 552 | u.asValueFloat = false 553 | u.asValueBool = false 554 | u.asValueString = false 555 | } 556 | 557 | func (u *PerformanceValueDataINTEL) AsValue64(val uint64) { 558 | u.Value64 = val 559 | u.asValue32 = false 560 | u.asValue64 = true 561 | u.asValueFloat = false 562 | u.asValueBool = false 563 | u.asValueString = false 564 | } 565 | 566 | func (u *PerformanceValueDataINTEL) AsValueFloat(val float32) { 567 | u.ValueFloat = val 568 | u.asValue32 = false 569 | u.asValue64 = false 570 | u.asValueFloat = true 571 | u.asValueBool = false 572 | u.asValueString = false 573 | } 574 | 575 | func (u *PerformanceValueDataINTEL) AsValueBool(val bool) { 576 | u.ValueBool = val 577 | u.asValue32 = false 578 | u.asValue64 = false 579 | u.asValueFloat = false 580 | u.asValueBool = true 581 | u.asValueString = false 582 | } 583 | 584 | func (u *PerformanceValueDataINTEL) AsValueString(val string) { 585 | u.ValueString = val 586 | u.asValue32 = false 587 | u.asValue64 = false 588 | u.asValueFloat = false 589 | u.asValueBool = false 590 | u.asValueString = true 591 | } 592 | 593 | type _vkPerformanceValueDataINTEL [8]byte 594 | 595 | func (u *PerformanceValueDataINTEL) Vulkanize() *_vkPerformanceValueDataINTEL { 596 | switch true { 597 | case u.asValue32: 598 | return (*_vkPerformanceValueDataINTEL)(unsafe.Pointer(&u.Value32)) 599 | case u.asValue64: 600 | return (*_vkPerformanceValueDataINTEL)(unsafe.Pointer(&u.Value64)) 601 | case u.asValueFloat: 602 | return (*_vkPerformanceValueDataINTEL)(unsafe.Pointer(&u.ValueFloat)) 603 | case u.asValueBool: 604 | return (*_vkPerformanceValueDataINTEL)(unsafe.Pointer(&u.ValueBool)) 605 | case u.asValueString: 606 | return (*_vkPerformanceValueDataINTEL)(unsafe.Pointer(&u.ValueString)) 607 | default: 608 | return &_vkPerformanceValueDataINTEL{} 609 | } 610 | } 611 | 612 | // PipelineExecutableStatisticValueKHR: See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html 613 | type PipelineExecutableStatisticValueKHR struct { 614 | B32 bool 615 | asB32 bool 616 | I64 int64 617 | asI64 bool 618 | U64 uint64 619 | asU64 bool 620 | F64 float64 621 | asF64 bool 622 | } 623 | 624 | func (u *PipelineExecutableStatisticValueKHR) AsB32(val bool) { 625 | u.B32 = val 626 | u.asB32 = true 627 | u.asI64 = false 628 | u.asU64 = false 629 | u.asF64 = false 630 | } 631 | 632 | func (u *PipelineExecutableStatisticValueKHR) AsI64(val int64) { 633 | u.I64 = val 634 | u.asB32 = false 635 | u.asI64 = true 636 | u.asU64 = false 637 | u.asF64 = false 638 | } 639 | 640 | func (u *PipelineExecutableStatisticValueKHR) AsU64(val uint64) { 641 | u.U64 = val 642 | u.asB32 = false 643 | u.asI64 = false 644 | u.asU64 = true 645 | u.asF64 = false 646 | } 647 | 648 | func (u *PipelineExecutableStatisticValueKHR) AsF64(val float64) { 649 | u.F64 = val 650 | u.asB32 = false 651 | u.asI64 = false 652 | u.asU64 = false 653 | u.asF64 = true 654 | } 655 | 656 | type _vkPipelineExecutableStatisticValueKHR [8]byte 657 | 658 | func (u *PipelineExecutableStatisticValueKHR) Vulkanize() *_vkPipelineExecutableStatisticValueKHR { 659 | switch true { 660 | case u.asB32: 661 | return (*_vkPipelineExecutableStatisticValueKHR)(unsafe.Pointer(&u.B32)) 662 | case u.asI64: 663 | return (*_vkPipelineExecutableStatisticValueKHR)(unsafe.Pointer(&u.I64)) 664 | case u.asU64: 665 | return (*_vkPipelineExecutableStatisticValueKHR)(unsafe.Pointer(&u.U64)) 666 | case u.asF64: 667 | return (*_vkPipelineExecutableStatisticValueKHR)(unsafe.Pointer(&u.F64)) 668 | default: 669 | return &_vkPipelineExecutableStatisticValueKHR{} 670 | } 671 | } 672 | --------------------------------------------------------------------------------