From c7d4af5c793c3247e58b032359994439515274e9 Mon Sep 17 00:00:00 2001 From: Charlie Shenton Date: Sat, 22 Apr 2023 16:39:01 +1000 Subject: [PATCH 001/108] Add Dynamic Resource Root Signature flags Add flag values associated with dynamics resources (ResourceDescriptorHeap and SamplerDescriptorHeap) see https://microsoft.github.io/DirectX-Specs/d3d/HLSL_SM_6_6_DynamicResources.html for details --- vendor/directx/d3d12/d3d12.odin | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vendor/directx/d3d12/d3d12.odin b/vendor/directx/d3d12/d3d12.odin index e84474aac..9c61aacbe 100644 --- a/vendor/directx/d3d12/d3d12.odin +++ b/vendor/directx/d3d12/d3d12.odin @@ -1992,6 +1992,8 @@ ROOT_SIGNATURE_FLAG :: enum u32 { LOCAL_ROOT_SIGNATURE = 7, DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 8, DENY_MESH_SHADER_ROOT_ACCESS = 9, + CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 10, + SAMPLER_HEAP_DIRECTLY_INDEXED = 11, } STATIC_BORDER_COLOR :: enum i32 { From 47610725eaac53db557cdb8c4d5b9a71b3af48ea Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Sun, 23 Apr 2023 17:02:56 +0100 Subject: [PATCH 002/108] Change default executable extension Putting a program into your path on a UNIX system with a file extension means that you have to type the extension out for every invocation of the program. A better default is to have no extension at all since most people will end up removing it anyway. This change does not affect Windows since the .exe extension is set after the default extension if compiling on Windows. --- src/build_settings.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index ac033df71..7de9e558e 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1497,13 +1497,11 @@ gb_internal bool init_build_paths(String init_filename) { } else if (is_arch_wasm()) { output_extension = STR_LIT("wasm"); } else if (build_context.build_mode == BuildMode_Executable) { - // By default use a .bin executable extension. - output_extension = STR_LIT("bin"); + // By default use no executable extension. + output_extension = make_string(nullptr, 0); if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); - } else if (build_context.cross_compiling && selected_target_metrics->metrics == &target_essence_amd64) { - output_extension = make_string(nullptr, 0); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { // By default use a .so shared library extension. From a6b93415933a9d8b27d6b37623d29788278bfc84 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Sun, 23 Apr 2023 18:53:00 +0100 Subject: [PATCH 003/108] Add .bin extension the case of a collision The directory name is used to determine the executable name. In the case that the directory and output executable are in conflict, a .bin extension is added. --- src/build_settings.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 7de9e558e..a8ad9bd3e 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1502,6 +1502,10 @@ gb_internal bool init_build_paths(String init_filename) { if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); + } else if (!str_eq(init_filename, str_lit(".")) && path_is_directory(init_filename)) { + // Add .bin extension to avoid collision + // with package directory name + output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { // By default use a .so shared library extension. From 06e8d03fbaf01fd78c2729e140c59bf921e7cf6b Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Sun, 23 Apr 2023 21:15:08 +0100 Subject: [PATCH 004/108] Use last element for directory collision check --- src/build_settings.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index a8ad9bd3e..d6b29709a 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1502,7 +1502,7 @@ gb_internal bool init_build_paths(String init_filename) { if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); - } else if (!str_eq(init_filename, str_lit(".")) && path_is_directory(init_filename)) { + } else if (!str_eq(init_filename, str_lit(".")) && path_is_directory(last_path_element(init_filename))) { // Add .bin extension to avoid collision // with package directory name output_extension = STR_LIT("bin"); From cbcf94669e138a1afcfc8d581257e81b138fbdb9 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Mon, 24 Apr 2023 12:57:34 +0100 Subject: [PATCH 005/108] Add get_current_directory() --- src/path.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/path.cpp b/src/path.cpp index 49a2d4a4f..baae94670 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -1,6 +1,8 @@ /* Path handling utilities. */ +#include + gb_internal String remove_extension_from_path(String const &s) { if (s.len != 0 && s.text[s.len-1] == '.') { return s; @@ -25,6 +27,16 @@ gb_internal String remove_directory_from_path(String const &s) { return substring(s, s.len-len, s.len); } +// NOTE(Mark Naughton): getcwd as String +gb_internal String get_current_directory(void) { + gbAllocator a = heap_allocator(); + + char cwd[256]; + getcwd(cwd, 256); + + return make_string_c(cwd); +} + gb_internal bool path_is_directory(String path); gb_internal String directory_from_path(String const &s) { From 780375d8654363f7de1eb95278b979d80a9a9775 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Mon, 24 Apr 2023 12:57:59 +0100 Subject: [PATCH 006/108] Add .bin extension in extra case --- src/build_settings.cpp | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index d6b29709a..1bef4b6ad 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1502,9 +1502,15 @@ gb_internal bool init_build_paths(String init_filename) { if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); - } else if (!str_eq(init_filename, str_lit(".")) && path_is_directory(last_path_element(init_filename))) { - // Add .bin extension to avoid collision - // with package directory name + } else if (str_eq(init_filename, str_lit("."))) { + // Avoid conflict in edge case where directory to be compiled is + // the same as the current directory's name + if (path_is_directory(last_path_element(get_current_directory()))) { + // Add .bin extension to avoid collision + // with package directory name + output_extension = STR_LIT("bin"); + } + } else if (path_is_directory(last_path_element(init_filename))) { output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { From 67b6a8ee89f5138f3e10d1d40111ac755ba34149 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Mon, 24 Apr 2023 14:26:53 +0100 Subject: [PATCH 007/108] Add Windows equivalent of get_current_directory --- src/path.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/path.cpp b/src/path.cpp index baae94670..414a90c39 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -1,7 +1,9 @@ /* Path handling utilities. */ +#if !defined(GB_SYSTEM_WINDOWS) #include +#endif gb_internal String remove_extension_from_path(String const &s) { if (s.len != 0 && s.text[s.len-1] == '.') { @@ -27,7 +29,9 @@ gb_internal String remove_directory_from_path(String const &s) { return substring(s, s.len-len, s.len); } + // NOTE(Mark Naughton): getcwd as String +#if !defined(GB_SYSTEM_WINDOWS) gb_internal String get_current_directory(void) { gbAllocator a = heap_allocator(); @@ -37,6 +41,17 @@ gb_internal String get_current_directory(void) { return make_string_c(cwd); } +#else +gb_internal String get_current_directory(void) { + gbAllocator a = heap_allocator(); + + wchar_t cwd[256]; + GetCurrentDirectoryW(256, cwd); + + return make_string_c(cwd); +} +#endif + gb_internal bool path_is_directory(String path); gb_internal String directory_from_path(String const &s) { From 5151403aaa500fc7a60c5f234f53d46d0b446b03 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Tue, 25 Apr 2023 12:08:15 +0100 Subject: [PATCH 008/108] Fix Windows version of get_current_directory --- src/path.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/path.cpp b/src/path.cpp index 414a90c39..7664380a4 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -33,8 +33,6 @@ gb_internal String remove_directory_from_path(String const &s) { // NOTE(Mark Naughton): getcwd as String #if !defined(GB_SYSTEM_WINDOWS) gb_internal String get_current_directory(void) { - gbAllocator a = heap_allocator(); - char cwd[256]; getcwd(cwd, 256); @@ -48,7 +46,9 @@ gb_internal String get_current_directory(void) { wchar_t cwd[256]; GetCurrentDirectoryW(256, cwd); - return make_string_c(cwd); + String16 wstr = make_string16_c(cwd); + + return string16_to_string(a, wstr); } #endif From 1a5ed4eb7f0fd88cf22992db8ebf1794464e7a1b Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Wed, 26 Apr 2023 14:10:22 +0100 Subject: [PATCH 009/108] Fix .bin not being applied for relative directory --- src/build_settings.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 1bef4b6ad..198de5bc6 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1510,7 +1510,8 @@ gb_internal bool init_build_paths(String init_filename) { // with package directory name output_extension = STR_LIT("bin"); } - } else if (path_is_directory(last_path_element(init_filename))) { + // Path could be absolute or relative + } else if (path_is_directory(last_path_element(init_filename)) || path_is_directory(init_filename)) { output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { From e84802468b61522b64e15a0eaa6cffe6029311e6 Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Wed, 26 Apr 2023 15:48:59 +0100 Subject: [PATCH 010/108] Use buildpath instead of init_filename --- src/build_settings.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 198de5bc6..b7ecd15f2 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1511,7 +1511,7 @@ gb_internal bool init_build_paths(String init_filename) { output_extension = STR_LIT("bin"); } // Path could be absolute or relative - } else if (path_is_directory(last_path_element(init_filename)) || path_is_directory(init_filename)) { + } else if (path_is_directory(last_path_element(bc->build_paths[BuildPath_Main_Package].basename))) { output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { From 4b4481ea274283489f39fe3ac3ae871d26a2b46d Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Wed, 26 Apr 2023 16:39:47 +0100 Subject: [PATCH 011/108] Simplify extension addition logic --- src/build_settings.cpp | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index b7ecd15f2..b74207b85 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1502,16 +1502,9 @@ gb_internal bool init_build_paths(String init_filename) { if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); - } else if (str_eq(init_filename, str_lit("."))) { - // Avoid conflict in edge case where directory to be compiled is - // the same as the current directory's name - if (path_is_directory(last_path_element(get_current_directory()))) { - // Add .bin extension to avoid collision - // with package directory name - output_extension = STR_LIT("bin"); - } - // Path could be absolute or relative } else if (path_is_directory(last_path_element(bc->build_paths[BuildPath_Main_Package].basename))) { + // Add .bin extension to avoid collision + // with package directory name output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { From 808e7ed4ae224806ab850feacacf5fa4682cfcc5 Mon Sep 17 00:00:00 2001 From: Ahsan-Sarbaz Date: Mon, 1 May 2023 00:16:20 +0500 Subject: [PATCH 012/108] Fixed Bug in DXGI --- vendor/directx/dxgi/dxgi.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vendor/directx/dxgi/dxgi.odin b/vendor/directx/dxgi/dxgi.odin index 5ad938ba0..dc1b73b1b 100644 --- a/vendor/directx/dxgi/dxgi.odin +++ b/vendor/directx/dxgi/dxgi.odin @@ -375,7 +375,7 @@ MAPPED_RECT :: struct { } ADAPTER_DESC :: struct { - Description: [128]i16, + Description: [128]u16, VendorId: u32, DeviceId: u32, SubSysId: u32, @@ -387,7 +387,7 @@ ADAPTER_DESC :: struct { } OUTPUT_DESC :: struct { - DeviceName: [32]i16, + DeviceName: [32]u16, DesktopCoordinates: RECT, AttachedToDesktop: BOOL, Rotation: MODE_ROTATION, @@ -613,7 +613,7 @@ ADAPTER_FLAG :: enum u32 { // TODO: convert to bit_set } ADAPTER_DESC1 :: struct { - Description: [128]i16, + Description: [128]u16, VendorId: u32, DeviceId: u32, SubSysId: u32, @@ -890,7 +890,7 @@ COMPUTE_PREEMPTION_GRANULARITY :: enum i32 { } ADAPTER_DESC2 :: struct { - Description: [128]i16, + Description: [128]u16, VendorId: u32, DeviceId: u32, SubSysId: u32, From f5dcbf517b88d7479fa12d5f3b59183a447cae6f Mon Sep 17 00:00:00 2001 From: Jon Lipstate Date: Sun, 30 Apr 2023 18:36:00 -0700 Subject: [PATCH 013/108] helpful errors custom-attrs --- src/checker.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/checker.cpp b/src/checker.cpp index a6768d495..3e9b46407 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3507,6 +3507,7 @@ gb_internal void check_decl_attributes(CheckerContext *c, Array const &at if (!proc(c, elem, name, value, ac)) { if (!build_context.ignore_unknown_attributes) { error(elem, "Unknown attribute element name '%.*s'", LIT(name)); + error_line("\tDid you forget to use build flag '-ignore-unknown-attributes'?\n"); } } } From eff4833840608b93d83a7140d152b80524dfd394 Mon Sep 17 00:00:00 2001 From: Elusive Porpoise <95202750+elusivePorpoise@users.noreply.github.com> Date: Mon, 8 May 2023 23:12:56 -0700 Subject: [PATCH 014/108] remove misleading example --- examples/demo/demo.odin | 6 ------ 1 file changed, 6 deletions(-) diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin index 457aa786a..2ea69a774 100644 --- a/examples/demo/demo.odin +++ b/examples/demo/demo.odin @@ -2145,12 +2145,6 @@ or_return_operator :: proc() { return -345 * z, zerr } - // If the other return values need to be set depending on what the end value is, - // the 'defer if' idiom is can be used - defer if err != nil { - n = -1 - } - n = 123 return } From 3032a4274dbd050457eced425e127c7aa1c42ba4 Mon Sep 17 00:00:00 2001 From: jason Date: Tue, 16 May 2023 16:56:32 -0400 Subject: [PATCH 015/108] implement backward shift during map insertion --- core/runtime/dynamic_map_internal.odin | 72 ++++++++++++++++++++------ 1 file changed, 55 insertions(+), 17 deletions(-) diff --git a/core/runtime/dynamic_map_internal.odin b/core/runtime/dynamic_map_internal.odin index fb4ad29a9..b0d6cefc4 100644 --- a/core/runtime/dynamic_map_internal.odin +++ b/core/runtime/dynamic_map_internal.odin @@ -394,32 +394,71 @@ map_insert_hash_dynamic :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^ tk := map_cell_index_dynamic(sk, info.ks, 1) tv := map_cell_index_dynamic(sv, info.vs, 1) - for { hp := &hs[pos] element_hash := hp^ if map_hash_is_empty(element_hash) { - k_dst := map_cell_index_dynamic(ks, info.ks, pos) - v_dst := map_cell_index_dynamic(vs, info.vs, pos) - intrinsics.mem_copy_non_overlapping(rawptr(k_dst), rawptr(k), size_of_k) - intrinsics.mem_copy_non_overlapping(rawptr(v_dst), rawptr(v), size_of_v) + kp := map_cell_index_dynamic(ks, info.ks, pos) + vp := map_cell_index_dynamic(vs, info.vs, pos) + intrinsics.mem_copy_non_overlapping(rawptr(kp), rawptr(k), size_of_k) + intrinsics.mem_copy_non_overlapping(rawptr(vp), rawptr(v), size_of_v) hp^ = h - return result if result != 0 else v_dst + return result if result != 0 else vp + } + + if map_hash_is_deleted(element_hash) { + next_pos := (pos + 1) & mask + + // backward shift + for !map_hash_is_empty(hs[next_pos]) { + probe_distance := map_probe_distance(m^, hs[next_pos], next_pos) + if probe_distance == 0 { + break + } + probe_distance -= 1 + + kp := map_cell_index_dynamic(ks, info.ks, pos) + vp := map_cell_index_dynamic(vs, info.vs, pos) + kn := map_cell_index_dynamic(ks, info.ks, next_pos) + vn := map_cell_index_dynamic(vs, info.vs, next_pos) + + if distance > probe_distance { + if result == 0 { + result = vp + } + // move stored into pos; store next + intrinsics.mem_copy_non_overlapping(rawptr(kp), rawptr(k), size_of_k) + intrinsics.mem_copy_non_overlapping(rawptr(vp), rawptr(v), size_of_v) + hs[pos] = h + + intrinsics.mem_copy_non_overlapping(rawptr(k), rawptr(kn), size_of_k) + intrinsics.mem_copy_non_overlapping(rawptr(v), rawptr(vn), size_of_v) + h = hs[next_pos] + } else { + // move next back 1 + intrinsics.mem_copy_non_overlapping(rawptr(kp), rawptr(kn), size_of_k) + intrinsics.mem_copy_non_overlapping(rawptr(vp), rawptr(vn), size_of_v) + hs[pos] = hs[next_pos] + distance = probe_distance + } + hs[next_pos] = 0 + pos = (pos + 1) & mask + next_pos = (next_pos + 1) & mask + distance += 1 + } + + kp := map_cell_index_dynamic(ks, info.ks, pos) + vp := map_cell_index_dynamic(vs, info.vs, pos) + intrinsics.mem_copy_non_overlapping(rawptr(kp), rawptr(k), size_of_k) + intrinsics.mem_copy_non_overlapping(rawptr(vp), rawptr(v), size_of_v) + hs[pos] = h + + return result if result != 0 else vp } if probe_distance := map_probe_distance(m^, element_hash, pos); distance > probe_distance { - if map_hash_is_deleted(element_hash) { - k_dst := map_cell_index_dynamic(ks, info.ks, pos) - v_dst := map_cell_index_dynamic(vs, info.vs, pos) - intrinsics.mem_copy_non_overlapping(rawptr(k_dst), rawptr(k), size_of_k) - intrinsics.mem_copy_non_overlapping(rawptr(v_dst), rawptr(v), size_of_v) - hp^ = h - - return result if result != 0 else v_dst - } - if result == 0 { result = map_cell_index_dynamic(vs, info.vs, pos) } @@ -637,7 +676,6 @@ map_erase_dynamic :: #force_inline proc "contextless" (#no_alias m: ^Raw_Map, #n { // coalesce tombstones // HACK NOTE(bill): This is an ugly bodge but it is coalescing the tombstone slots - // TODO(bill): we should do backward shift deletion and not rely on tombstone slots mask := (uintptr(1)< Date: Tue, 16 May 2023 23:49:55 -0400 Subject: [PATCH 016/108] implement random map seed --- core/runtime/dynamic_map_internal.odin | 42 +++++++++++++++++++++----- src/llvm_backend.cpp | 27 ++++++++++++++--- src/llvm_backend.hpp | 2 +- 3 files changed, 57 insertions(+), 14 deletions(-) diff --git a/core/runtime/dynamic_map_internal.odin b/core/runtime/dynamic_map_internal.odin index b0d6cefc4..188d6343e 100644 --- a/core/runtime/dynamic_map_internal.odin +++ b/core/runtime/dynamic_map_internal.odin @@ -251,6 +251,26 @@ map_hash_is_valid :: #force_inline proc "contextless" (hash: Map_Hash) -> bool { return (hash != 0) & (hash & TOMBSTONE_MASK == 0) } +@(require_results) +map_seed :: #force_inline proc "contextless" (m: Raw_Map) -> uintptr { + return map_seed_from_map_data(map_data(m)) +} + +// splitmix for uintptr +@(require_results) +map_seed_from_map_data :: #force_inline proc "contextless" (data: uintptr) -> uintptr { + when size_of(uintptr) == size_of(u64) { + mix := data + 0x9e3779b97f4a7c15 + mix = (mix ~ (mix >> 30)) * 0xbf58476d1ce4e5b9 + mix = (mix ~ (mix >> 27)) * 0x94d049bb133111eb + return mix ~ (mix >> 31) + } else { + mix := data + 0x9e3779b9 + mix = (mix ~ (mix >> 16)) * 0x21f0aaad + mix = (mix ~ (mix >> 15)) * 0x735a2d97 + return mix ~ (mix >> 15) + } +} // Computes the desired position in the array. This is just index % capacity, // but a procedure as there's some math involved here to recover the capacity. @@ -542,6 +562,7 @@ map_reserve_dynamic :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_ } k := map_cell_index_dynamic(ks, info.ks, i) v := map_cell_index_dynamic(vs, info.vs, i) + hash = info.key_hasher(rawptr(k), map_seed(resized)) _ = map_insert_hash_dynamic(&resized, info, hash, k, v) // Only need to do this comparison on each actually added pair, so do not // fold it into the for loop comparator as a micro-optimization. @@ -620,7 +641,7 @@ map_lookup_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info, if map_len(m) == 0 { return 0, false } - h := info.key_hasher(rawptr(k), 0) + h := info.key_hasher(rawptr(k), map_seed(m)) p := map_desired_position(m, h) d := uintptr(0) c := (uintptr(1) << map_log2_cap(m)) - 1 @@ -643,7 +664,7 @@ map_exists_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info, if map_len(m) == 0 { return false } - h := info.key_hasher(rawptr(k), 0) + h := info.key_hasher(rawptr(k), map_seed(m)) p := map_desired_position(m, h) d := uintptr(0) c := (uintptr(1) << map_log2_cap(m)) - 1 @@ -749,7 +770,7 @@ map_get :: proc "contextless" (m: $T/map[$K]$V, key: K) -> (stored_key: K, store info := intrinsics.type_map_info(T) key := key - h := info.key_hasher(&key, 0) + h := info.key_hasher(&key, map_seed(m)) pos := map_desired_position(rm, h) distance := uintptr(0) mask := (uintptr(1) << map_log2_cap(rm)) - 1 @@ -800,15 +821,15 @@ __dynamic_map_get :: proc "contextless" (#no_alias m: ^Raw_Map, #no_alias info: } // IMPORTANT: USED WITHIN THE COMPILER -__dynamic_map_check_grow :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, loc := #caller_location) -> Allocator_Error { +__dynamic_map_check_grow :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, loc := #caller_location) -> (err: Allocator_Error, has_grown: bool) { if m.len >= map_resize_threshold(m^) { - return map_grow_dynamic(m, info, loc) + return map_grow_dynamic(m, info, loc), true } - return nil + return nil, false } __dynamic_map_set_without_hash :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, key, value: rawptr, loc := #caller_location) -> rawptr { - return __dynamic_map_set(m, info, info.key_hasher(key, 0), key, value, loc) + return __dynamic_map_set(m, info, info.key_hasher(key, map_seed(m^)), key, value, loc) } @@ -819,9 +840,14 @@ __dynamic_map_set :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_In return found } - if __dynamic_map_check_grow(m, info, loc) != nil { + hash := hash + err, has_grown := __dynamic_map_check_grow(m, info, loc) + if err != nil { return nil } + if has_grown { + hash = info.key_hasher(key, map_seed(m^)) + } result := map_insert_hash_dynamic(m, info, hash, uintptr(key), uintptr(value)) m.len += 1 diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 4d8e13f0f..f28b1f62d 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -720,6 +720,7 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { lbBlock *check_grow_block = lb_create_block(p, "check-grow"); lbBlock *grow_fail_block = lb_create_block(p, "grow-fail"); lbBlock *insert_block = lb_create_block(p, "insert"); + lbBlock *rehash_block = lb_create_block(p, "rehash"); lb_emit_if(p, lb_emit_comp_against_nil(p, Token_NotEq, found_ptr), found_block, check_grow_block); lb_start_block(p, found_block); @@ -737,12 +738,19 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { args[0] = lb_emit_conv(p, map_ptr, t_rawptr); args[1] = map_info; args[2] = lb_emit_load(p, location_ptr); - lbValue grow_err = lb_emit_runtime_call(p, "__dynamic_map_check_grow", args); + lbValue grow_err_and_has_grown = lb_emit_runtime_call(p, "__dynamic_map_check_grow", args); + lbValue grow_err = lb_emit_struct_ev(p, grow_err_and_has_grown, 0); + lbValue has_grown = lb_emit_struct_ev(p, grow_err_and_has_grown, 1); lb_emit_if(p, lb_emit_comp_against_nil(p, Token_NotEq, grow_err), grow_fail_block, insert_block); lb_start_block(p, grow_fail_block); LLVMBuildRet(p->builder, LLVMConstNull(lb_type(m, t_rawptr))); + + lb_emit_if(p, has_grown, grow_fail_block, rehash_block); + lb_start_block(p, rehash_block); + lbValue key = lb_emit_load(p, key_ptr); + hash = lb_gen_map_key_hash(p, map_ptr, key, nullptr); } lb_start_block(p, insert_block); @@ -916,7 +924,7 @@ gb_internal lbValue lb_const_hash(lbModule *m, lbValue key, Type *key_type) { return hashed_key; } -gb_internal lbValue lb_gen_map_key_hash(lbProcedure *p, lbValue key, Type *key_type, lbValue *key_ptr_) { +gb_internal lbValue lb_gen_map_key_hash(lbProcedure *p, lbValue const &map_ptr, lbValue key, lbValue *key_ptr_) { TEMPORARY_ALLOCATOR_GUARD(); lbValue key_ptr = lb_address_from_load_or_generate_local(p, key); @@ -924,13 +932,22 @@ gb_internal lbValue lb_gen_map_key_hash(lbProcedure *p, lbValue key, Type *key_t if (key_ptr_) *key_ptr_ = key_ptr; + Type* key_type = base_type(type_deref(map_ptr.type))->Map.key; + lbValue hashed_key = lb_const_hash(p->module, key, key_type); if (hashed_key.value == nullptr) { lbValue hasher = lb_hasher_proc_for_type(p->module, key_type); + lbValue seed = {}; + { + auto args = array_make(temporary_allocator(), 1); + args[0] = lb_map_data_uintptr(p, lb_emit_load(p, map_ptr)); + seed = lb_emit_runtime_call(p, "map_seed_from_map_data", args); + } + auto args = array_make(temporary_allocator(), 2); args[0] = key_ptr; - args[1] = lb_const_int(p->module, t_uintptr, 0); + args[1] = seed; hashed_key = lb_emit_call(p, hasher, args); } @@ -945,7 +962,7 @@ gb_internal lbValue lb_internal_dynamic_map_get_ptr(lbProcedure *p, lbValue cons lbValue ptr = {}; lbValue key_ptr = {}; - lbValue hash = lb_gen_map_key_hash(p, key, map_type->Map.key, &key_ptr); + lbValue hash = lb_gen_map_key_hash(p, map_ptr, key, &key_ptr); if (build_context.dynamic_map_calls) { auto args = array_make(temporary_allocator(), 4); @@ -976,7 +993,7 @@ gb_internal void lb_internal_dynamic_map_set(lbProcedure *p, lbValue const &map_ GB_ASSERT(map_type->kind == Type_Map); lbValue key_ptr = {}; - lbValue hash = lb_gen_map_key_hash(p, map_key, map_type->Map.key, &key_ptr); + lbValue hash = lb_gen_map_key_hash(p, map_ptr, map_key, &key_ptr); lbValue v = lb_emit_conv(p, map_value, map_type->Map.value); lbValue value_ptr = lb_address_from_load_or_generate_local(p, v); diff --git a/src/llvm_backend.hpp b/src/llvm_backend.hpp index 964195223..1ddd4fed7 100644 --- a/src/llvm_backend.hpp +++ b/src/llvm_backend.hpp @@ -477,7 +477,7 @@ gb_internal String lb_get_const_string(lbModule *m, lbValue value); gb_internal lbValue lb_generate_local_array(lbProcedure *p, Type *elem_type, i64 count, bool zero_init=true); gb_internal lbValue lb_generate_global_array(lbModule *m, Type *elem_type, i64 count, String prefix, i64 id); -gb_internal lbValue lb_gen_map_key_hash(lbProcedure *p, lbValue key, Type *key_type, lbValue *key_ptr_); +gb_internal lbValue lb_gen_map_key_hash(lbProcedure *p, lbValue const &map_ptr, lbValue key, lbValue *key_ptr_); gb_internal lbValue lb_gen_map_cell_info_ptr(lbModule *m, Type *type); gb_internal lbValue lb_gen_map_info_ptr(lbModule *m, Type *map_type); From b2645b32014b57003f80ff9dde841c2be94d44ca Mon Sep 17 00:00:00 2001 From: jason Date: Wed, 17 May 2023 00:06:31 -0400 Subject: [PATCH 017/108] add rehash to map_shrink_dynamic --- core/runtime/dynamic_map_internal.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/core/runtime/dynamic_map_internal.odin b/core/runtime/dynamic_map_internal.odin index 188d6343e..fe4690610 100644 --- a/core/runtime/dynamic_map_internal.odin +++ b/core/runtime/dynamic_map_internal.odin @@ -610,6 +610,7 @@ map_shrink_dynamic :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_I k := map_cell_index_dynamic(ks, info.ks, i) v := map_cell_index_dynamic(vs, info.vs, i) + hash = info.key_hasher(rawptr(k), map_seed(shrunk)) _ = map_insert_hash_dynamic(&shrunk, info, hash, k, v) // Only need to do this comparison on each actually added pair, so do not // fold it into the for loop comparator as a micro-optimization. From f2e590be7a02710aaf2a6cd236ceeb829db14e30 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 18 May 2023 11:35:47 +0100 Subject: [PATCH 018/108] Fix #2544 --- src/llvm_backend_expr.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index 108276ee3..67c201677 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -3783,6 +3783,7 @@ gb_internal lbAddr lb_build_addr_index_expr(lbProcedure *p, Ast *expr) { multi_ptr = lb_emit_load(p, multi_ptr); } lbValue index = lb_build_expr(p, ie->index); + index = lb_emit_conv(p, index, t_int); lbValue v = {}; LLVMValueRef indices[1] = {index.value}; From c0e84b05923cef2d3fb1d6c0ef5b9e9a119363fe Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 18 May 2023 11:39:18 +0100 Subject: [PATCH 019/108] Fix #2536 --- src/types.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/types.cpp b/src/types.cpp index 889269564..70c4bcdbe 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -2769,13 +2769,23 @@ gb_internal Type *default_type(Type *type) { return type; } +gb_internal bool union_variant_index_types_equal(Type *v, Type *vt) { + if (are_types_identical(v, vt)) { + return true; + } + if (is_type_proc(v) && is_type_proc(vt)) { + return are_types_identical(base_type(v), base_type(vt)); + } + return false; +} + gb_internal i64 union_variant_index(Type *u, Type *v) { u = base_type(u); GB_ASSERT(u->kind == Type_Union); for_array(i, u->Union.variants) { Type *vt = u->Union.variants[i]; - if (are_types_identical(v, vt)) { + if (union_variant_index_types_equal(v, vt)) { if (u->Union.kind == UnionType_no_nil) { return cast(i64)(i+0); } else { From 56c0d32ea0c81ad9913e4e512952b3be25688504 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 18 May 2023 11:52:16 +0100 Subject: [PATCH 020/108] Fix #2526 --- src/check_decl.cpp | 12 ++++++++---- src/check_stmt.cpp | 6 ++++++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/check_decl.cpp b/src/check_decl.cpp index a984f87a3..e97e86e8b 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -43,14 +43,20 @@ gb_internal Type *check_init_variable(CheckerContext *ctx, Entity *e, Operand *o } if (operand->mode == Addressing_Type) { - if (e->type != nullptr && is_type_typeid(e->type)) { + if (e->type != nullptr && is_type_typeid(e->type) && !is_type_polymorphic(operand->type)) { add_type_info_type(ctx, operand->type); add_type_and_value(ctx, operand->expr, Addressing_Value, e->type, exact_value_typeid(operand->type)); return e->type; } else { + ERROR_BLOCK(); + gbString t = type_to_string(operand->type); defer (gb_string_free(t)); - error(operand->expr, "Cannot assign a type '%s' to variable '%.*s'", t, LIT(e->token.string)); + if (is_type_polymorphic(operand->type)) { + error(operand->expr, "Cannot assign a non-specialized polymorphic type '%s' to variable '%.*s'", t, LIT(e->token.string)); + } else { + error(operand->expr, "Cannot assign a type '%s' to variable '%.*s'", t, LIT(e->token.string)); + } if (e->type == nullptr) { error_line("\tThe type of the variable '%.*s' cannot be inferred as a type does not have a default type\n", LIT(e->token.string)); } @@ -59,8 +65,6 @@ gb_internal Type *check_init_variable(CheckerContext *ctx, Entity *e, Operand *o } } - - if (e->type == nullptr) { // NOTE(bill): Use the type of the operand diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 388a64e00..1e3b35c21 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -402,6 +402,12 @@ gb_internal Type *check_assignment_variable(CheckerContext *ctx, Operand *lhs, O Type *assignment_type = lhs->type; + if (rhs->mode == Addressing_Type && is_type_polymorphic(rhs->type)) { + gbString t = type_to_string(rhs->type); + error(rhs->expr, "Invalid use of a non-specialized polymorphic type '%s'", t); + gb_string_free(t); + } + switch (lhs->mode) { case Addressing_Invalid: return nullptr; From 3108752a0c00d25371b2c66840bbcd7e5d11ecd6 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 18 May 2023 11:55:37 +0100 Subject: [PATCH 021/108] Fix #2518 --- core/sys/windows/kernel32.odin | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin index a6897f164..beed3a7e5 100644 --- a/core/sys/windows/kernel32.odin +++ b/core/sys/windows/kernel32.odin @@ -2,6 +2,7 @@ package sys_windows foreign import kernel32 "system:Kernel32.lib" +foreign import one_core "system:OneCore.lib" FOREGROUND_BLUE :: WORD(0x0001) FOREGROUND_GREEN :: WORD(0x0002) @@ -891,7 +892,7 @@ WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: distinct ULONG }*/ @(default_calling_convention="stdcall") -foreign kernel32 { +foreign one_core { QueryVirtualMemoryInformation :: proc( Process: HANDLE, VirtualAddress: PVOID, From d56fdd293774dde8752c7906cf3c9651b69098f7 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 18 May 2023 12:00:23 +0100 Subject: [PATCH 022/108] Add `fmt:"s,0"` tags to UTF-16 strings in dxgi.odin --- vendor/directx/dxgi/dxgi.odin | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vendor/directx/dxgi/dxgi.odin b/vendor/directx/dxgi/dxgi.odin index dc1b73b1b..c2117f637 100644 --- a/vendor/directx/dxgi/dxgi.odin +++ b/vendor/directx/dxgi/dxgi.odin @@ -375,7 +375,7 @@ MAPPED_RECT :: struct { } ADAPTER_DESC :: struct { - Description: [128]u16, + Description: [128]u16 `fmt:"s,0"`, VendorId: u32, DeviceId: u32, SubSysId: u32, @@ -387,7 +387,7 @@ ADAPTER_DESC :: struct { } OUTPUT_DESC :: struct { - DeviceName: [32]u16, + DeviceName: [32]u16 `fmt:"s,0"`, DesktopCoordinates: RECT, AttachedToDesktop: BOOL, Rotation: MODE_ROTATION, @@ -613,7 +613,7 @@ ADAPTER_FLAG :: enum u32 { // TODO: convert to bit_set } ADAPTER_DESC1 :: struct { - Description: [128]u16, + Description: [128]u16 `fmt:"s,0"`, VendorId: u32, DeviceId: u32, SubSysId: u32, @@ -890,7 +890,7 @@ COMPUTE_PREEMPTION_GRANULARITY :: enum i32 { } ADAPTER_DESC2 :: struct { - Description: [128]u16, + Description: [128]u16 `fmt:"s,0"`, VendorId: u32, DeviceId: u32, SubSysId: u32, From 413077a5d9ce55850bbb64747e1e7a813e356e5b Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Thu, 18 May 2023 13:23:17 +0100 Subject: [PATCH 023/108] Fix single-file package case --- src/build_settings.cpp | 7 +++++++ src/path.cpp | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index b74207b85..e690b9ea2 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1499,13 +1499,20 @@ gb_internal bool init_build_paths(String init_filename) { } else if (build_context.build_mode == BuildMode_Executable) { // By default use no executable extension. output_extension = make_string(nullptr, 0); + String const single_file_extension = str_lit(".odin"); if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); + } else if (build_context.cross_compiling && selected_target_metrics->metrics == &target_essence_amd64) { + output_extension = make_string(nullptr, 0); } else if (path_is_directory(last_path_element(bc->build_paths[BuildPath_Main_Package].basename))) { // Add .bin extension to avoid collision // with package directory name output_extension = STR_LIT("bin"); + } else if (string_ends_with(init_filename, single_file_extension) && path_is_directory(remove_extension_from_path(init_filename))) { + // Add bin extension if compiling single-file package + // with same output name as a directory + output_extension = STR_LIT("bin"); } } else if (build_context.build_mode == BuildMode_DynamicLibrary) { // By default use a .so shared library extension. diff --git a/src/path.cpp b/src/path.cpp index 7664380a4..3054e3b57 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -2,7 +2,7 @@ Path handling utilities. */ #if !defined(GB_SYSTEM_WINDOWS) -#include +#include #endif gb_internal String remove_extension_from_path(String const &s) { From 87a17926771ae7c365e8b0416c7cd938e3b41386 Mon Sep 17 00:00:00 2001 From: KyleRhoads45 Date: Thu, 18 May 2023 13:19:22 -0700 Subject: [PATCH 024/108] Fix #2545 - Typo in vec4 lerping procedures --- core/math/linalg/glsl/linalg_glsl.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/math/linalg/glsl/linalg_glsl.odin b/core/math/linalg/glsl/linalg_glsl.odin index 74753f66f..0c3f56636 100644 --- a/core/math/linalg/glsl/linalg_glsl.odin +++ b/core/math/linalg/glsl/linalg_glsl.odin @@ -762,10 +762,10 @@ lerp_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } lerp_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } lerp_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } lerp_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +lerp_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } lerp_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } lerp_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +lerp_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } step :: proc{ From 2631e07beab29558249341c329c69bb604dd61fb Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 19 May 2023 11:18:20 +0100 Subject: [PATCH 025/108] Add `intrinsics.type_merge` --- core/intrinsics/intrinsics.odin | 1 + src/check_builtin.cpp | 69 +++++++++++++++++++++++++++++++++ src/check_expr.cpp | 2 +- src/checker_builtin_procs.hpp | 2 + src/parser.hpp | 9 +++++ 5 files changed, 82 insertions(+), 1 deletion(-) diff --git a/core/intrinsics/intrinsics.odin b/core/intrinsics/intrinsics.odin index 890a6881d..93cd0e505 100644 --- a/core/intrinsics/intrinsics.odin +++ b/core/intrinsics/intrinsics.odin @@ -192,6 +192,7 @@ type_map_info :: proc($T: typeid/map[$K]$V) -> ^runtime.Map_Info --- type_map_cell_info :: proc($T: typeid) -> ^runtime.Map_Cell_Info --- type_convert_variants_to_pointers :: proc($T: typeid) -> typeid where type_is_union(T) --- +type_merge :: proc($U, $V: typeid) -> typeid where type_is_union(U), type_is_union(V) --- constant_utf16_cstring :: proc($literal: string) -> [^]u16 --- diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 5f9715959..0f8cdfd69 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -4843,6 +4843,75 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As } operand->mode = Addressing_Type; break; + case BuiltinProc_type_merge: + { + operand->mode = Addressing_Type; + operand->type = t_invalid; + + Operand x = {}; + Operand y = {}; + check_expr_or_type(c, &x, ce->args[0]); + check_expr_or_type(c, &y, ce->args[1]); + if (x.mode != Addressing_Type) { + error(x.expr, "Expected a type for '%.*s'", LIT(builtin_name)); + return false; + } + if (y.mode != Addressing_Type) { + error(y.expr, "Expected a type for '%.*s'", LIT(builtin_name)); + return false; + } + + if (is_type_polymorphic(x.type)) { + gbString t = type_to_string(x.type); + error(x.expr, "Expected a non-polymorphic type for '%.*s', got %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + if (is_type_polymorphic(y.type)) { + gbString t = type_to_string(y.type); + error(y.expr, "Expected a non-polymorphic type for '%.*s', got %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + if (!is_type_union(x.type)) { + gbString t = type_to_string(x.type); + error(x.expr, "Expected a union type for '%.*s', got %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + if (!is_type_union(y.type)) { + gbString t = type_to_string(y.type); + error(x.expr, "Expected a union type for '%.*s', got %s", LIT(builtin_name), t); + gb_string_free(t); + return false; + } + Type *ux = base_type(x.type); + Type *uy = base_type(y.type); + GB_ASSERT(ux->kind == Type_Union); + GB_ASSERT(uy->kind == Type_Union); + + i64 custom_align = gb_max(ux->Union.custom_align, uy->Union.custom_align); + if (ux->Union.kind != uy->Union.kind) { + error(x.expr, "Union kinds must match, got %s vs %s", union_type_kind_strings[ux->Union.kind], union_type_kind_strings[uy->Union.kind]); + } + + Type *merged_union = alloc_type_union(); + + merged_union->Union.node = call; + merged_union->Union.scope = create_scope(c->info, c->scope); + merged_union->Union.kind = ux->Union.kind; + merged_union->Union.custom_align = custom_align; + + auto variants = slice_make(permanent_allocator(), ux->Union.variants.count+uy->Union.variants.count); + slice_copy(&variants, ux->Union.variants, 0); + slice_copy(&variants, uy->Union.variants, ux->Union.variants.count); + merged_union->Union.variants = variants; + + operand->mode = Addressing_Type; + operand->type = merged_union; + } + break; + case BuiltinProc_type_is_boolean: case BuiltinProc_type_is_integer: diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 0db12aba0..1552b1ef5 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -1067,7 +1067,7 @@ gb_internal void check_assignment(CheckerContext *c, Operand *operand, Type *typ if (check_is_assignable_to(c, operand, type)) { if (operand->mode == Addressing_Type && is_type_typeid(type)) { - add_type_info_type(c, operand->type); + add_type_info_type(c, operand->type); add_type_and_value(c, operand->expr, Addressing_Value, type, exact_value_typeid(operand->type)); } } else { diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index 72f001c70..edd046087 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -203,6 +203,7 @@ BuiltinProc__type_begin, BuiltinProc_type_elem_type, BuiltinProc_type_convert_variants_to_pointers, + BuiltinProc_type_merge, BuiltinProc__type_simple_boolean_begin, BuiltinProc_type_is_boolean, @@ -501,6 +502,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("type_core_type"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_elem_type"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("type_convert_variants_to_pointers"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("type_merge"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT(""), 0, false, Expr_Stmt, BuiltinProcPkg_intrinsics}, {STR_LIT("type_is_boolean"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, diff --git a/src/parser.hpp b/src/parser.hpp index 5302fd274..aea3bbf21 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -356,6 +356,15 @@ enum UnionTypeKind : u8 { UnionType_Normal = 0, UnionType_no_nil = 2, UnionType_shared_nil = 3, + + UnionType_COUNT +}; + +gb_global char const *union_type_kind_strings[UnionType_COUNT] = { + "(normal)", + "#maybe", + "#no_nil", + "#shared_nil", }; #define AST_KINDS \ From 4201834b18e540b64899d27f7426fc98cce457c3 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 19 May 2023 12:11:18 +0100 Subject: [PATCH 026/108] Make `intrinsics.type_merge` form a union of the types; ignoring duplicates --- src/check_builtin.cpp | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 0f8cdfd69..46ee6b7f9 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -4902,10 +4902,24 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As merged_union->Union.kind = ux->Union.kind; merged_union->Union.custom_align = custom_align; - auto variants = slice_make(permanent_allocator(), ux->Union.variants.count+uy->Union.variants.count); - slice_copy(&variants, ux->Union.variants, 0); - slice_copy(&variants, uy->Union.variants, ux->Union.variants.count); - merged_union->Union.variants = variants; + auto variants = array_make(permanent_allocator(), 0, ux->Union.variants.count+uy->Union.variants.count); + for (Type *t : ux->Union.variants) { + array_add(&variants, t); + } + for (Type *t : uy->Union.variants) { + bool ok = true; + for (Type *other_t : ux->Union.variants) { + if (are_types_identical(other_t, t)) { + ok = false; + break; + } + } + if (ok) { + array_add(&variants, t); + } + + } + merged_union->Union.variants = slice_from_array(variants); operand->mode = Addressing_Type; operand->type = merged_union; From ff745e0ad84c91a5c672208b48cbb719cea2ffba Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Fri, 19 May 2023 19:14:25 +0200 Subject: [PATCH 027/108] fix parse_address can return nil --- core/net/dns.odin | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/net/dns.odin b/core/net/dns.odin index a0223e6ee..6afa844fe 100644 --- a/core/net/dns.odin +++ b/core/net/dns.odin @@ -392,6 +392,10 @@ load_resolv_conf :: proc(resolv_conf_path: string, allocator := context.allocato } addr := parse_address(server_ip_str) + if addr == nil { + continue + } + endpoint := Endpoint{ addr, 53, From 018904f0ec59244645187b72f01bedcf716ab40c Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Fri, 19 May 2023 18:37:55 +0100 Subject: [PATCH 028/108] Add write permissions check on output folder --- src/build_settings.cpp | 19 ++++++++++++++++++- src/path.cpp | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 1 deletion(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index e690b9ea2..018c3741a 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1504,7 +1504,8 @@ gb_internal bool init_build_paths(String init_filename) { if (build_context.metrics.os == TargetOs_windows) { output_extension = STR_LIT("exe"); } else if (build_context.cross_compiling && selected_target_metrics->metrics == &target_essence_amd64) { - output_extension = make_string(nullptr, 0); + // Do nothing: we don't want the .bin extension + // when cross compiling } else if (path_is_directory(last_path_element(bc->build_paths[BuildPath_Main_Package].basename))) { // Add .bin extension to avoid collision // with package directory name @@ -1624,6 +1625,22 @@ gb_internal bool init_build_paths(String init_filename) { return false; } + if (path_is_directory(bc->build_paths[BuildPath_Output])) { + String output_file = path_to_string(ha, bc->build_paths[BuildPath_Output]); + defer (gb_free(ha, output_file.text)); + gb_printf_err("Output path %.*s is a directory.\n", LIT(output_file)); + return false; + } + //nocheckin char const *pathname = (char *)bc->build_paths[BuildPath_Output].basename.text; + + if (!write_directory(bc->build_paths[BuildPath_Output].basename)) { + String output_file = path_to_string(ha, bc->build_paths[BuildPath_Output]); + defer (gb_free(ha, output_file.text)); + gb_printf_err("No write permissions for output path: %.*s\n", LIT(output_file)); + return false; + } + + if (bc->target_features_string.len != 0) { enable_target_feature({}, bc->target_features_string); } diff --git a/src/path.cpp b/src/path.cpp index 3054e3b57..c9887e9ca 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -419,7 +419,43 @@ gb_internal ReadDirectoryError read_directory(String path, Array *fi) return ReadDirectory_None; } + + #else #error Implement read_directory #endif +#if !defined(GB_SYSTEM_WINDOWS) +gb_internal bool write_directory(String path) { + char const *pathname = (char *) path.text; + + if (access(pathname, W_OK) < 0) { + return false; + } + + return true; +} +#else +gb_internal bool write_directory(String path) { + String16wstr = string_to_string16(heap_allocator(), path); + LPCWSTR wdirectory_name = wstr.text; + + HANDLE directory = CreateFileW(wdirectory_name, + GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, + NULL); + + if (directory == INVALID_HANDLE_VALUE) { + DWORD error_code = GetLastError(); + if (error_code == ERROR_ACCESS_DENIED) { + return false; + } + } + + CloseHandle(directory); + return true; +} +#endif From 775a488a3688a1ce3157366a368349de32279f8c Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Fri, 19 May 2023 18:53:43 +0100 Subject: [PATCH 029/108] Fix windows write_directory() --- src/path.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/path.cpp b/src/path.cpp index c9887e9ca..de80c9def 100644 --- a/src/path.cpp +++ b/src/path.cpp @@ -437,7 +437,7 @@ gb_internal bool write_directory(String path) { } #else gb_internal bool write_directory(String path) { - String16wstr = string_to_string16(heap_allocator(), path); + String16 wstr = string_to_string16(heap_allocator(), path); LPCWSTR wdirectory_name = wstr.text; HANDLE directory = CreateFileW(wdirectory_name, From fa1ce7d5d1dc96c7d02184c6c706533bfbf0796b Mon Sep 17 00:00:00 2001 From: Mark Naughton Date: Fri, 19 May 2023 18:56:35 +0100 Subject: [PATCH 030/108] Fix accidental check in --- src/build_settings.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 018c3741a..7c9531da1 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1625,14 +1625,6 @@ gb_internal bool init_build_paths(String init_filename) { return false; } - if (path_is_directory(bc->build_paths[BuildPath_Output])) { - String output_file = path_to_string(ha, bc->build_paths[BuildPath_Output]); - defer (gb_free(ha, output_file.text)); - gb_printf_err("Output path %.*s is a directory.\n", LIT(output_file)); - return false; - } - //nocheckin char const *pathname = (char *)bc->build_paths[BuildPath_Output].basename.text; - if (!write_directory(bc->build_paths[BuildPath_Output].basename)) { String output_file = path_to_string(ha, bc->build_paths[BuildPath_Output]); defer (gb_free(ha, output_file.text)); From 223ae61c89d9dbfc435ffc0bbd3542fd3cc41bb3 Mon Sep 17 00:00:00 2001 From: Elusive Porpoise <95202750+elusivePorpoise@users.noreply.github.com> Date: Fri, 19 May 2023 11:36:16 -0700 Subject: [PATCH 031/108] added error printing --- examples/demo/demo.odin | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin index 2ea69a774..3b9aa73ca 100644 --- a/examples/demo/demo.odin +++ b/examples/demo/demo.odin @@ -2145,6 +2145,10 @@ or_return_operator :: proc() { return -345 * z, zerr } + defer if err != nil { + fmt.println("Error in", #procedure, ":" , err) + } + n = 123 return } From 46bb9bc5c78bb1199d6bb6f0737f570127238bec Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 20 May 2023 12:41:30 +0100 Subject: [PATCH 032/108] Enforce an `icmp` when casting to `i1` to correct behaviour for booleans which are not 0 or 1 --- src/llvm_backend_expr.cpp | 79 ++++++++++++++++----------------------- 1 file changed, 33 insertions(+), 46 deletions(-) diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index 67c201677..69443c9a3 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -1,20 +1,18 @@ gb_internal lbValue lb_emit_arith_matrix(lbProcedure *p, TokenKind op, lbValue lhs, lbValue rhs, Type *type, bool component_wise); -gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, Ast *left, Ast *right, Type *type) { +gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, Ast *left, Ast *right, Type *final_type) { lbModule *m = p->module; lbBlock *rhs = lb_create_block(p, "logical.cmp.rhs"); lbBlock *done = lb_create_block(p, "logical.cmp.done"); - type = default_type(type); - lbValue short_circuit = {}; if (op == Token_CmpAnd) { lb_build_cond(p, left, rhs, done); - short_circuit = lb_const_bool(m, type, false); + short_circuit = lb_const_bool(m, t_llvm_bool, false); } else if (op == Token_CmpOr) { lb_build_cond(p, left, done, rhs); - short_circuit = lb_const_bool(m, type, true); + short_circuit = lb_const_bool(m, t_llvm_bool, true); } if (rhs->preds.count == 0) { @@ -25,7 +23,7 @@ gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, As if (done->preds.count == 0) { lb_start_block(p, rhs); if (lb_is_expr_untyped_const(right)) { - return lb_expr_untyped_const_to_typed(m, right, type); + return lb_expr_untyped_const_to_typed(m, right, default_type(final_type)); } return lb_build_expr(p, right); } @@ -43,10 +41,11 @@ gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, As lb_start_block(p, rhs); lbValue edge = {}; if (lb_is_expr_untyped_const(right)) { - edge = lb_expr_untyped_const_to_typed(m, right, type); + edge = lb_expr_untyped_const_to_typed(m, right, t_llvm_bool); } else { - edge = lb_build_expr(p, right); + edge = lb_emit_conv(p, lb_build_expr(p, right), t_llvm_bool); } + GB_ASSERT(edge.type == t_llvm_bool); incoming_values[done->preds.count] = edge.value; incoming_blocks[done->preds.count] = p->curr_block->block; @@ -54,7 +53,7 @@ gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, As lb_emit_jump(p, done); lb_start_block(p, done); - LLVMTypeRef dst_type = lb_type(m, type); + LLVMTypeRef dst_type = lb_type(m, t_llvm_bool); LLVMValueRef phi = nullptr; GB_ASSERT(incoming_values.count == incoming_blocks.count); @@ -67,48 +66,36 @@ gb_internal lbValue lb_emit_logical_binary_expr(lbProcedure *p, TokenKind op, As break; } } + + lbValue res = {}; if (phi_type == nullptr) { phi = LLVMBuildPhi(p->builder, dst_type, ""); LLVMAddIncoming(phi, incoming_values.data, incoming_blocks.data, cast(unsigned)incoming_values.count); - lbValue res = {}; - res.type = type; res.value = phi; - return res; - } - - for_array(i, incoming_values) { - LLVMValueRef incoming_value = incoming_values[i]; - LLVMTypeRef incoming_type = LLVMTypeOf(incoming_value); - - if (phi_type != incoming_type) { - GB_ASSERT_MSG(LLVMIsConstant(incoming_value), "%s vs %s", LLVMPrintTypeToString(phi_type), LLVMPrintTypeToString(incoming_type)); - bool ok = !!LLVMConstIntGetZExtValue(incoming_value); - incoming_values[i] = LLVMConstInt(phi_type, ok, false); - } - - } - - phi = LLVMBuildPhi(p->builder, phi_type, ""); - LLVMAddIncoming(phi, incoming_values.data, incoming_blocks.data, cast(unsigned)incoming_values.count); - - LLVMTypeRef i1 = LLVMInt1TypeInContext(m->ctx); - if ((phi_type == i1) ^ (dst_type == i1)) { - if (phi_type == i1) { - phi = LLVMBuildZExt(p->builder, phi, dst_type, ""); - } else { - phi = LLVMBuildTruncOrBitCast(p->builder, phi, dst_type, ""); - } - } else if (lb_sizeof(phi_type) < lb_sizeof(dst_type)) { - phi = LLVMBuildZExt(p->builder, phi, dst_type, ""); + res.type = t_llvm_bool; } else { - phi = LLVMBuildTruncOrBitCast(p->builder, phi, dst_type, ""); - } - - lbValue res = {}; - res.type = type; - res.value = phi; - return res; + for_array(i, incoming_values) { + LLVMValueRef incoming_value = incoming_values[i]; + LLVMTypeRef incoming_type = LLVMTypeOf(incoming_value); + + if (phi_type != incoming_type) { + GB_ASSERT_MSG(LLVMIsConstant(incoming_value), "%s vs %s", LLVMPrintTypeToString(phi_type), LLVMPrintTypeToString(incoming_type)); + bool ok = !!LLVMConstIntGetZExtValue(incoming_value); + incoming_values[i] = LLVMConstInt(phi_type, ok, false); + } + + } + + // NOTE(bill): this now only uses i1 for the logic to prevent issues with corrupted booleans which are not of value 0 or 1 (e.g. 2) + // Doing this may produce slightly worse code as a result but it will be correct behaviour + + phi = LLVMBuildPhi(p->builder, phi_type, ""); + LLVMAddIncoming(phi, incoming_values.data, incoming_blocks.data, cast(unsigned)incoming_values.count); + res.value = phi; + res.type = t_llvm_bool; + } + return lb_emit_conv(p, res, default_type(final_type)); } @@ -1566,7 +1553,7 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { // bool <-> llvm bool if (is_type_boolean(src) && dst == t_llvm_bool) { lbValue res = {}; - res.value = LLVMBuildTrunc(p->builder, value.value, lb_type(m, dst), ""); + res.value = LLVMBuildICmp(p->builder, LLVMIntNE, value.value, LLVMConstNull(lb_type(m, src)), ""); res.type = t; return res; } From 9e5677ab0267ae48d3dd54c55710a132cd4efc04 Mon Sep 17 00:00:00 2001 From: ikarus Date: Sat, 20 May 2023 20:07:41 +0700 Subject: [PATCH 033/108] add missing fields to fontinfo --- vendor/stb/truetype/stb_truetype.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vendor/stb/truetype/stb_truetype.odin b/vendor/stb/truetype/stb_truetype.odin index 56bb0667a..5b0022da2 100644 --- a/vendor/stb/truetype/stb_truetype.odin +++ b/vendor/stb/truetype/stb_truetype.odin @@ -200,7 +200,7 @@ fontinfo :: struct { numGlyphs: c.int, - loca, head, glyf, hhea, hmtx, kern: c.int, + loca, head, glyf, hhea, hmtx, kern, gpos, svg: c.int, index_map: c.int, indexToLocFormat: c.int, From d77103e53e79bd5df7a24bec5b4c72cdc2fcf9d4 Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 18:18:50 -0400 Subject: [PATCH 034/108] Add MicromapUsageEXT** to convert_type We should probably parse this in parse_structs. --- vendor/vulkan/_gen/create_vulkan_odin_wrapper.py | 1 + 1 file changed, 1 insertion(+) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index 76d62f519..dbd87c498 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -70,6 +70,7 @@ def convert_type(t, prev_name, curr_name): "const void* const *": "[^]rawptr", "const AccelerationStructureGeometryKHR* const*": "^[^]AccelerationStructureGeometryKHR", "const AccelerationStructureBuildRangeInfoKHR* const*": "^[^]AccelerationStructureBuildRangeInfoKHR", + "const MicromapUsageEXT* const*": "^[^]MicromapUsageEXT", "struct BaseOutStructure": "BaseOutStructure", "struct BaseInStructure": "BaseInStructure", "struct wl_display": "wl_display", From 66461c9dbc2baae8d4ed4f8585713f8649cee2d2 Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 18:28:39 -0400 Subject: [PATCH 035/108] Parse Vulkan Video headers --- vendor/vulkan/_gen/create_vulkan_odin_wrapper.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index dbd87c498..e90c32659 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -16,6 +16,11 @@ file_and_urls = [ ("vulkan_macos.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_macos.h', False), ("vulkan_ios.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_ios.h', False), ("vulkan_wayland.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vulkan/vulkan_wayland.h', False), + # Vulkan Video + ("vulkan_video_codec_h264std.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vk_video/vulkan_video_codec_h264std.h', False), + ("vulkan_video_codec_h265std.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vk_video/vulkan_video_codec_h265std.h', False), + ("vulkan_video_codec_h264std_decode.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vk_video/vulkan_video_codec_h264std_decode.h', False), + ("vulkan_video_codec_h265std_decode.h", 'https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/main/include/vk_video/vulkan_video_codec_h265std_decode.h', False), ] for file, url, _ in file_and_urls: @@ -37,6 +42,9 @@ def no_vk(t): t = t.replace('PFN_', 'Proc') t = t.replace('PFN_', 'Proc') t = t.replace('VK_', '') + # Vulkan Video + t = t.replace('STD_', '') + t = t.replace('Std', '') return t OPAQUE_STRUCTS = """ @@ -267,6 +275,8 @@ def parse_constants(f): inner = r"((?:(?:" + fixes + r")\w+)|(?:\w+" + fixes + r"))" pattern = r"#define\s+VK_" + inner + r"\s*(.*?)\n" data = re.findall(pattern, src, re.S) + vulkan_video_find_pattern = r"#define\s+STD_" + inner + r"\s*(.*?)\n" + data += re.findall(vulkan_video_find_pattern, src, re.S) number_suffix_re = re.compile(r"(\d+)[UuLlFf]") @@ -285,6 +295,7 @@ def parse_enums(f): f.write("// Enums\n") data = re.findall(r"typedef enum Vk(\w+) {(.+?)} \w+;", src, re.S) + data += re.findall(r"typedef enum Std(\w+) {(.+?)} \w+;", src, re.S) data.sort(key=lambda x: x[0]) @@ -407,6 +418,7 @@ def parse_enums(f): def parse_structs(f): data = re.findall(r"typedef (struct|union) Vk(\w+?) {(.+?)} \w+?;", src, re.S) + data += re.findall(r"typedef (struct|union) Std(\w+?) {(.+?)} \w+?;", src, re.S) for _type, name, fields in data: fields = re.findall(r"\s+(.+?)\s+([_a-zA-Z0-9[\]]+);", fields) From c5c723b80ca6705b4234c6fac01a41356e1982ee Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 18:40:38 -0400 Subject: [PATCH 036/108] Parse C bit fields in parse_structs --- vendor/vulkan/_gen/create_vulkan_odin_wrapper.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index e90c32659..79962ada9 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -64,6 +64,7 @@ def convert_type(t, prev_name, curr_name): 'int64_t': 'i64', 'int': 'c.int', 'uint8_t': 'u8', + 'int8_t': 'i8', "uint16_t": 'u16', "char": "byte", "void": "void", @@ -430,6 +431,18 @@ def parse_structs(f): prev_name = "" ffields = [] for type_, fname in fields: + + # If the typename has a colon in it, then it is a C bit field. + if ":" in type_: + bit_field = type_.split(' ') + # Get rid of empty spaces + bit_field = list(filter(bool, bit_field)) + # [type, typename, :] + assert len(bit_field) == 3, "Failed to parse the bit field!" + bit_field_type = do_type(bit_field[0], prev_name, fname) + f.write("\tbit_field: {},{}\n".format(bit_field_type, comment or "")) + break + if '[' in fname: fname, type_ = parse_array(fname, type_) comment = None @@ -443,7 +456,7 @@ def parse_structs(f): ffields.append(tuple([n, t, comment])) prev_name = fname - max_len = max(len(n) for n, _, _ in ffields) + max_len = max([len(n) for n, _, _ in ffields], default=0) for n, t, comment in ffields: k = max_len-len(n)+len(t) From 2167f1b567fa8474325137f8bb950e0b0cd0225e Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 18:58:40 -0400 Subject: [PATCH 037/108] Make sure the 's' is after Flags and not the ext name --- vendor/vulkan/_gen/create_vulkan_odin_wrapper.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index 79962ada9..07f6c6b46 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -397,7 +397,16 @@ def parse_enums(f): used_flags.append('.'+flags[i]) else: used_flags.append('{}({})'.format(enum_name, i)) - s = "{enum_name}s_{n} :: {enum_name}s{{".format(enum_name=enum_name, n=n) + # Make sure the 's' is after Flags and not the extension name. + ext_suffix = '' + for suffix in ext_suffixes: + if not enum_name.endswith(suffix): + continue + + ext_suffix = suffix + enum_name = remove_suffix(enum_name, ext_suffix) + break + s = "{enum_name}s{ext_suffix}_{n} :: {enum_name}s{ext_suffix}{{".format(enum_name=enum_name, ext_suffix=ext_suffix, n=n) s += ', '.join(used_flags) s += "}\n" f.write(s) From a144a49a9ab53abe3747fdecc610b28d92a62caf Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 19:07:34 -0400 Subject: [PATCH 038/108] Parse vulkan video constants in seperate section and add MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT to the base constants --- .../vulkan/_gen/create_vulkan_odin_wrapper.py | 51 ++++++++++--------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index 07f6c6b46..fb9c5b0b4 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -271,13 +271,17 @@ def parse_constants(f): for name, value in allowed_data: f.write("{}{} :: {}\n".format(name, "".rjust(max_len-len(name)), value)) + f.write("\n// Vulkan Video Constants\n") + vulkan_video_data = re.findall(r"#define STD_(\w+)\s*(.*?)U?\n", src, re.S) + max_len = max(len(name) for name, value in vulkan_video_data) + for name, value in vulkan_video_data: + f.write("{}{} :: {}\n".format(name, "".rjust(max_len-len(name)), value)) + f.write("\n// Vendor Constants\n") fixes = '|'.join(ext_suffixes) inner = r"((?:(?:" + fixes + r")\w+)|(?:\w+" + fixes + r"))" pattern = r"#define\s+VK_" + inner + r"\s*(.*?)\n" data = re.findall(pattern, src, re.S) - vulkan_video_find_pattern = r"#define\s+STD_" + inner + r"\s*(.*?)\n" - data += re.findall(vulkan_video_find_pattern, src, re.S) number_suffix_re = re.compile(r"(\d+)[UuLlFf]") @@ -695,27 +699,28 @@ SetProcAddressType :: #type proc(p: rawptr, name: cstring) RemoteAddressNV :: distinct rawptr // Declared inline before MemoryGetRemoteAddressInfoNV // Base constants -LOD_CLAMP_NONE :: 1000.0 -REMAINING_MIP_LEVELS :: ~u32(0) -REMAINING_ARRAY_LAYERS :: ~u32(0) -WHOLE_SIZE :: ~u64(0) -ATTACHMENT_UNUSED :: ~u32(0) -TRUE :: 1 -FALSE :: 0 -QUEUE_FAMILY_IGNORED :: ~u32(0) -SUBPASS_EXTERNAL :: ~u32(0) -MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256 -UUID_SIZE :: 16 -MAX_MEMORY_TYPES :: 32 -MAX_MEMORY_HEAPS :: 16 -MAX_EXTENSION_NAME_SIZE :: 256 -MAX_DESCRIPTION_SIZE :: 256 -MAX_DEVICE_GROUP_SIZE :: 32 -LUID_SIZE_KHX :: 8 -LUID_SIZE :: 8 -MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(1) -MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16 -QUEUE_FAMILY_EXTERNAL :: MAX_QUEUE_FAMILY_EXTERNAL +LOD_CLAMP_NONE :: 1000.0 +REMAINING_MIP_LEVELS :: ~u32(0) +REMAINING_ARRAY_LAYERS :: ~u32(0) +WHOLE_SIZE :: ~u64(0) +ATTACHMENT_UNUSED :: ~u32(0) +TRUE :: 1 +FALSE :: 0 +QUEUE_FAMILY_IGNORED :: ~u32(0) +SUBPASS_EXTERNAL :: ~u32(0) +MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256 +MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT :: 32 +UUID_SIZE :: 16 +MAX_MEMORY_TYPES :: 32 +MAX_MEMORY_HEAPS :: 16 +MAX_EXTENSION_NAME_SIZE :: 256 +MAX_DESCRIPTION_SIZE :: 256 +MAX_DEVICE_GROUP_SIZE :: 32 +LUID_SIZE_KHX :: 8 +LUID_SIZE :: 8 +MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(1) +MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16 +QUEUE_FAMILY_EXTERNAL :: MAX_QUEUE_FAMILY_EXTERNAL """[1::]) parse_constants(f) From f0b08a6c6746e712c40ddf65d9cc9694a45a26eb Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 19:14:19 -0400 Subject: [PATCH 039/108] Add required metal types --- vendor/vulkan/_gen/create_vulkan_odin_wrapper.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py index fb9c5b0b4..26bfc0a82 100644 --- a/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py +++ b/vendor/vulkan/_gen/create_vulkan_odin_wrapper.py @@ -48,8 +48,9 @@ def no_vk(t): return t OPAQUE_STRUCTS = """ -wl_surface :: struct {} // Opaque struct defined by Wayland -wl_display :: struct {} // Opaque struct defined by Wayland +wl_surface :: struct {} // Opaque struct defined by Wayland +wl_display :: struct {} // Opaque struct defined by Wayland +IOSurfaceRef :: struct {} // Opaque struct defined by Apple’s CoreGraphics framework """ def convert_type(t, prev_name, curr_name): @@ -766,6 +767,12 @@ when ODIN_OS == .Windows { CAMetalLayer :: struct {} +MTLBuffer_id :: rawptr +MTLTexture_id :: rawptr +MTLSharedEvent_id :: rawptr +MTLDevice_id :: rawptr +MTLCommandQueue_id :: rawptr + /********************************/ """) f.write("\n") From 87788142bf33eb865f6d45273130d15c108593d8 Mon Sep 17 00:00:00 2001 From: NoahR02 Date: Sat, 20 May 2023 19:15:32 -0400 Subject: [PATCH 040/108] Generate the new vulkan files --- vendor/vulkan/_gen/vk_icd.h | 31 +- vendor/vulkan/_gen/vk_layer.h | 17 +- vendor/vulkan/_gen/vk_platform.h | 2 +- vendor/vulkan/_gen/vulkan_core.h | 3268 +++++++- vendor/vulkan/_gen/vulkan_ios.h | 2 +- vendor/vulkan/_gen/vulkan_macos.h | 2 +- vendor/vulkan/_gen/vulkan_metal.h | 143 +- .../vulkan/_gen/vulkan_video_codec_h264std.h | 310 + .../_gen/vulkan_video_codec_h264std_decode.h | 75 + .../vulkan/_gen/vulkan_video_codec_h265std.h | 443 ++ .../_gen/vulkan_video_codec_h265std_decode.h | 65 + vendor/vulkan/_gen/vulkan_win32.h | 20 +- vendor/vulkan/core.odin | 1680 +++-- vendor/vulkan/enums.odin | 2558 ++++--- vendor/vulkan/procedures.odin | 6540 +++++++++-------- vendor/vulkan/structs.odin | 2313 +++++- 16 files changed, 12312 insertions(+), 5157 deletions(-) create mode 100644 vendor/vulkan/_gen/vulkan_video_codec_h264std.h create mode 100644 vendor/vulkan/_gen/vulkan_video_codec_h264std_decode.h create mode 100644 vendor/vulkan/_gen/vulkan_video_codec_h265std.h create mode 100644 vendor/vulkan/_gen/vulkan_video_codec_h265std_decode.h diff --git a/vendor/vulkan/_gen/vk_icd.h b/vendor/vulkan/_gen/vk_icd.h index 41989ee35..2cd6c3d33 100644 --- a/vendor/vulkan/_gen/vk_icd.h +++ b/vendor/vulkan/_gen/vk_icd.h @@ -2,9 +2,9 @@ // File: vk_icd.h // /* - * Copyright (c) 2015-2016 The Khronos Group Inc. - * Copyright (c) 2015-2016 Valve Corporation - * Copyright (c) 2015-2016 LunarG, Inc. + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,9 +19,7 @@ * limitations under the License. * */ - -#ifndef VKICD_H -#define VKICD_H +#pragma once #include "vulkan.h" #include @@ -42,7 +40,17 @@ // call for any API version > 1.0. Otherwise, the loader will // manually determine if it can support the expected version. // Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices. -#define CURRENT_LOADER_ICD_INTERFACE_VERSION 6 +// Version 7 - If an ICD supports any of the following functions, they must be +// queryable with vk_icdGetInstanceProcAddr: +// vk_icdNegotiateLoaderICDInterfaceVersion +// vk_icdGetPhysicalDeviceProcAddr +// vk_icdEnumerateAdapterPhysicalDevices (Windows only) +// In addition, these functions no longer need to be exported directly. +// This version allows drivers provided through the extension +// VK_LUNARG_direct_driver_loading be able to support the entire +// Driver-Loader interface. + +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7 #define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 #define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 @@ -70,7 +78,7 @@ extern "C" { #endif VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion); VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName); - VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance isntance, const char* pName); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName); #if defined(VK_USE_PLATFORM_WIN32_KHR) VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); @@ -123,6 +131,7 @@ typedef enum { VK_ICD_WSI_PLATFORM_VI, VK_ICD_WSI_PLATFORM_GGP, VK_ICD_WSI_PLATFORM_SCREEN, + VK_ICD_WSI_PLATFORM_FUCHSIA, } VkIcdWsiPlatform; typedef struct { @@ -242,4 +251,8 @@ typedef struct { } VkIcdSurfaceScreen; #endif // VK_USE_PLATFORM_SCREEN_QNX -#endif // VKICD_H +#ifdef VK_USE_PLATFORM_FUCHSIA +typedef struct { + VkIcdSurfaceBase base; +} VkIcdSurfaceImagePipe; +#endif // VK_USE_PLATFORM_FUCHSIA diff --git a/vendor/vulkan/_gen/vk_layer.h b/vendor/vulkan/_gen/vk_layer.h index 0651870c7..7954f71d8 100644 --- a/vendor/vulkan/_gen/vk_layer.h +++ b/vendor/vulkan/_gen/vk_layer.h @@ -2,9 +2,9 @@ // File: vk_layer.h // /* - * Copyright (c) 2015-2017 The Khronos Group Inc. - * Copyright (c) 2015-2017 Valve Corporation - * Copyright (c) 2015-2017 LunarG, Inc. + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,21 +19,14 @@ * limitations under the License. * */ +#pragma once /* Need to define dispatch table * Core struct can then have ptr to dispatch table at the top * Along with object ptrs for current and next OBJ */ -#pragma once -#include "vulkan.h" -#if defined(__GNUC__) && __GNUC__ >= 4 -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define VK_LAYER_EXPORT __attribute__((visibility("default"))) -#else -#define VK_LAYER_EXPORT -#endif +#include "vulkan_core.h" #define MAX_NUM_UNKNOWN_EXTS 250 diff --git a/vendor/vulkan/_gen/vk_platform.h b/vendor/vulkan/_gen/vk_platform.h index 3ff8c5d14..ed67a6004 100644 --- a/vendor/vulkan/_gen/vk_platform.h +++ b/vendor/vulkan/_gen/vk_platform.h @@ -2,7 +2,7 @@ // File: vk_platform.h // /* -** Copyright 2014-2022 The Khronos Group Inc. +** Copyright 2014-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/vendor/vulkan/_gen/vulkan_core.h b/vendor/vulkan/_gen/vulkan_core.h index 5c8b8461f..a2e7ed3cb 100644 --- a/vendor/vulkan/_gen/vulkan_core.h +++ b/vendor/vulkan/_gen/vulkan_core.h @@ -2,7 +2,7 @@ #define VULKAN_CORE_H_ 1 /* -** Copyright 2015-2022 The Khronos Group Inc. +** Copyright 2015-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -58,37 +58,37 @@ extern "C" { #endif #endif -// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. -#define VK_MAKE_VERSION(major, minor, patch) \ - ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) +#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 - -#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ - ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Vulkan 1.0 version number #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 211 +#define VK_HEADER_VERSION 250 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) +// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. +#define VK_MAKE_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. -#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. -#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead. #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) -#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29) -#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU) -#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) +#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) +#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) +#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) typedef uint32_t VkBool32; typedef uint64_t VkDeviceAddress; @@ -120,7 +120,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) -#define VK_UUID_SIZE 16U #define VK_ATTACHMENT_UNUSED (~0U) #define VK_FALSE 0U #define VK_LOD_CLAMP_NONE 1000.0F @@ -131,10 +130,11 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) #define VK_TRUE 1U #define VK_WHOLE_SIZE (~0ULL) #define VK_MAX_MEMORY_TYPES 32U -#define VK_MAX_MEMORY_HEAPS 16U #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U +#define VK_UUID_SIZE 16U #define VK_MAX_EXTENSION_NAME_SIZE 256U #define VK_MAX_DESCRIPTION_SIZE 256U +#define VK_MAX_MEMORY_HEAPS 16U typedef enum VkResult { VK_SUCCESS = 0, @@ -168,6 +168,12 @@ typedef enum VkResult { VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, VK_ERROR_NOT_PERMITTED_KHR = -1000174001, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, @@ -175,6 +181,11 @@ typedef enum VkResult { VK_THREAD_DONE_KHR = 1000268001, VK_OPERATION_DEFERRED_KHR = 1000268002, VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, +#endif + VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, @@ -424,63 +435,26 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, -#endif + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, @@ -508,13 +482,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008, @@ -522,9 +493,6 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, #endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT = 1000038010, -#endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, #endif @@ -541,16 +509,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT = 1000039005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT = 1000039006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT = 1000039007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT = 1000039008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007, #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009, @@ -558,27 +520,12 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, #endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040006, -#endif + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, @@ -595,6 +542,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, @@ -738,24 +688,12 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187005, -#endif + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, @@ -767,7 +705,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, @@ -832,7 +769,18 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, + VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, @@ -855,6 +803,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -868,14 +819,49 @@ typedef enum VkStructureType { #endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, #endif VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, @@ -883,21 +869,31 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = 1000338002, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = 1000338003, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = 1000342000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, @@ -922,26 +918,109 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, + VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, + VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, + VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -1047,6 +1126,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, @@ -1103,16 +1183,26 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF } VkStructureType; +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + typedef enum VkImageLayout { VK_IMAGE_LAYOUT_UNDEFINED = 0, VK_IMAGE_LAYOUT_GENERAL = 1, @@ -1132,15 +1222,9 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, -#endif VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, @@ -1153,6 +1237,7 @@ typedef enum VkImageLayout { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, #endif + VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, @@ -1200,12 +1285,8 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, -#endif VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, @@ -1216,17 +1297,15 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, + VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF } VkObjectType; -typedef enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheHeaderVersion; - typedef enum VkVendorId { VK_VENDOR_ID_VIV = 0x10001, VK_VENDOR_ID_VSI = 0x10002, @@ -1234,6 +1313,7 @@ typedef enum VkVendorId { VK_VENDOR_ID_CODEPLAY = 0x10004, VK_VENDOR_ID_MESA = 0x10005, VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MOBILEYE = 0x10007, VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF } VkVendorId; @@ -1499,6 +1579,7 @@ typedef enum VkFormat { VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_R16G16_S10_5_NV = 1000464000, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, @@ -1583,9 +1664,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_OCCLUSION = 0, VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, VK_QUERY_TYPE_TIMESTAMP = 2, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, -#endif VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, @@ -1593,9 +1672,14 @@ typedef enum VkQueryType { VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, #ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000, + VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, #endif + VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF } VkQueryType; @@ -1744,10 +1828,13 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, @@ -1755,6 +1842,38 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, + VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, + VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, + VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, + VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, + VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, + VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, + VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, + VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, + VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, + VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, + VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, + VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, + VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, + VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, @@ -1855,8 +1974,8 @@ typedef enum VkBorderColor { typedef enum VkFilter { VK_FILTER_NEAREST = 0, VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_IMG = 1000015000, - VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG, + VK_FILTER_CUBIC_EXT = 1000015000, + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, VK_FILTER_MAX_ENUM = 0x7FFFFFFF } VkFilter; @@ -1891,8 +2010,11 @@ typedef enum VkDescriptorType { VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000, + VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF } VkDescriptorType; @@ -2027,14 +2149,10 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, -#endif VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -2043,6 +2161,7 @@ typedef enum VkFormatFeatureFlagBits { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, #endif + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, @@ -2053,7 +2172,6 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkFormatFeatureFlagBits; typedef VkFlags VkFormatFeatureFlags; @@ -2074,6 +2192,8 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, + VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, @@ -2107,15 +2227,9 @@ typedef enum VkImageUsageFlagBits { VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, -#endif VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -2127,7 +2241,10 @@ typedef enum VkImageUsageFlagBits { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, #endif + VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, + VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkImageUsageFlagBits; @@ -2167,12 +2284,11 @@ typedef enum VkQueueFlagBits { VK_QUEUE_TRANSFER_BIT = 0x00000004, VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, VK_QUEUE_PROTECTED_BIT = 0x00000010, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, -#endif #ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, #endif + VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkQueueFlagBits; typedef VkFlags VkQueueFlags; @@ -2207,14 +2323,16 @@ typedef enum VkPipelineStageFlagBits { VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineStageFlagBits; @@ -2261,6 +2379,9 @@ typedef enum VkQueryPipelineStatisticFlagBits { VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, + VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, + VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkQueryPipelineStatisticFlagBits; typedef VkFlags VkQueryPipelineStatisticFlags; @@ -2271,9 +2392,7 @@ typedef enum VkQueryResultFlagBits { VK_QUERY_RESULT_WAIT_BIT = 0x00000002, VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, -#endif VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkQueryResultFlagBits; typedef VkFlags VkQueryResultFlags; @@ -2284,6 +2403,7 @@ typedef enum VkBufferCreateFlagBits { VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, + VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -2301,12 +2421,8 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, -#endif VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, @@ -2319,6 +2435,11 @@ typedef enum VkBufferUsageFlagBits { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, #endif + VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, + VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, + VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, + VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, + VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, @@ -2329,6 +2450,7 @@ typedef VkFlags VkBufferViewCreateFlags; typedef enum VkImageViewCreateFlagBits { VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkImageViewCreateFlagBits; @@ -2373,9 +2495,18 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, + VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, + VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, + VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, +#endif + VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000, + VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, @@ -2411,15 +2542,18 @@ typedef enum VkShaderStageFlagBits { VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, - VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, - VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, + VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, + VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, + VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkShaderStageFlagBits; @@ -2439,14 +2573,17 @@ typedef VkFlags VkPipelineRasterizationStateCreateFlags; typedef VkFlags VkPipelineMultisampleStateCreateFlags; typedef enum VkPipelineDepthStencilStateCreateFlagBits { - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = 0x00000001, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = 0x00000002, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineDepthStencilStateCreateFlagBits; typedef VkFlags VkPipelineDepthStencilStateCreateFlags; typedef enum VkPipelineColorBlendStateCreateFlagBits { - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = 0x00000001, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineColorBlendStateCreateFlagBits; typedef VkFlags VkPipelineColorBlendStateCreateFlags; @@ -2462,6 +2599,9 @@ typedef VkFlags VkShaderStageFlags; typedef enum VkSamplerCreateFlagBits { VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, + VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSamplerCreateFlagBits; typedef VkFlags VkSamplerCreateFlags; @@ -2469,8 +2609,9 @@ typedef VkFlags VkSamplerCreateFlags; typedef enum VkDescriptorPoolCreateFlagBits { VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDescriptorPoolCreateFlagBits; typedef VkFlags VkDescriptorPoolCreateFlags; @@ -2479,8 +2620,11 @@ typedef VkFlags VkDescriptorPoolResetFlags; typedef enum VkDescriptorSetLayoutCreateFlagBits { VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDescriptorSetLayoutCreateFlagBits; typedef VkFlags VkDescriptorSetLayoutCreateFlags; @@ -2495,6 +2639,7 @@ typedef enum VkDependencyFlagBits { VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -2519,9 +2664,13 @@ typedef enum VkSubpassDescriptionFlagBits { VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = 0x00000010, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = 0x00000020, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = 0x00000040, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, + VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSubpassDescriptionFlagBits; typedef VkFlags VkSubpassDescriptionFlags; @@ -5524,6 +5673,9 @@ typedef enum VkDriverId { VK_DRIVER_ID_MESA_PANVK = 20, VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, VK_DRIVER_ID_MESA_VENUS = 22, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, @@ -6336,9 +6488,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; -#endif #ifdef VK_ENABLE_BETA_EXTENSIONS static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; #endif @@ -6354,8 +6504,14 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; typedef VkFlags64 VkAccessFlags2; @@ -6403,12 +6559,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; -#endif #ifdef VK_ENABLE_BETA_EXTENSIONS static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; #endif @@ -6429,7 +6581,13 @@ static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; typedef enum VkSubmitFlagBits { @@ -6443,6 +6601,7 @@ typedef enum VkRenderingFlagBits { VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, VK_RENDERING_SUSPENDING_BIT = 0x00000002, VK_RENDERING_RESUMING_BIT = 0x00000004, + VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, @@ -6507,12 +6666,8 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; -#endif static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; @@ -6523,6 +6678,13 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; #endif static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; typedef struct VkPhysicalDeviceVulkan13Features { VkStructureType sType; @@ -7399,6 +7561,7 @@ typedef enum VkSwapchainCreateFlagBitsKHR { VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkSwapchainCreateFlagBitsKHR; typedef VkFlags VkSwapchainCreateFlagsKHR; @@ -7702,6 +7865,412 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" +#define VK_KHR_video_queue 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) +#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" + +typedef enum VkQueryResultStatusKHR { + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueryResultStatusKHR; + +typedef enum VkVideoCodecOperationFlagBitsKHR { + VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000, +#endif + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodecOperationFlagBitsKHR; +typedef VkFlags VkVideoCodecOperationFlagsKHR; + +typedef enum VkVideoChromaSubsamplingFlagBitsKHR { + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoChromaSubsamplingFlagBitsKHR; +typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + +typedef enum VkVideoComponentBitDepthFlagBitsKHR { + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoComponentBitDepthFlagBitsKHR; +typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + +typedef enum VkVideoCapabilityFlagBitsKHR { + VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCapabilityFlagBitsKHR; +typedef VkFlags VkVideoCapabilityFlagsKHR; + +typedef enum VkVideoSessionCreateFlagBitsKHR { + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionCreateFlagsKHR; +typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; +typedef VkFlags VkVideoBeginCodingFlagsKHR; +typedef VkFlags VkVideoEndCodingFlagsKHR; + +typedef enum VkVideoCodingControlFlagBitsKHR { + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0x00000004, +#endif + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingControlFlagBitsKHR; +typedef VkFlags VkVideoCodingControlFlagsKHR; +typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 queryResultStatusSupport; +} VkQueueFamilyQueryResultStatusPropertiesKHR; + +typedef struct VkQueueFamilyVideoPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkQueueFamilyVideoPropertiesKHR; + +typedef struct VkVideoProfileInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileInfoKHR; + +typedef struct VkVideoProfileListInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t profileCount; + const VkVideoProfileInfoKHR* pProfiles; +} VkVideoProfileListInfoKHR; + +typedef struct VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; +} VkVideoCapabilitiesKHR; + +typedef struct VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; +} VkPhysicalDeviceVideoFormatInfoKHR; + +typedef struct VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; +} VkVideoFormatPropertiesKHR; + +typedef struct VkVideoPictureResourceInfoKHR { + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; +} VkVideoPictureResourceInfoKHR; + +typedef struct VkVideoReferenceSlotInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t slotIndex; + const VkVideoPictureResourceInfoKHR* pPictureResource; +} VkVideoReferenceSlotInfoKHR; + +typedef struct VkVideoSessionMemoryRequirementsKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryBindIndex; + VkMemoryRequirements memoryRequirements; +} VkVideoSessionMemoryRequirementsKHR; + +typedef struct VkBindVideoSessionMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +} VkBindVideoSessionMemoryInfoKHR; + +typedef struct VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileInfoKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + const VkExtensionProperties* pStdHeaderVersion; +} VkVideoSessionCreateInfoKHR; + +typedef struct VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +} VkVideoSessionParametersCreateInfoKHR; + +typedef struct VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR; + +typedef struct VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoBeginCodingInfoKHR; + +typedef struct VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR; + +typedef struct VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); + +VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); +#endif + + +#define VK_KHR_video_decode_queue 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" + +typedef enum VkVideoDecodeCapabilityFlagBitsKHR { + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; + +typedef enum VkVideoDecodeUsageFlagBitsKHR { + VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, + VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeUsageFlagBitsKHR; +typedef VkFlags VkVideoDecodeUsageFlagsKHR; +typedef VkFlags VkVideoDecodeFlagsKHR; +typedef struct VkVideoDecodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoDecodeCapabilityFlagsKHR flags; +} VkVideoDecodeCapabilitiesKHR; + +typedef struct VkVideoDecodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeUsageFlagsKHR videoUsageHints; +} VkVideoDecodeUsageInfoKHR; + +typedef struct VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceInfoKHR dstPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoDecodeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo); +#endif + + +#define VK_KHR_video_decode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 8 +#define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264" + +typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeH264PictureLayoutFlagBitsKHR; +typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; +typedef struct VkVideoDecodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; +} VkVideoDecodeH264ProfileInfoKHR; + +typedef struct VkVideoDecodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; +} VkVideoDecodeH264CapabilitiesKHR; + +typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoDecodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + uint32_t sliceCount; + const uint32_t* pSliceOffsets; +} VkVideoDecodeH264PictureInfoKHR; + +typedef struct VkVideoDecodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoKHR; + + + #define VK_KHR_dynamic_rendering 1 #define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 #define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering" @@ -8815,6 +9384,59 @@ typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { +#define VK_KHR_video_decode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265" +typedef struct VkVideoDecodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoDecodeH265ProfileInfoKHR; + +typedef struct VkVideoDecodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoDecodeH265CapabilitiesKHR; + +typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoDecodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265PictureInfo* pStdPictureInfo; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets; +} VkVideoDecodeH265PictureInfoKHR; + +typedef struct VkVideoDecodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH265DpbSlotInfoKHR; + + + #define VK_KHR_global_priority 1 #define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16U #define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1 @@ -9238,6 +9860,41 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR #endif +#define VK_KHR_map_memory2 1 +#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" +typedef VkFlags VkMemoryUnmapFlagsKHR; +typedef struct VkMemoryMapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMemoryMapInfoKHR; + +typedef struct VkMemoryUnmapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryUnmapFlagsKHR flags; + VkDeviceMemory memory; +} VkMemoryUnmapInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); +typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); +#endif + + #define VK_KHR_shader_integer_dot_product 1 #define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1 #define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" @@ -9382,6 +10039,23 @@ VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( #endif +#define VK_KHR_fragment_shader_barycentric 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_KHR_fragment_shader_barycentric" +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; +} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + + #define VK_KHR_shader_subgroup_uniform_control_flow 1 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow" @@ -9474,7 +10148,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( #define VK_KHR_format_feature_flags2 1 -#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 1 +#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 #define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; @@ -9484,6 +10158,42 @@ typedef VkFormatProperties3 VkFormatProperties3KHR; +#define VK_KHR_ray_tracing_maintenance1 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1" +typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; +} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; + +typedef struct VkTraceRaysIndirectCommand2KHR { + VkDeviceAddress raygenShaderRecordAddress; + VkDeviceSize raygenShaderRecordSize; + VkDeviceAddress missShaderBindingTableAddress; + VkDeviceSize missShaderBindingTableSize; + VkDeviceSize missShaderBindingTableStride; + VkDeviceAddress hitShaderBindingTableAddress; + VkDeviceSize hitShaderBindingTableSize; + VkDeviceSize hitShaderBindingTableStride; + VkDeviceAddress callableShaderBindingTableAddress; + VkDeviceSize callableShaderBindingTableSize; + VkDeviceSize callableShaderBindingTableStride; + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommand2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress); +#endif + + #define VK_KHR_portability_enumeration 1 #define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1 #define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration" @@ -9523,6 +10233,17 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( #endif +#define VK_KHR_ray_tracing_position_fetch 1 +#define VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME "VK_KHR_ray_tracing_position_fetch" +typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPositionFetch; +} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; + + + #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10 @@ -10174,6 +10895,51 @@ typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { +#define VK_EXT_pipeline_robustness 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_pipeline_robustness" + +typedef enum VkPipelineRobustnessBufferBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessBufferBehaviorEXT; + +typedef enum VkPipelineRobustnessImageBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessImageBehaviorEXT; +typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineRobustness; +} VkPhysicalDevicePipelineRobustnessFeaturesEXT; + +typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT { + VkStructureType sType; + void* pNext; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; +} VkPhysicalDevicePipelineRobustnessPropertiesEXT; + +typedef struct VkPipelineRobustnessCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRobustnessBufferBehaviorEXT storageBuffers; + VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT vertexInputs; + VkPipelineRobustnessImageBehaviorEXT images; +} VkPipelineRobustnessCreateInfoEXT; + + + #define VK_EXT_conditional_rendering 1 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" @@ -10474,7 +11240,7 @@ typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { #define VK_EXT_discard_rectangles 1 -#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 2 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" typedef enum VkDiscardRectangleModeEXT { @@ -10499,6 +11265,8 @@ typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { } VkPipelineDiscardRectangleStateCreateInfoEXT; typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( @@ -10506,6 +11274,14 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); #endif @@ -10629,6 +11405,7 @@ typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkDebugUtilsMessageTypeFlagBitsEXT; typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; @@ -11299,6 +12076,8 @@ typedef enum VkGeometryInstanceFlagBitsKHR { VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, @@ -11319,6 +12098,13 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR { VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = 0x00000200, +#endif + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, @@ -11904,11 +12690,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( #define VK_NV_fragment_shader_barycentric 1 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" -typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderBarycentric; -} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; +typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; @@ -11924,7 +12706,7 @@ typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { #define VK_NV_scissor_exclusive 1 -#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 2 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { VkStructureType sType; @@ -11939,9 +12721,16 @@ typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { VkBool32 exclusiveScissor; } VkPhysicalDeviceExclusiveScissorFeaturesNV; +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); #ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); + VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, @@ -12779,6 +13568,105 @@ typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { +#define VK_EXT_surface_maintenance1 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_surface_maintenance1" + +typedef enum VkPresentScalingFlagBitsEXT { + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0x00000004, + VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentScalingFlagBitsEXT; +typedef VkFlags VkPresentScalingFlagsEXT; + +typedef enum VkPresentGravityFlagBitsEXT { + VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0x00000004, + VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentGravityFlagBitsEXT; +typedef VkFlags VkPresentGravityFlagsEXT; +typedef struct VkSurfacePresentModeEXT { + VkStructureType sType; + void* pNext; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeEXT; + +typedef struct VkSurfacePresentScalingCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkPresentScalingFlagsEXT supportedPresentScaling; + VkPresentGravityFlagsEXT supportedPresentGravityX; + VkPresentGravityFlagsEXT supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesEXT; + +typedef struct VkSurfacePresentModeCompatibilityEXT { + VkStructureType sType; + void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkSurfacePresentModeCompatibilityEXT; + + + +#define VK_EXT_swapchain_maintenance1 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_swapchain_maintenance1" +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; + +typedef struct VkSwapchainPresentFenceInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkFence* pFences; +} VkSwapchainPresentFenceInfoEXT; + +typedef struct VkSwapchainPresentModesCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModesCreateInfoEXT; + +typedef struct VkSwapchainPresentModeInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModeInfoEXT; + +typedef struct VkSwapchainPresentScalingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPresentScalingFlagsEXT scalingBehavior; + VkPresentGravityFlagsEXT presentGravityX; + VkPresentGravityFlagsEXT presentGravityY; +} VkSwapchainPresentScalingCreateInfoEXT; + +typedef struct VkReleaseSwapchainImagesInfoEXT { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices; +} VkReleaseSwapchainImagesInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); +#endif + + #define VK_EXT_shader_demote_to_helper_invocation 1 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" @@ -12800,6 +13688,7 @@ typedef enum VkIndirectCommandsTokenTypeNV { VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF } VkIndirectCommandsTokenTypeNV; @@ -13009,7 +13898,7 @@ typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBuff #define VK_QCOM_render_pass_transform 1 -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 3 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" typedef struct VkRenderPassTransformBeginInfoQCOM { VkStructureType sType; @@ -13141,6 +14030,29 @@ typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" +#define VK_NV_present_barrier 1 +#define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1 +#define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier" +typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrier; +} VkPhysicalDevicePresentBarrierFeaturesNV; + +typedef struct VkSurfaceCapabilitiesPresentBarrierNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierSupported; +} VkSurfaceCapabilitiesPresentBarrierNV; + +typedef struct VkSwapchainPresentBarrierCreateInfoNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierEnable; +} VkSwapchainPresentBarrierCreateInfoNV; + + + #define VK_EXT_private_data 1 typedef VkPrivateDataSlot VkPrivateDataSlotEXT; @@ -13195,13 +14107,14 @@ typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePip #define VK_NV_device_diagnostics_config 1 -#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1 +#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 2 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF } VkDeviceDiagnosticsConfigFlagBitsNV; typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; @@ -13224,6 +14137,229 @@ typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" +#define VK_NV_low_latency 1 +#define VK_NV_LOW_LATENCY_SPEC_VERSION 1 +#define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" +typedef struct VkQueryLowLatencySupportNV { + VkStructureType sType; + const void* pNext; + void* pQueriedLowLatencyData; +} VkQueryLowLatencySupportNV; + + + +#define VK_EXT_descriptor_buffer 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) +#define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 +#define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize maxSamplerDescriptorBufferRange; + VkDeviceSize maxResourceDescriptorBufferRange; + VkDeviceSize samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT; + +typedef struct VkDescriptorAddressInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkDeviceSize range; + VkFormat format; +} VkDescriptorAddressInfoEXT; + +typedef struct VkDescriptorBufferBindingInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT; + +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { + VkStructureType sType; + void* pNext; + VkBuffer buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + +typedef union VkDescriptorDataEXT { + const VkSampler* pSampler; + const VkDescriptorImageInfo* pCombinedImageSampler; + const VkDescriptorImageInfo* pInputAttachmentImage; + const VkDescriptorImageInfo* pSampledImage; + const VkDescriptorImageInfo* pStorageImage; + const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT* pUniformBuffer; + const VkDescriptorAddressInfoEXT* pStorageBuffer; + VkDeviceAddress accelerationStructure; +} VkDescriptorDataEXT; + +typedef struct VkDescriptorGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkDescriptorType type; + VkDescriptorDataEXT data; +} VkDescriptorGetInfoEXT; + +typedef struct VkBufferCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferCaptureDescriptorDataInfoEXT; + +typedef struct VkImageCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageCaptureDescriptorDataInfoEXT; + +typedef struct VkImageViewCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; +} VkImageViewCaptureDescriptorDataInfoEXT; + +typedef struct VkSamplerCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampler sampler; +} VkSamplerCaptureDescriptorDataInfoEXT; + +typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { + VkStructureType sType; + const void* pNext; + const void* opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT; + +typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; + VkAccelerationStructureNV accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + + #define VK_EXT_graphics_pipeline_library 1 #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1 #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library" @@ -13257,6 +14393,17 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { +#define VK_AMD_shader_early_and_late_fragment_tests 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME "VK_AMD_shader_early_and_late_fragment_tests" +typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 shaderEarlyAndLateFragmentTests; +} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + + #define VK_NV_fragment_shading_rate_enums 1 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums" @@ -13453,6 +14600,103 @@ typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessF +#define VK_EXT_image_compression_control 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME "VK_EXT_image_compression_control" + +typedef enum VkImageCompressionFlagBitsEXT { + VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFlagBitsEXT; +typedef VkFlags VkImageCompressionFlagsEXT; + +typedef enum VkImageCompressionFixedRateFlagBitsEXT { + VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, + VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, + VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, + VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, + VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, + VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, + VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, + VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, + VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, + VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, + VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, + VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, + VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, + VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, + VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, + VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, + VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, + VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, + VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, + VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, + VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, + VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFixedRateFlagBitsEXT; +typedef VkFlags VkImageCompressionFixedRateFlagsEXT; +typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControl; +} VkPhysicalDeviceImageCompressionControlFeaturesEXT; + +typedef struct VkImageCompressionControlEXT { + VkStructureType sType; + const void* pNext; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; +} VkImageCompressionControlEXT; + +typedef struct VkSubresourceLayout2EXT { + VkStructureType sType; + void* pNext; + VkSubresourceLayout subresourceLayout; +} VkSubresourceLayout2EXT; + +typedef struct VkImageSubresource2EXT { + VkStructureType sType; + void* pNext; + VkImageSubresource imageSubresource; +} VkImageSubresource2EXT; + +typedef struct VkImageCompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; +} VkImageCompressionPropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout); +#endif + + +#define VK_EXT_attachment_feedback_loop_layout 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION 2 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout" +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopLayout; +} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + + #define VK_EXT_4444_formats 1 #define VK_EXT_4444_FORMATS_SPEC_VERSION 1 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" @@ -13465,16 +14709,97 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { +#define VK_EXT_device_fault 1 +#define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 +#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" + +typedef enum VkDeviceFaultAddressTypeEXT { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultAddressTypeEXT; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionEXT; +typedef struct VkPhysicalDeviceFaultFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; +} VkPhysicalDeviceFaultFeaturesEXT; + +typedef struct VkDeviceFaultCountsEXT { + VkStructureType sType; + void* pNext; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize vendorBinarySize; +} VkDeviceFaultCountsEXT; + +typedef struct VkDeviceFaultAddressInfoEXT { + VkDeviceFaultAddressTypeEXT addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoEXT; + +typedef struct VkDeviceFaultVendorInfoEXT { + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoEXT; + +typedef struct VkDeviceFaultInfoEXT { + VkStructureType sType; + void* pNext; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoEXT* pAddressInfos; + VkDeviceFaultVendorInfoEXT* pVendorInfos; + void* pVendorBinaryData; +} VkDeviceFaultInfoEXT; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); +#endif + + #define VK_ARM_rasterization_order_attachment_access 1 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access" -typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { +typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { VkStructureType sType; void* pNext; VkBool32 rasterizationOrderColorAttachmentAccess; VkBool32 rasterizationOrderDepthAttachmentAccess; VkBool32 rasterizationOrderStencilAttachmentAccess; -} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; +} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; @@ -13489,44 +14814,32 @@ typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { -#define VK_NV_acquire_winrt_display 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay); -#endif - - #define VK_VALVE_mutable_descriptor_type 1 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" -typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE { +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { VkStructureType sType; void* pNext; VkBool32 mutableDescriptorType; -} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; -typedef struct VkMutableDescriptorTypeListVALVE { +typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +typedef struct VkMutableDescriptorTypeListEXT { uint32_t descriptorTypeCount; const VkDescriptorType* pDescriptorTypes; -} VkMutableDescriptorTypeListVALVE; +} VkMutableDescriptorTypeListEXT; -typedef struct VkMutableDescriptorTypeCreateInfoVALVE { - VkStructureType sType; - const void* pNext; - uint32_t mutableDescriptorTypeListCount; - const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists; -} VkMutableDescriptorTypeCreateInfoVALVE; +typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; + +typedef struct VkMutableDescriptorTypeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mutableDescriptorTypeListCount; + const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoEXT; + +typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; @@ -13585,6 +14898,38 @@ typedef struct VkPhysicalDeviceDrmPropertiesEXT { +#define VK_EXT_device_address_binding_report 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report" + +typedef enum VkDeviceAddressBindingTypeEXT { + VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, + VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, + VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingTypeEXT; + +typedef enum VkDeviceAddressBindingFlagBitsEXT { + VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, + VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingFlagBitsEXT; +typedef VkFlags VkDeviceAddressBindingFlagsEXT; +typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 reportAddressBinding; +} VkPhysicalDeviceAddressBindingReportFeaturesEXT; + +typedef struct VkDeviceAddressBindingCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress baseAddress; + VkDeviceSize size; + VkDeviceAddressBindingTypeEXT bindingType; +} VkDeviceAddressBindingCallbackDataEXT; + + + #define VK_EXT_depth_clip_control 1 #define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1 #define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control" @@ -13696,6 +15041,57 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( #endif +#define VK_EXT_pipeline_properties 1 +#define VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME "VK_EXT_pipeline_properties" +typedef VkPipelineInfoKHR VkPipelineInfoEXT; + +typedef struct VkPipelinePropertiesIdentifierEXT { + VkStructureType sType; + void* pNext; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; +} VkPipelinePropertiesIdentifierEXT; + +typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelinePropertiesIdentifier; +} VkPhysicalDevicePipelinePropertiesFeaturesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); +#endif + + +#define VK_EXT_multisampled_render_to_single_sampled 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled" +typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multisampledRenderToSingleSampled; +} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + +typedef struct VkSubpassResolvePerformanceQueryEXT { + VkStructureType sType; + void* pNext; + VkBool32 optimal; +} VkSubpassResolvePerformanceQueryEXT; + +typedef struct VkMultisampledRenderToSingleSampledInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; +} VkMultisampledRenderToSingleSampledInfoEXT; + + + #define VK_EXT_extended_dynamic_state2 1 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" @@ -13863,11 +15259,339 @@ typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { +#define VK_EXT_shader_tile_image 1 +#define VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION 1 +#define VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME "VK_EXT_shader_tile_image" +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT; + + + +#define VK_EXT_opacity_micromap 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) +#define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2 +#define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap" + +typedef enum VkMicromapTypeEXT { + VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV = 1000397000, +#endif + VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapTypeEXT; + +typedef enum VkBuildMicromapModeEXT { + VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, + VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapModeEXT; + +typedef enum VkCopyMicromapModeEXT { + VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, + VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, + VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, + VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, + VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkCopyMicromapModeEXT; + +typedef enum VkOpacityMicromapFormatEXT { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapFormatEXT; + +typedef enum VkOpacityMicromapSpecialIndexEXT { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexEXT; + +typedef enum VkAccelerationStructureCompatibilityKHR { + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCompatibilityKHR; + +typedef enum VkAccelerationStructureBuildTypeKHR { + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureBuildTypeKHR; + +typedef enum VkBuildMicromapFlagBitsEXT { + VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, + VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, + VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, + VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapFlagBitsEXT; +typedef VkFlags VkBuildMicromapFlagsEXT; + +typedef enum VkMicromapCreateFlagBitsEXT { + VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, + VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapCreateFlagBitsEXT; +typedef VkFlags VkMicromapCreateFlagsEXT; +typedef struct VkMicromapUsageEXT { + uint32_t count; + uint32_t subdivisionLevel; + uint32_t format; +} VkMicromapUsageEXT; + +typedef union VkDeviceOrHostAddressKHR { + VkDeviceAddress deviceAddress; + void* hostAddress; +} VkDeviceOrHostAddressKHR; + +typedef struct VkMicromapBuildInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT dstMicromap; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkDeviceOrHostAddressConstKHR data; + VkDeviceOrHostAddressKHR scratchData; + VkDeviceOrHostAddressConstKHR triangleArray; + VkDeviceSize triangleArrayStride; +} VkMicromapBuildInfoEXT; + +typedef struct VkMicromapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkMicromapTypeEXT type; + VkDeviceAddress deviceAddress; +} VkMicromapCreateInfoEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; +} VkPhysicalDeviceOpacityMicromapFeaturesEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; +} VkPhysicalDeviceOpacityMicromapPropertiesEXT; + +typedef struct VkMicromapVersionInfoEXT { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkMicromapVersionInfoEXT; + +typedef struct VkCopyMicromapToMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkDeviceOrHostAddressKHR dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapToMemoryInfoEXT; + +typedef struct VkCopyMemoryToMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMemoryToMicromapInfoEXT; + +typedef struct VkCopyMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapInfoEXT; + +typedef struct VkMicromapBuildSizesInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceSize micromapSize; + VkDeviceSize buildScratchSize; + VkBool32 discardable; +} VkMicromapBuildSizesInfoEXT; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT; + +typedef struct VkMicromapTriangleEXT { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); + +VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); +#endif + + #define VK_EXT_load_store_op_none 1 #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" +#define VK_HUAWEI_cluster_culling_shader 1 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 2 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME "VK_HUAWEI_cluster_culling_shader" +typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; +} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize indirectBufferOffsetAlignment; +} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); +#endif + + #define VK_EXT_border_color_swizzle 1 #define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 #define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" @@ -13906,6 +15630,38 @@ VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( #endif +#define VK_ARM_shader_core_properties 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties" +typedef struct VkPhysicalDeviceShaderCorePropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; +} VkPhysicalDeviceShaderCorePropertiesARM; + + + +#define VK_EXT_image_sliced_view_of_3d 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d" +#define VK_REMAINING_3D_SLICES_EXT (~0U) +typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageSlicedViewOf3D; +} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + +typedef struct VkImageViewSlicedCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t sliceOffset; + uint32_t sliceCount; +} VkImageViewSlicedCreateInfoEXT; + + + #define VK_VALVE_descriptor_set_host_mapping 1 #define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1 #define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping" @@ -13945,6 +15701,28 @@ VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE( #endif +#define VK_EXT_depth_clamp_zero_one 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one" +typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClampZeroOne; +} VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; + + + +#define VK_EXT_non_seamless_cube_map 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" +typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nonSeamlessCubeMap; +} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + + #define VK_QCOM_fragment_density_map_offset 1 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" @@ -13969,6 +15747,104 @@ typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM { +#define VK_NV_copy_memory_indirect 1 +#define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 +#define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect" +typedef struct VkCopyMemoryIndirectCommandNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize size; +} VkCopyMemoryIndirectCommandNV; + +typedef struct VkCopyMemoryToImageIndirectCommandNV { + VkDeviceAddress srcAddress; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkCopyMemoryToImageIndirectCommandNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 indirectCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); +#endif + + +#define VK_NV_memory_decompression 1 +#define VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION 1 +#define VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_NV_memory_decompression" + +// Flag bits for VkMemoryDecompressionMethodFlagBitsNV +typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsNV; +static const VkMemoryDecompressionMethodFlagBitsNV VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; + +typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; +typedef struct VkDecompressMemoryRegionNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; + VkMemoryDecompressionMethodFlagsNV decompressionMethod; +} VkDecompressMemoryRegionNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 memoryDecompression; +} VkPhysicalDeviceMemoryDecompressionFeaturesNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV { + VkStructureType sType; + void* pNext; + VkMemoryDecompressionMethodFlagsNV decompressionMethods; + uint64_t maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride); +#endif + + #define VK_NV_linear_color_attachment 1 #define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 #define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" @@ -13981,12 +15857,852 @@ typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { #define VK_GOOGLE_surfaceless_query 1 -#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 1 +#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 2 #define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query" +#define VK_EXT_image_compression_control_swapchain 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain" +typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControlSwapchain; +} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + + +#define VK_QCOM_image_processing 1 +#define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing" +typedef struct VkImageViewSampleWeightCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; +} VkImageViewSampleWeightCreateInfoQCOM; + +typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; +} VkPhysicalDeviceImageProcessingFeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; +} VkPhysicalDeviceImageProcessingPropertiesQCOM; + + + +#define VK_EXT_extended_dynamic_state3 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" +typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; +} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; + +typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicPrimitiveTopologyUnrestricted; +} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; + +typedef struct VkColorBlendEquationEXT { + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; +} VkColorBlendEquationEXT; + +typedef struct VkColorBlendAdvancedEXT { + VkBlendOp advancedBlendOp; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; + VkBool32 clampResults; +} VkColorBlendAdvancedEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); +#endif + + +#define VK_EXT_subpass_merge_feedback 1 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback" + +typedef enum VkSubpassMergeStatusEXT { + VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, + VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, + VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSubpassMergeStatusEXT; +typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subpassMergeFeedback; +} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + +typedef struct VkRenderPassCreationControlEXT { + VkStructureType sType; + const void* pNext; + VkBool32 disallowMerging; +} VkRenderPassCreationControlEXT; + +typedef struct VkRenderPassCreationFeedbackInfoEXT { + uint32_t postMergeSubpassCount; +} VkRenderPassCreationFeedbackInfoEXT; + +typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; +} VkRenderPassCreationFeedbackCreateInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackInfoEXT { + VkSubpassMergeStatusEXT subpassMergeStatus; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t postMergeIndex; +} VkRenderPassSubpassFeedbackInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; +} VkRenderPassSubpassFeedbackCreateInfoEXT; + + + +#define VK_LUNARG_direct_driver_loading 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME "VK_LUNARG_direct_driver_loading" + +typedef enum VkDirectDriverLoadingModeLUNARG { + VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, + VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF +} VkDirectDriverLoadingModeLUNARG; +typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddrLUNARG)( + VkInstance instance, const char* pName); + +typedef struct VkDirectDriverLoadingInfoLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingFlagsLUNARG flags; + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; +} VkDirectDriverLoadingInfoLUNARG; + +typedef struct VkDirectDriverLoadingListLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingModeLUNARG mode; + uint32_t driverCount; + const VkDirectDriverLoadingInfoLUNARG* pDrivers; +} VkDirectDriverLoadingListLUNARG; + + + +#define VK_EXT_shader_module_identifier 1 +#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32U +#define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1 +#define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier" +typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderModuleIdentifier; +} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; +} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; + +typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; + +typedef struct VkShaderModuleIdentifierEXT { + VkStructureType sType; + void* pNext; + uint32_t identifierSize; + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; +} VkShaderModuleIdentifierEXT; + +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); + +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); +#endif + + +#define VK_EXT_rasterization_order_attachment_access 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access" + + +#define VK_NV_optical_flow 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) +#define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1 +#define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow" + +typedef enum VkOpticalFlowPerformanceLevelNV { + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowPerformanceLevelNV; + +typedef enum VkOpticalFlowSessionBindingPointNV { + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionBindingPointNV; + +typedef enum VkOpticalFlowGridSizeFlagBitsNV { + VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowGridSizeFlagBitsNV; +typedef VkFlags VkOpticalFlowGridSizeFlagsNV; + +typedef enum VkOpticalFlowUsageFlagBitsNV { + VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowUsageFlagBitsNV; +typedef VkFlags VkOpticalFlowUsageFlagsNV; + +typedef enum VkOpticalFlowSessionCreateFlagBitsNV { + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionCreateFlagBitsNV; +typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; + +typedef enum VkOpticalFlowExecuteFlagBitsNV { + VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowExecuteFlagBitsNV; +typedef VkFlags VkOpticalFlowExecuteFlagsNV; +typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 opticalFlow; +} VkPhysicalDeviceOpticalFlowFeaturesNV; + +typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; +} VkPhysicalDeviceOpticalFlowPropertiesNV; + +typedef struct VkOpticalFlowImageFormatInfoNV { + VkStructureType sType; + const void* pNext; + VkOpticalFlowUsageFlagsNV usage; +} VkOpticalFlowImageFormatInfoNV; + +typedef struct VkOpticalFlowImageFormatPropertiesNV { + VkStructureType sType; + const void* pNext; + VkFormat format; +} VkOpticalFlowImageFormatPropertiesNV; + +typedef struct VkOpticalFlowSessionCreateInfoNV { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; +} VkOpticalFlowSessionCreateInfoNV; + +typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { + VkStructureType sType; + void* pNext; + uint32_t id; + uint32_t size; + const void* pPrivateData; +} VkOpticalFlowSessionCreatePrivateDataInfoNV; + +typedef struct VkOpticalFlowExecuteInfoNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + const VkRect2D* pRegions; +} VkOpticalFlowExecuteInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); + +VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); + +VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +#endif + + +#define VK_EXT_legacy_dithering 1 +#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1 +#define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering" +typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 legacyDithering; +} VkPhysicalDeviceLegacyDitheringFeaturesEXT; + + + +#define VK_EXT_pipeline_protected_access 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access" +typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineProtectedAccess; +} VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; + + + +#define VK_EXT_shader_object 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) +#define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 +#define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" + +typedef enum VkShaderCodeTypeEXT { + VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCodeTypeEXT; + +typedef enum VkShaderCreateFlagBitsEXT { + VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, + VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, + VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, + VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, + VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, + VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, + VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCreateFlagBitsEXT; +typedef VkFlags VkShaderCreateFlagsEXT; +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT; + +typedef struct VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode; + const char* pName; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; + const VkSpecializationInfo* pSpecializationInfo; +} VkShaderCreateInfoEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); +#endif + + +#define VK_QCOM_tile_properties 1 +#define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 +#define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" +typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileProperties; +} VkPhysicalDeviceTilePropertiesFeaturesQCOM; + +typedef struct VkTilePropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; +} VkTilePropertiesQCOM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); +#endif + + +#define VK_SEC_amigo_profiling 1 +#define VK_SEC_AMIGO_PROFILING_SPEC_VERSION 1 +#define VK_SEC_AMIGO_PROFILING_EXTENSION_NAME "VK_SEC_amigo_profiling" +typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 amigoProfiling; +} VkPhysicalDeviceAmigoProfilingFeaturesSEC; + +typedef struct VkAmigoProfilingSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + uint64_t firstDrawTimestamp; + uint64_t swapBufferTimestamp; +} VkAmigoProfilingSubmitInfoSEC; + + + +#define VK_QCOM_multiview_per_view_viewports 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports" +typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewViewports; +} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + + +#define VK_NV_ray_tracing_invocation_reorder 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_NV_ray_tracing_invocation_reorder" + +typedef enum VkRayTracingInvocationReorderModeNV { + VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingInvocationReorderModeNV; +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { + VkStructureType sType; + void* pNext; + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + + +#define VK_EXT_mutable_descriptor_type 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" + + +#define VK_ARM_shader_core_builtins 1 +#define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2 +#define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins" +typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 shaderCoreBuiltins; +} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; + +typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkStructureType sType; + void* pNext; + uint64_t shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; +} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + + +#define VK_EXT_pipeline_library_group_handles 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" +typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineLibraryGroupHandles; +} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + + +#define VK_QCOM_multiview_per_view_render_areas 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" +typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewRenderAreas; +} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + +typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t perViewRenderAreaCount; + const VkRect2D* pPerViewRenderAreas; +} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + + + +#define VK_EXT_attachment_feedback_loop_dynamic_state 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_dynamic_state" +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopDynamicState; +} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask); +#endif + + #define VK_KHR_acceleration_structure 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 #define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" @@ -13996,30 +16712,13 @@ typedef enum VkBuildAccelerationStructureModeKHR { VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF } VkBuildAccelerationStructureModeKHR; -typedef enum VkAccelerationStructureBuildTypeKHR { - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureBuildTypeKHR; - -typedef enum VkAccelerationStructureCompatibilityKHR { - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCompatibilityKHR; - typedef enum VkAccelerationStructureCreateFlagBitsKHR { VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkAccelerationStructureCreateFlagBitsKHR; typedef VkFlags VkAccelerationStructureCreateFlagsKHR; -typedef union VkDeviceOrHostAddressKHR { - VkDeviceAddress deviceAddress; - void* hostAddress; -} VkDeviceOrHostAddressKHR; - typedef struct VkAccelerationStructureBuildRangeInfoKHR { uint32_t primitiveCount; uint32_t primitiveOffset; @@ -14424,6 +17123,87 @@ typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { } VkPhysicalDeviceRayQueryFeaturesKHR; + +#define VK_EXT_mesh_shader 1 +#define VK_EXT_MESH_SHADER_SPEC_VERSION 1 +#define VK_EXT_MESH_SHADER_EXTENSION_NAME "VK_EXT_mesh_shader" +typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; +} VkPhysicalDeviceMeshShaderFeaturesEXT; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; +} VkPhysicalDeviceMeshShaderPropertiesEXT; + +typedef struct VkDrawMeshTasksIndirectCommandEXT { + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +} VkDrawMeshTasksIndirectCommandEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + #ifdef __cplusplus } #endif diff --git a/vendor/vulkan/_gen/vulkan_ios.h b/vendor/vulkan/_gen/vulkan_ios.h index 579220543..8c6d9e72a 100644 --- a/vendor/vulkan/_gen/vulkan_ios.h +++ b/vendor/vulkan/_gen/vulkan_ios.h @@ -2,7 +2,7 @@ #define VULKAN_IOS_H_ 1 /* -** Copyright 2015-2022 The Khronos Group Inc. +** Copyright 2015-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/vendor/vulkan/_gen/vulkan_macos.h b/vendor/vulkan/_gen/vulkan_macos.h index 8e197c7cf..3310e11ab 100644 --- a/vendor/vulkan/_gen/vulkan_macos.h +++ b/vendor/vulkan/_gen/vulkan_macos.h @@ -2,7 +2,7 @@ #define VULKAN_MACOS_H_ 1 /* -** Copyright 2015-2022 The Khronos Group Inc. +** Copyright 2015-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/vendor/vulkan/_gen/vulkan_metal.h b/vendor/vulkan/_gen/vulkan_metal.h index 3631f1200..7127651c1 100644 --- a/vendor/vulkan/_gen/vulkan_metal.h +++ b/vendor/vulkan/_gen/vulkan_metal.h @@ -2,7 +2,7 @@ #define VULKAN_METAL_H_ 1 /* -** Copyright 2015-2022 The Khronos Group Inc. +** Copyright 2015-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -20,7 +20,6 @@ extern "C" { #define VK_EXT_metal_surface 1 - #ifdef __OBJC__ @class CAMetalLayer; #else @@ -47,6 +46,146 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( VkSurfaceKHR* pSurface); #endif + +#define VK_EXT_metal_objects 1 +#ifdef __OBJC__ +@protocol MTLDevice; +typedef id MTLDevice_id; +#else +typedef void* MTLDevice_id; +#endif + +#ifdef __OBJC__ +@protocol MTLCommandQueue; +typedef id MTLCommandQueue_id; +#else +typedef void* MTLCommandQueue_id; +#endif + +#ifdef __OBJC__ +@protocol MTLBuffer; +typedef id MTLBuffer_id; +#else +typedef void* MTLBuffer_id; +#endif + +#ifdef __OBJC__ +@protocol MTLTexture; +typedef id MTLTexture_id; +#else +typedef void* MTLTexture_id; +#endif + +typedef struct __IOSurface* IOSurfaceRef; +#ifdef __OBJC__ +@protocol MTLSharedEvent; +typedef id MTLSharedEvent_id; +#else +typedef void* MTLSharedEvent_id; +#endif + +#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1 +#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects" + +typedef enum VkExportMetalObjectTypeFlagBitsEXT { + VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020, + VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkExportMetalObjectTypeFlagBitsEXT; +typedef VkFlags VkExportMetalObjectTypeFlagsEXT; +typedef struct VkExportMetalObjectCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkExportMetalObjectTypeFlagBitsEXT exportObjectType; +} VkExportMetalObjectCreateInfoEXT; + +typedef struct VkExportMetalObjectsInfoEXT { + VkStructureType sType; + const void* pNext; +} VkExportMetalObjectsInfoEXT; + +typedef struct VkExportMetalDeviceInfoEXT { + VkStructureType sType; + const void* pNext; + MTLDevice_id mtlDevice; +} VkExportMetalDeviceInfoEXT; + +typedef struct VkExportMetalCommandQueueInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueue queue; + MTLCommandQueue_id mtlCommandQueue; +} VkExportMetalCommandQueueInfoEXT; + +typedef struct VkExportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + MTLBuffer_id mtlBuffer; +} VkExportMetalBufferInfoEXT; + +typedef struct VkImportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + MTLBuffer_id mtlBuffer; +} VkImportMetalBufferInfoEXT; + +typedef struct VkExportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageView imageView; + VkBufferView bufferView; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkExportMetalTextureInfoEXT; + +typedef struct VkImportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkImportMetalTextureInfoEXT; + +typedef struct VkExportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + IOSurfaceRef ioSurface; +} VkExportMetalIOSurfaceInfoEXT; + +typedef struct VkImportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + IOSurfaceRef ioSurface; +} VkImportMetalIOSurfaceInfoEXT; + +typedef struct VkExportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkEvent event; + MTLSharedEvent_id mtlSharedEvent; +} VkExportMetalSharedEventInfoEXT; + +typedef struct VkImportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + MTLSharedEvent_id mtlSharedEvent; +} VkImportMetalSharedEventInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +#endif + #ifdef __cplusplus } #endif diff --git a/vendor/vulkan/_gen/vulkan_video_codec_h264std.h b/vendor/vulkan/_gen/vulkan_video_codec_h264std.h new file mode 100644 index 000000000..21c7b667f --- /dev/null +++ b/vendor/vulkan/_gen/vulkan_video_codec_h264std.h @@ -0,0 +1,310 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h264std 1 +#include +#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6 +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64 +#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32 +#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2 + +typedef enum StdVideoH264ChromaFormatIdc { + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, + STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264LevelIdc { + STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, + STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, + STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, + STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, + STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, + STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, + STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, + STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, + STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, + STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, + STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, + STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, + STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, + STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, + STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, + STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, + STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, + STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, + STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264LevelIdc; + +typedef enum StdVideoH264PocType { + STD_VIDEO_H264_POC_TYPE_0 = 0, + STD_VIDEO_H264_POC_TYPE_1 = 1, + STD_VIDEO_H264_POC_TYPE_2 = 2, + STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBipredIdc { + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264WeightedBipredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, + STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, + STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, + STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264SliceType { + STD_VIDEO_H264_SLICE_TYPE_P = 0, + STD_VIDEO_H264_SLICE_TYPE_B = 1, + STD_VIDEO_H264_SLICE_TYPE_I = 2, + STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264PictureType { + STD_VIDEO_H264_PICTURE_TYPE_P = 0, + STD_VIDEO_H264_PICTURE_TYPE_B = 1, + STD_VIDEO_H264_PICTURE_TYPE_I = 2, + STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, + STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264NonVclNaluType { + STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; +typedef struct StdVideoH264SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t reserved1; + uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint32_t reserved1; + const StdVideoH264HrdParameters* pHrdParameters; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists { + uint16_t scaling_list_present_mask; + uint16_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet { + StdVideoH264SpsFlags flags; + StdVideoH264ProfileIdc profile_idc; + StdVideoH264LevelIdc level_idc; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint8_t reserved1; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + uint32_t reserved2; + const int32_t* pOffsetForRefFrame; + const StdVideoH264ScalingLists* pScalingLists; + const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t bottom_field_pic_order_in_frame_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet { + StdVideoH264PpsFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + const StdVideoH264ScalingLists* pScalingLists; +} StdVideoH264PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/vulkan/_gen/vulkan_video_codec_h264std_decode.h b/vendor/vulkan/_gen/vulkan_video_codec_h264std_decode.h new file mode 100644 index 000000000..f7eb8edbd --- /dev/null +++ b/vendor/vulkan/_gen/vulkan_video_codec_h264std_decode.h @@ -0,0 +1,75 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h264std_decode 1 + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" + +typedef enum StdVideoDecodeH264FieldOrderCount { + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF +} StdVideoDecodeH264FieldOrderCount; +typedef struct StdVideoDecodeH264PictureInfoFlags { + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + StdVideoDecodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t reserved1; + uint8_t reserved2; + uint16_t frame_num; + uint16_t idr_pic_id; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t is_non_existing : 1; +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + StdVideoDecodeH264ReferenceInfoFlags flags; + uint16_t FrameNum; + uint16_t reserved; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/vulkan/_gen/vulkan_video_codec_h265std.h b/vendor/vulkan/_gen/vulkan_video_codec_h265std.h new file mode 100644 index 000000000..4233bdc89 --- /dev/null +++ b/vendor/vulkan/_gen/vulkan_video_codec_h265std.h @@ -0,0 +1,443 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h265std 1 +#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7 +#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16 +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2 +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 +#define STD_VIDEO_H265_MAX_DPB_SIZE 16 +#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 +#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15 +#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2 +#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64 +#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16 +#define STD_VIDEO_H265_MAX_DELTA_POC 48 + +typedef enum StdVideoH265ChromaFormatIdc { + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265LevelIdc { + STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, + STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, + STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, + STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, + STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, + STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, + STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, + STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, + STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, + STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, + STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, + STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, + STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265LevelIdc; + +typedef enum StdVideoH265SliceType { + STD_VIDEO_H265_SLICE_TYPE_B = 0, + STD_VIDEO_H265_SLICE_TYPE_P = 1, + STD_VIDEO_H265_SLICE_TYPE_I = 2, + STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265SliceType; + +typedef enum StdVideoH265PictureType { + STD_VIDEO_H265_PICTURE_TYPE_P = 0, + STD_VIDEO_H265_PICTURE_TYPE_B = 1, + STD_VIDEO_H265_PICTURE_TYPE_I = 2, + STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, + STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265PictureType; + +typedef enum StdVideoH265AspectRatioIdc { + STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265AspectRatioIdc; +typedef struct StdVideoH265DecPicBufMgr { + uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cbr_flag; +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + StdVideoH265HrdFlags flags; + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t reserved[3]; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265ProfileTierLevelFlags { + uint32_t general_tier_flag : 1; + uint32_t general_progressive_source_flag : 1; + uint32_t general_interlaced_source_flag : 1; + uint32_t general_non_packed_constraint_flag : 1; + uint32_t general_frame_only_constraint_flag : 1; +} StdVideoH265ProfileTierLevelFlags; + +typedef struct StdVideoH265ProfileTierLevel { + StdVideoH265ProfileTierLevelFlags flags; + StdVideoH265ProfileIdc general_profile_idc; + StdVideoH265LevelIdc general_level_idc; +} StdVideoH265ProfileTierLevel; + +typedef struct StdVideoH265VideoParameterSet { + StdVideoH265VpsFlags flags; + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + uint32_t reserved3; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265HrdParameters* pHrdParameters; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists { + uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; + uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; + uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; + uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; + uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + StdVideoH265SpsVuiFlags flags; + StdVideoH265AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint8_t reserved1; + uint8_t reserved2; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + uint16_t min_spatial_segmentation_idc; + uint16_t reserved3; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + const StdVideoH265HrdParameters* pHrdParameters; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries { + uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; +} StdVideoH265PredictorPaletteEntries; + +typedef struct StdVideoH265SpsFlags { + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t conformance_window_flag : 1; + uint32_t sps_sub_layer_ordering_info_present_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_scc_extension_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializers_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265ShortTermRefPicSetFlags { + uint32_t inter_ref_pic_set_prediction_flag : 1; + uint32_t delta_rps_sign : 1; +} StdVideoH265ShortTermRefPicSetFlags; + +typedef struct StdVideoH265ShortTermRefPicSet { + StdVideoH265ShortTermRefPicSetFlags flags; + uint32_t delta_idx_minus1; + uint16_t use_delta_flag; + uint16_t abs_delta_rps_minus1; + uint16_t used_by_curr_pic_flag; + uint16_t used_by_curr_pic_s0_flag; + uint16_t used_by_curr_pic_s1_flag; + uint16_t reserved1; + uint8_t reserved2; + uint8_t reserved3; + uint8_t num_negative_pics; + uint8_t num_positive_pics; + uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; + uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; +} StdVideoH265ShortTermRefPicSet; + +typedef struct StdVideoH265LongTermRefPicsSps { + uint32_t used_by_curr_pic_lt_sps_flag; + uint32_t lt_ref_pic_poc_lsb_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; +} StdVideoH265LongTermRefPicsSps; + +typedef struct StdVideoH265SequenceParameterSet { + StdVideoH265SpsFlags flags; + StdVideoH265ChromaFormatIdc chroma_format_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint8_t reserved1; + uint8_t reserved2; + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializers_minus1; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; + const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265SequenceParameterSet; + +typedef struct StdVideoH265PpsFlags { + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializers_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet { + StdVideoH265PpsFlags flags; + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t sps_video_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus3; + uint8_t pps_num_palette_predictor_initializers; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; + uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; + uint32_t reserved3; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/vulkan/_gen/vulkan_video_codec_h265std_decode.h b/vendor/vulkan/_gen/vulkan_video_codec_h265std_decode.h new file mode 100644 index 000000000..7eee9b389 --- /dev/null +++ b/vendor/vulkan/_gen/vulkan_video_codec_h265std_decode.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h265std_decode 1 + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" +typedef struct StdVideoDecodeH265PictureInfoFlags { + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + StdVideoDecodeH265PictureInfoFlags flags; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t NumDeltaPocsOfRefRpsIdx; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; + uint16_t reserved; + uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + StdVideoDecodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; +} StdVideoDecodeH265ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/vulkan/_gen/vulkan_win32.h b/vendor/vulkan/_gen/vulkan_win32.h index affe0c02a..5b65a36a6 100644 --- a/vendor/vulkan/_gen/vulkan_win32.h +++ b/vendor/vulkan/_gen/vulkan_win32.h @@ -2,7 +2,7 @@ #define VULKAN_WIN32_H_ 1 /* -** Copyright 2015-2022 The Khronos Group Inc. +** Copyright 2015-2023 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -308,6 +308,24 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( VkDeviceGroupPresentModeFlagsKHR* pModes); #endif + +#define VK_NV_acquire_winrt_display 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif + #ifdef __cplusplus } #endif diff --git a/vendor/vulkan/core.odin b/vendor/vulkan/core.odin index 414d546a1..7ad114266 100644 --- a/vendor/vulkan/core.odin +++ b/vendor/vulkan/core.odin @@ -27,768 +27,931 @@ SetProcAddressType :: #type proc(p: rawptr, name: cstring) RemoteAddressNV :: distinct rawptr // Declared inline before MemoryGetRemoteAddressInfoNV // Base constants -LOD_CLAMP_NONE :: 1000.0 -REMAINING_MIP_LEVELS :: ~u32(0) -REMAINING_ARRAY_LAYERS :: ~u32(0) -WHOLE_SIZE :: ~u64(0) -ATTACHMENT_UNUSED :: ~u32(0) -TRUE :: 1 -FALSE :: 0 -QUEUE_FAMILY_IGNORED :: ~u32(0) -SUBPASS_EXTERNAL :: ~u32(0) -MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256 -UUID_SIZE :: 16 -MAX_MEMORY_TYPES :: 32 -MAX_MEMORY_HEAPS :: 16 -MAX_EXTENSION_NAME_SIZE :: 256 -MAX_DESCRIPTION_SIZE :: 256 -MAX_DEVICE_GROUP_SIZE :: 32 -LUID_SIZE_KHX :: 8 -LUID_SIZE :: 8 -MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(1) -MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16 -QUEUE_FAMILY_EXTERNAL :: MAX_QUEUE_FAMILY_EXTERNAL +LOD_CLAMP_NONE :: 1000.0 +REMAINING_MIP_LEVELS :: ~u32(0) +REMAINING_ARRAY_LAYERS :: ~u32(0) +WHOLE_SIZE :: ~u64(0) +ATTACHMENT_UNUSED :: ~u32(0) +TRUE :: 1 +FALSE :: 0 +QUEUE_FAMILY_IGNORED :: ~u32(0) +SUBPASS_EXTERNAL :: ~u32(0) +MAX_PHYSICAL_DEVICE_NAME_SIZE :: 256 +MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT :: 32 +UUID_SIZE :: 16 +MAX_MEMORY_TYPES :: 32 +MAX_MEMORY_HEAPS :: 16 +MAX_EXTENSION_NAME_SIZE :: 256 +MAX_DESCRIPTION_SIZE :: 256 +MAX_DEVICE_GROUP_SIZE :: 32 +LUID_SIZE_KHX :: 8 +LUID_SIZE :: 8 +MAX_QUEUE_FAMILY_EXTERNAL :: ~u32(1) +MAX_GLOBAL_PRIORITY_SIZE_EXT :: 16 +QUEUE_FAMILY_EXTERNAL :: MAX_QUEUE_FAMILY_EXTERNAL // General Constants -HEADER_VERSION :: 211 +HEADER_VERSION :: 250 MAX_DRIVER_NAME_SIZE :: 256 MAX_DRIVER_INFO_SIZE :: 256 +// Vulkan Video Constants +VIDEO_H264_CPB_CNT_LIST_SIZE :: 32 +VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS :: 6 +VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS :: 16 +VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS :: 6 +VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS :: 64 +VIDEO_H264_MAX_NUM_LIST_REF :: 32 +VIDEO_H264_MAX_CHROMA_PLANES :: 2 +VIDEO_H265_SUBLAYERS_LIST_SIZE :: 7 +VIDEO_H265_CPB_CNT_LIST_SIZE :: 32 +VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS :: 6 +VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS :: 16 +VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS :: 6 +VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS :: 64 +VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS :: 6 +VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS :: 64 +VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS :: 2 +VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS :: 64 +VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE :: 3 +VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE :: 128 +VIDEO_H265_MAX_DPB_SIZE :: 16 +VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS :: 32 +VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE :: 6 +VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE :: 19 +VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE :: 21 +VIDEO_H265_MAX_NUM_LIST_REF :: 15 +VIDEO_H265_MAX_CHROMA_PLANES :: 2 +VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS :: 64 +VIDEO_H265_MAX_LONG_TERM_PICS :: 16 +VIDEO_H265_MAX_DELTA_POC :: 48 +VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE :: 2 +VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE :: 8 + // Vendor Constants -KHR_surface :: 1 -KHR_SURFACE_SPEC_VERSION :: 25 -KHR_SURFACE_EXTENSION_NAME :: "VK_KHR_surface" -KHR_swapchain :: 1 -KHR_SWAPCHAIN_SPEC_VERSION :: 70 -KHR_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_swapchain" -KHR_display :: 1 -KHR_DISPLAY_SPEC_VERSION :: 23 -KHR_DISPLAY_EXTENSION_NAME :: "VK_KHR_display" -KHR_display_swapchain :: 1 -KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION :: 10 -KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_display_swapchain" -KHR_sampler_mirror_clamp_to_edge :: 1 -KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION :: 3 -KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: "VK_KHR_sampler_mirror_clamp_to_edge" -KHR_dynamic_rendering :: 1 -KHR_DYNAMIC_RENDERING_SPEC_VERSION :: 1 -KHR_DYNAMIC_RENDERING_EXTENSION_NAME :: "VK_KHR_dynamic_rendering" -KHR_multiview :: 1 -KHR_MULTIVIEW_SPEC_VERSION :: 1 -KHR_MULTIVIEW_EXTENSION_NAME :: "VK_KHR_multiview" -KHR_get_physical_device_properties2 :: 1 -KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION :: 2 -KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_physical_device_properties2" -KHR_device_group :: 1 -KHR_DEVICE_GROUP_SPEC_VERSION :: 4 -KHR_DEVICE_GROUP_EXTENSION_NAME :: "VK_KHR_device_group" -KHR_shader_draw_parameters :: 1 -KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION :: 1 -KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: "VK_KHR_shader_draw_parameters" -KHR_maintenance1 :: 1 -KHR_MAINTENANCE_1_SPEC_VERSION :: 2 -KHR_MAINTENANCE_1_EXTENSION_NAME :: "VK_KHR_maintenance1" -KHR_MAINTENANCE1_SPEC_VERSION :: KHR_MAINTENANCE_1_SPEC_VERSION -KHR_MAINTENANCE1_EXTENSION_NAME :: KHR_MAINTENANCE_1_EXTENSION_NAME -KHR_device_group_creation :: 1 -KHR_DEVICE_GROUP_CREATION_SPEC_VERSION :: 1 -KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME :: "VK_KHR_device_group_creation" -MAX_DEVICE_GROUP_SIZE_KHR :: MAX_DEVICE_GROUP_SIZE -KHR_external_memory_capabilities :: 1 -KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1 -KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_memory_capabilities" -LUID_SIZE_KHR :: LUID_SIZE -KHR_external_memory :: 1 -KHR_EXTERNAL_MEMORY_SPEC_VERSION :: 1 -KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_KHR_external_memory" -QUEUE_FAMILY_EXTERNAL_KHR :: QUEUE_FAMILY_EXTERNAL -KHR_external_memory_fd :: 1 -KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION :: 1 -KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: "VK_KHR_external_memory_fd" -KHR_external_semaphore_capabilities :: 1 -KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION :: 1 -KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_semaphore_capabilities" -KHR_external_semaphore :: 1 -KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION :: 1 -KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_external_semaphore" -KHR_external_semaphore_fd :: 1 -KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION :: 1 -KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: "VK_KHR_external_semaphore_fd" -KHR_push_descriptor :: 1 -KHR_PUSH_DESCRIPTOR_SPEC_VERSION :: 2 -KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: "VK_KHR_push_descriptor" -KHR_shader_float16_int8 :: 1 -KHR_SHADER_FLOAT16_INT8_SPEC_VERSION :: 1 -KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME :: "VK_KHR_shader_float16_int8" -KHR_16bit_storage :: 1 -KHR_16BIT_STORAGE_SPEC_VERSION :: 1 -KHR_16BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_16bit_storage" -KHR_incremental_present :: 1 -KHR_INCREMENTAL_PRESENT_SPEC_VERSION :: 2 -KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: "VK_KHR_incremental_present" -KHR_descriptor_update_template :: 1 -KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION :: 1 -KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: "VK_KHR_descriptor_update_template" -KHR_imageless_framebuffer :: 1 -KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION :: 1 -KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME :: "VK_KHR_imageless_framebuffer" -KHR_create_renderpass2 :: 1 -KHR_CREATE_RENDERPASS_2_SPEC_VERSION :: 1 -KHR_CREATE_RENDERPASS_2_EXTENSION_NAME :: "VK_KHR_create_renderpass2" -KHR_shared_presentable_image :: 1 -KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION :: 1 -KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: "VK_KHR_shared_presentable_image" -KHR_external_fence_capabilities :: 1 -KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION :: 1 -KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_fence_capabilities" -KHR_external_fence :: 1 -KHR_EXTERNAL_FENCE_SPEC_VERSION :: 1 -KHR_EXTERNAL_FENCE_EXTENSION_NAME :: "VK_KHR_external_fence" -KHR_external_fence_fd :: 1 -KHR_EXTERNAL_FENCE_FD_SPEC_VERSION :: 1 -KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: "VK_KHR_external_fence_fd" -KHR_performance_query :: 1 -KHR_PERFORMANCE_QUERY_SPEC_VERSION :: 1 -KHR_PERFORMANCE_QUERY_EXTENSION_NAME :: "VK_KHR_performance_query" -KHR_maintenance2 :: 1 -KHR_MAINTENANCE_2_SPEC_VERSION :: 1 -KHR_MAINTENANCE_2_EXTENSION_NAME :: "VK_KHR_maintenance2" -KHR_MAINTENANCE2_SPEC_VERSION :: KHR_MAINTENANCE_2_SPEC_VERSION -KHR_MAINTENANCE2_EXTENSION_NAME :: KHR_MAINTENANCE_2_EXTENSION_NAME -KHR_get_surface_capabilities2 :: 1 -KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION :: 1 -KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: "VK_KHR_get_surface_capabilities2" -KHR_variable_pointers :: 1 -KHR_VARIABLE_POINTERS_SPEC_VERSION :: 1 -KHR_VARIABLE_POINTERS_EXTENSION_NAME :: "VK_KHR_variable_pointers" -KHR_get_display_properties2 :: 1 -KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION :: 1 -KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_display_properties2" -KHR_dedicated_allocation :: 1 -KHR_DEDICATED_ALLOCATION_SPEC_VERSION :: 3 -KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_KHR_dedicated_allocation" -KHR_storage_buffer_storage_class :: 1 -KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION :: 1 -KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: "VK_KHR_storage_buffer_storage_class" -KHR_relaxed_block_layout :: 1 -KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION :: 1 -KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_KHR_relaxed_block_layout" -KHR_get_memory_requirements2 :: 1 -KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION :: 1 -KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: "VK_KHR_get_memory_requirements2" -KHR_image_format_list :: 1 -KHR_IMAGE_FORMAT_LIST_SPEC_VERSION :: 1 -KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: "VK_KHR_image_format_list" -KHR_sampler_ycbcr_conversion :: 1 -KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION :: 14 -KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: "VK_KHR_sampler_ycbcr_conversion" -KHR_bind_memory2 :: 1 -KHR_BIND_MEMORY_2_SPEC_VERSION :: 1 -KHR_BIND_MEMORY_2_EXTENSION_NAME :: "VK_KHR_bind_memory2" -KHR_maintenance3 :: 1 -KHR_MAINTENANCE_3_SPEC_VERSION :: 1 -KHR_MAINTENANCE_3_EXTENSION_NAME :: "VK_KHR_maintenance3" -KHR_MAINTENANCE3_SPEC_VERSION :: KHR_MAINTENANCE_3_SPEC_VERSION -KHR_MAINTENANCE3_EXTENSION_NAME :: KHR_MAINTENANCE_3_EXTENSION_NAME -KHR_draw_indirect_count :: 1 -KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 1 -KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_KHR_draw_indirect_count" -KHR_shader_subgroup_extended_types :: 1 -KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION :: 1 -KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME :: "VK_KHR_shader_subgroup_extended_types" -KHR_8bit_storage :: 1 -KHR_8BIT_STORAGE_SPEC_VERSION :: 1 -KHR_8BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_8bit_storage" -KHR_shader_atomic_int64 :: 1 -KHR_SHADER_ATOMIC_INT64_SPEC_VERSION :: 1 -KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME :: "VK_KHR_shader_atomic_int64" -KHR_shader_clock :: 1 -KHR_SHADER_CLOCK_SPEC_VERSION :: 1 -KHR_SHADER_CLOCK_EXTENSION_NAME :: "VK_KHR_shader_clock" -KHR_global_priority :: 1 -MAX_GLOBAL_PRIORITY_SIZE_KHR :: 16 -KHR_GLOBAL_PRIORITY_SPEC_VERSION :: 1 -KHR_GLOBAL_PRIORITY_EXTENSION_NAME :: "VK_KHR_global_priority" -KHR_driver_properties :: 1 -KHR_DRIVER_PROPERTIES_SPEC_VERSION :: 1 -KHR_DRIVER_PROPERTIES_EXTENSION_NAME :: "VK_KHR_driver_properties" -MAX_DRIVER_NAME_SIZE_KHR :: MAX_DRIVER_NAME_SIZE -MAX_DRIVER_INFO_SIZE_KHR :: MAX_DRIVER_INFO_SIZE -KHR_shader_float_controls :: 1 -KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION :: 4 -KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME :: "VK_KHR_shader_float_controls" -KHR_depth_stencil_resolve :: 1 -KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION :: 1 -KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME :: "VK_KHR_depth_stencil_resolve" -KHR_swapchain_mutable_format :: 1 -KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION :: 1 -KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME :: "VK_KHR_swapchain_mutable_format" -KHR_timeline_semaphore :: 1 -KHR_TIMELINE_SEMAPHORE_SPEC_VERSION :: 2 -KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_timeline_semaphore" -KHR_vulkan_memory_model :: 1 -KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION :: 3 -KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME :: "VK_KHR_vulkan_memory_model" -KHR_shader_terminate_invocation :: 1 -KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION :: 1 -KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME :: "VK_KHR_shader_terminate_invocation" -KHR_fragment_shading_rate :: 1 -KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION :: 2 -KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME :: "VK_KHR_fragment_shading_rate" -KHR_spirv_1_4 :: 1 -KHR_SPIRV_1_4_SPEC_VERSION :: 1 -KHR_SPIRV_1_4_EXTENSION_NAME :: "VK_KHR_spirv_1_4" -KHR_surface_protected_capabilities :: 1 -KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION :: 1 -KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_surface_protected_capabilities" -KHR_separate_depth_stencil_layouts :: 1 -KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION :: 1 -KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME :: "VK_KHR_separate_depth_stencil_layouts" -KHR_present_wait :: 1 -KHR_PRESENT_WAIT_SPEC_VERSION :: 1 -KHR_PRESENT_WAIT_EXTENSION_NAME :: "VK_KHR_present_wait" -KHR_uniform_buffer_standard_layout :: 1 -KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION :: 1 -KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME :: "VK_KHR_uniform_buffer_standard_layout" -KHR_buffer_device_address :: 1 -KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 1 -KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_KHR_buffer_device_address" -KHR_deferred_host_operations :: 1 -KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: 4 -KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: "VK_KHR_deferred_host_operations" -KHR_pipeline_executable_properties :: 1 -KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION :: 1 -KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME :: "VK_KHR_pipeline_executable_properties" -KHR_shader_integer_dot_product :: 1 -KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION :: 1 -KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME :: "VK_KHR_shader_integer_dot_product" -KHR_pipeline_library :: 1 -KHR_PIPELINE_LIBRARY_SPEC_VERSION :: 1 -KHR_PIPELINE_LIBRARY_EXTENSION_NAME :: "VK_KHR_pipeline_library" -KHR_shader_non_semantic_info :: 1 -KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION :: 1 -KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME :: "VK_KHR_shader_non_semantic_info" -KHR_present_id :: 1 -KHR_PRESENT_ID_SPEC_VERSION :: 1 -KHR_PRESENT_ID_EXTENSION_NAME :: "VK_KHR_present_id" -KHR_synchronization2 :: 1 -KHR_SYNCHRONIZATION_2_SPEC_VERSION :: 1 -KHR_SYNCHRONIZATION_2_EXTENSION_NAME :: "VK_KHR_synchronization2" -KHR_shader_subgroup_uniform_control_flow :: 1 -KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION :: 1 -KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME :: "VK_KHR_shader_subgroup_uniform_control_flow" -KHR_zero_initialize_workgroup_memory :: 1 -KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION :: 1 -KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME :: "VK_KHR_zero_initialize_workgroup_memory" -KHR_workgroup_memory_explicit_layout :: 1 -KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION :: 1 -KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME :: "VK_KHR_workgroup_memory_explicit_layout" -KHR_copy_commands2 :: 1 -KHR_COPY_COMMANDS_2_SPEC_VERSION :: 1 -KHR_COPY_COMMANDS_2_EXTENSION_NAME :: "VK_KHR_copy_commands2" -KHR_format_feature_flags2 :: 1 -KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION :: 1 -KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME :: "VK_KHR_format_feature_flags2" -KHR_portability_enumeration :: 1 -KHR_PORTABILITY_ENUMERATION_SPEC_VERSION :: 1 -KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME :: "VK_KHR_portability_enumeration" -KHR_maintenance4 :: 1 -KHR_MAINTENANCE_4_SPEC_VERSION :: 2 -KHR_MAINTENANCE_4_EXTENSION_NAME :: "VK_KHR_maintenance4" -EXT_debug_report :: 1 -EXT_DEBUG_REPORT_SPEC_VERSION :: 10 -EXT_DEBUG_REPORT_EXTENSION_NAME :: "VK_EXT_debug_report" -NV_glsl_shader :: 1 -NV_GLSL_SHADER_SPEC_VERSION :: 1 -NV_GLSL_SHADER_EXTENSION_NAME :: "VK_NV_glsl_shader" -EXT_depth_range_unrestricted :: 1 -EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION :: 1 -EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: "VK_EXT_depth_range_unrestricted" -AMD_rasterization_order :: 1 -AMD_RASTERIZATION_ORDER_SPEC_VERSION :: 1 -AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: "VK_AMD_rasterization_order" -AMD_shader_trinary_minmax :: 1 -AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION :: 1 -AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: "VK_AMD_shader_trinary_minmax" -AMD_shader_explicit_vertex_parameter :: 1 -AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION :: 1 -AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: "VK_AMD_shader_explicit_vertex_parameter" -EXT_debug_marker :: 1 -EXT_DEBUG_MARKER_SPEC_VERSION :: 4 -EXT_DEBUG_MARKER_EXTENSION_NAME :: "VK_EXT_debug_marker" -AMD_gcn_shader :: 1 -AMD_GCN_SHADER_SPEC_VERSION :: 1 -AMD_GCN_SHADER_EXTENSION_NAME :: "VK_AMD_gcn_shader" -NV_dedicated_allocation :: 1 -NV_DEDICATED_ALLOCATION_SPEC_VERSION :: 1 -NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_NV_dedicated_allocation" -EXT_transform_feedback :: 1 -EXT_TRANSFORM_FEEDBACK_SPEC_VERSION :: 1 -EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME :: "VK_EXT_transform_feedback" -NVX_binary_import :: 1 -NVX_BINARY_IMPORT_SPEC_VERSION :: 1 -NVX_BINARY_IMPORT_EXTENSION_NAME :: "VK_NVX_binary_import" -NVX_image_view_handle :: 1 -NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: 2 -NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: "VK_NVX_image_view_handle" -AMD_draw_indirect_count :: 1 -AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 2 -AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_AMD_draw_indirect_count" -AMD_negative_viewport_height :: 1 -AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION :: 1 -AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: "VK_AMD_negative_viewport_height" -AMD_gpu_shader_half_float :: 1 -AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION :: 2 -AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: "VK_AMD_gpu_shader_half_float" -AMD_shader_ballot :: 1 -AMD_SHADER_BALLOT_SPEC_VERSION :: 1 -AMD_SHADER_BALLOT_EXTENSION_NAME :: "VK_AMD_shader_ballot" -AMD_texture_gather_bias_lod :: 1 -AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION :: 1 -AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: "VK_AMD_texture_gather_bias_lod" -AMD_shader_info :: 1 -AMD_SHADER_INFO_SPEC_VERSION :: 1 -AMD_SHADER_INFO_EXTENSION_NAME :: "VK_AMD_shader_info" -AMD_shader_image_load_store_lod :: 1 -AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION :: 1 -AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: "VK_AMD_shader_image_load_store_lod" -NV_corner_sampled_image :: 1 -NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION :: 2 -NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME :: "VK_NV_corner_sampled_image" -NV_external_memory_capabilities :: 1 -NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1 -NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_NV_external_memory_capabilities" -NV_external_memory :: 1 -NV_EXTERNAL_MEMORY_SPEC_VERSION :: 1 -NV_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_NV_external_memory" -EXT_validation_flags :: 1 -EXT_VALIDATION_FLAGS_SPEC_VERSION :: 2 -EXT_VALIDATION_FLAGS_EXTENSION_NAME :: "VK_EXT_validation_flags" -EXT_shader_subgroup_ballot :: 1 -EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION :: 1 -EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: "VK_EXT_shader_subgroup_ballot" -EXT_shader_subgroup_vote :: 1 -EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION :: 1 -EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: "VK_EXT_shader_subgroup_vote" -EXT_texture_compression_astc_hdr :: 1 -EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION :: 1 -EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME :: "VK_EXT_texture_compression_astc_hdr" -EXT_astc_decode_mode :: 1 -EXT_ASTC_DECODE_MODE_SPEC_VERSION :: 1 -EXT_ASTC_DECODE_MODE_EXTENSION_NAME :: "VK_EXT_astc_decode_mode" -EXT_conditional_rendering :: 1 -EXT_CONDITIONAL_RENDERING_SPEC_VERSION :: 2 -EXT_CONDITIONAL_RENDERING_EXTENSION_NAME :: "VK_EXT_conditional_rendering" -NV_clip_space_w_scaling :: 1 -NV_CLIP_SPACE_W_SCALING_SPEC_VERSION :: 1 -NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: "VK_NV_clip_space_w_scaling" -EXT_direct_mode_display :: 1 -EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION :: 1 -EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: "VK_EXT_direct_mode_display" -EXT_display_surface_counter :: 1 -EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION :: 1 -EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: "VK_EXT_display_surface_counter" -EXT_display_control :: 1 -EXT_DISPLAY_CONTROL_SPEC_VERSION :: 1 -EXT_DISPLAY_CONTROL_EXTENSION_NAME :: "VK_EXT_display_control" -GOOGLE_display_timing :: 1 -GOOGLE_DISPLAY_TIMING_SPEC_VERSION :: 1 -GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: "VK_GOOGLE_display_timing" -NV_sample_mask_override_coverage :: 1 -NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION :: 1 -NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: "VK_NV_sample_mask_override_coverage" -NV_geometry_shader_passthrough :: 1 -NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION :: 1 -NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: "VK_NV_geometry_shader_passthrough" -NV_viewport_array2 :: 1 -NV_VIEWPORT_ARRAY_2_SPEC_VERSION :: 1 -NV_VIEWPORT_ARRAY_2_EXTENSION_NAME :: "VK_NV_viewport_array2" -NV_VIEWPORT_ARRAY2_SPEC_VERSION :: NV_VIEWPORT_ARRAY_2_SPEC_VERSION -NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: NV_VIEWPORT_ARRAY_2_EXTENSION_NAME -NVX_multiview_per_view_attributes :: 1 -NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION :: 1 -NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: "VK_NVX_multiview_per_view_attributes" -NV_viewport_swizzle :: 1 -NV_VIEWPORT_SWIZZLE_SPEC_VERSION :: 1 -NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: "VK_NV_viewport_swizzle" -EXT_discard_rectangles :: 1 -EXT_DISCARD_RECTANGLES_SPEC_VERSION :: 1 -EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: "VK_EXT_discard_rectangles" -EXT_conservative_rasterization :: 1 -EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION :: 1 -EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_conservative_rasterization" -EXT_depth_clip_enable :: 1 -EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION :: 1 -EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME :: "VK_EXT_depth_clip_enable" -EXT_swapchain_colorspace :: 1 -EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION :: 4 -EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: "VK_EXT_swapchain_colorspace" -EXT_hdr_metadata :: 1 -EXT_HDR_METADATA_SPEC_VERSION :: 2 -EXT_HDR_METADATA_EXTENSION_NAME :: "VK_EXT_hdr_metadata" -EXT_external_memory_dma_buf :: 1 -EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION :: 1 -EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: "VK_EXT_external_memory_dma_buf" -EXT_queue_family_foreign :: 1 -EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION :: 1 -EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: "VK_EXT_queue_family_foreign" -EXT_debug_utils :: 1 -EXT_DEBUG_UTILS_SPEC_VERSION :: 2 -EXT_DEBUG_UTILS_EXTENSION_NAME :: "VK_EXT_debug_utils" -EXT_sampler_filter_minmax :: 1 -EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION :: 2 -EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: "VK_EXT_sampler_filter_minmax" -AMD_gpu_shader_int16 :: 1 -AMD_GPU_SHADER_INT16_SPEC_VERSION :: 2 -AMD_GPU_SHADER_INT16_EXTENSION_NAME :: "VK_AMD_gpu_shader_int16" -AMD_mixed_attachment_samples :: 1 -AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION :: 1 -AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: "VK_AMD_mixed_attachment_samples" -AMD_shader_fragment_mask :: 1 -AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION :: 1 -AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: "VK_AMD_shader_fragment_mask" -EXT_inline_uniform_block :: 1 -EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION :: 1 -EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME :: "VK_EXT_inline_uniform_block" -EXT_shader_stencil_export :: 1 -EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION :: 1 -EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: "VK_EXT_shader_stencil_export" -EXT_sample_locations :: 1 -EXT_SAMPLE_LOCATIONS_SPEC_VERSION :: 1 -EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: "VK_EXT_sample_locations" -EXT_blend_operation_advanced :: 1 -EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION :: 2 -EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: "VK_EXT_blend_operation_advanced" -NV_fragment_coverage_to_color :: 1 -NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION :: 1 -NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: "VK_NV_fragment_coverage_to_color" -NV_framebuffer_mixed_samples :: 1 -NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: 1 -NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: "VK_NV_framebuffer_mixed_samples" -NV_fill_rectangle :: 1 -NV_FILL_RECTANGLE_SPEC_VERSION :: 1 -NV_FILL_RECTANGLE_EXTENSION_NAME :: "VK_NV_fill_rectangle" -NV_shader_sm_builtins :: 1 -NV_SHADER_SM_BUILTINS_SPEC_VERSION :: 1 -NV_SHADER_SM_BUILTINS_EXTENSION_NAME :: "VK_NV_shader_sm_builtins" -EXT_post_depth_coverage :: 1 -EXT_POST_DEPTH_COVERAGE_SPEC_VERSION :: 1 -EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: "VK_EXT_post_depth_coverage" -EXT_image_drm_format_modifier :: 1 -EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION :: 2 -EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME :: "VK_EXT_image_drm_format_modifier" -EXT_validation_cache :: 1 -EXT_VALIDATION_CACHE_SPEC_VERSION :: 1 -EXT_VALIDATION_CACHE_EXTENSION_NAME :: "VK_EXT_validation_cache" -EXT_descriptor_indexing :: 1 -EXT_DESCRIPTOR_INDEXING_SPEC_VERSION :: 2 -EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME :: "VK_EXT_descriptor_indexing" -EXT_shader_viewport_index_layer :: 1 -EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION :: 1 -EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: "VK_EXT_shader_viewport_index_layer" -NV_shading_rate_image :: 1 -NV_SHADING_RATE_IMAGE_SPEC_VERSION :: 3 -NV_SHADING_RATE_IMAGE_EXTENSION_NAME :: "VK_NV_shading_rate_image" -NV_ray_tracing :: 1 -NV_RAY_TRACING_SPEC_VERSION :: 3 -NV_RAY_TRACING_EXTENSION_NAME :: "VK_NV_ray_tracing" -SHADER_UNUSED_KHR :: 0 -NV_representative_fragment_test :: 1 -NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION :: 2 -NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME :: "VK_NV_representative_fragment_test" -EXT_filter_cubic :: 1 -EXT_FILTER_CUBIC_SPEC_VERSION :: 3 -EXT_FILTER_CUBIC_EXTENSION_NAME :: "VK_EXT_filter_cubic" -EXT_global_priority :: 1 -EXT_GLOBAL_PRIORITY_SPEC_VERSION :: 2 -EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: "VK_EXT_global_priority" -EXT_external_memory_host :: 1 -EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION :: 1 -EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: "VK_EXT_external_memory_host" -AMD_buffer_marker :: 1 -AMD_BUFFER_MARKER_SPEC_VERSION :: 1 -AMD_BUFFER_MARKER_EXTENSION_NAME :: "VK_AMD_buffer_marker" -AMD_pipeline_compiler_control :: 1 -AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION :: 1 -AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME :: "VK_AMD_pipeline_compiler_control" -EXT_calibrated_timestamps :: 1 -EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION :: 2 -EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME :: "VK_EXT_calibrated_timestamps" -AMD_shader_core_properties :: 1 -AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION :: 2 -AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME :: "VK_AMD_shader_core_properties" -AMD_memory_overallocation_behavior :: 1 -AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION :: 1 -AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME :: "VK_AMD_memory_overallocation_behavior" -EXT_vertex_attribute_divisor :: 1 -EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION :: 3 -EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME :: "VK_EXT_vertex_attribute_divisor" -EXT_pipeline_creation_feedback :: 1 -EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION :: 1 -EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME :: "VK_EXT_pipeline_creation_feedback" -NV_shader_subgroup_partitioned :: 1 -NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION :: 1 -NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME :: "VK_NV_shader_subgroup_partitioned" -NV_compute_shader_derivatives :: 1 -NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION :: 1 -NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME :: "VK_NV_compute_shader_derivatives" -NV_mesh_shader :: 1 -NV_MESH_SHADER_SPEC_VERSION :: 1 -NV_MESH_SHADER_EXTENSION_NAME :: "VK_NV_mesh_shader" -NV_fragment_shader_barycentric :: 1 -NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION :: 1 -NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME :: "VK_NV_fragment_shader_barycentric" -NV_shader_image_footprint :: 1 -NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION :: 2 -NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME :: "VK_NV_shader_image_footprint" -NV_scissor_exclusive :: 1 -NV_SCISSOR_EXCLUSIVE_SPEC_VERSION :: 1 -NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME :: "VK_NV_scissor_exclusive" -NV_device_diagnostic_checkpoints :: 1 -NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION :: 2 -NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME :: "VK_NV_device_diagnostic_checkpoints" -EXT_pci_bus_info :: 1 -EXT_PCI_BUS_INFO_SPEC_VERSION :: 2 -EXT_PCI_BUS_INFO_EXTENSION_NAME :: "VK_EXT_pci_bus_info" -AMD_display_native_hdr :: 1 -AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION :: 1 -AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME :: "VK_AMD_display_native_hdr" -EXT_fragment_density_map :: 1 -EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION :: 2 -EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME :: "VK_EXT_fragment_density_map" -EXT_scalar_block_layout :: 1 -EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION :: 1 -EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_EXT_scalar_block_layout" -GOOGLE_hlsl_functionality1 :: 1 -GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION :: 1 -GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME :: "VK_GOOGLE_hlsl_functionality1" -GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION :: GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION -GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME :: GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME -GOOGLE_decorate_string :: 1 -GOOGLE_DECORATE_STRING_SPEC_VERSION :: 1 -GOOGLE_DECORATE_STRING_EXTENSION_NAME :: "VK_GOOGLE_decorate_string" -EXT_subgroup_size_control :: 1 -EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION :: 2 -EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME :: "VK_EXT_subgroup_size_control" -AMD_shader_core_properties2 :: 1 -AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION :: 1 -AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME :: "VK_AMD_shader_core_properties2" -AMD_device_coherent_memory :: 1 -AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION :: 1 -AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME :: "VK_AMD_device_coherent_memory" -EXT_shader_image_atomic_int64 :: 1 -EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION :: 1 -EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME :: "VK_EXT_shader_image_atomic_int64" -EXT_memory_budget :: 1 -EXT_MEMORY_BUDGET_SPEC_VERSION :: 1 -EXT_MEMORY_BUDGET_EXTENSION_NAME :: "VK_EXT_memory_budget" -EXT_memory_priority :: 1 -EXT_MEMORY_PRIORITY_SPEC_VERSION :: 1 -EXT_MEMORY_PRIORITY_EXTENSION_NAME :: "VK_EXT_memory_priority" -NV_dedicated_allocation_image_aliasing :: 1 -NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION :: 1 -NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME :: "VK_NV_dedicated_allocation_image_aliasing" -EXT_buffer_device_address :: 1 -EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 2 -EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_EXT_buffer_device_address" -EXT_tooling_info :: 1 -EXT_TOOLING_INFO_SPEC_VERSION :: 1 -EXT_TOOLING_INFO_EXTENSION_NAME :: "VK_EXT_tooling_info" -EXT_separate_stencil_usage :: 1 -EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION :: 1 -EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME :: "VK_EXT_separate_stencil_usage" -EXT_validation_features :: 1 -EXT_VALIDATION_FEATURES_SPEC_VERSION :: 5 -EXT_VALIDATION_FEATURES_EXTENSION_NAME :: "VK_EXT_validation_features" -NV_cooperative_matrix :: 1 -NV_COOPERATIVE_MATRIX_SPEC_VERSION :: 1 -NV_COOPERATIVE_MATRIX_EXTENSION_NAME :: "VK_NV_cooperative_matrix" -NV_coverage_reduction_mode :: 1 -NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION :: 1 -NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME :: "VK_NV_coverage_reduction_mode" -EXT_fragment_shader_interlock :: 1 -EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION :: 1 -EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME :: "VK_EXT_fragment_shader_interlock" -EXT_ycbcr_image_arrays :: 1 -EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION :: 1 -EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME :: "VK_EXT_ycbcr_image_arrays" -EXT_provoking_vertex :: 1 -EXT_PROVOKING_VERTEX_SPEC_VERSION :: 1 -EXT_PROVOKING_VERTEX_EXTENSION_NAME :: "VK_EXT_provoking_vertex" -EXT_headless_surface :: 1 -EXT_HEADLESS_SURFACE_SPEC_VERSION :: 1 -EXT_HEADLESS_SURFACE_EXTENSION_NAME :: "VK_EXT_headless_surface" -EXT_line_rasterization :: 1 -EXT_LINE_RASTERIZATION_SPEC_VERSION :: 1 -EXT_LINE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_line_rasterization" -EXT_shader_atomic_float :: 1 -EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: 1 -EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: "VK_EXT_shader_atomic_float" -EXT_host_query_reset :: 1 -EXT_HOST_QUERY_RESET_SPEC_VERSION :: 1 -EXT_HOST_QUERY_RESET_EXTENSION_NAME :: "VK_EXT_host_query_reset" -EXT_index_type_uint8 :: 1 -EXT_INDEX_TYPE_UINT8_SPEC_VERSION :: 1 -EXT_INDEX_TYPE_UINT8_EXTENSION_NAME :: "VK_EXT_index_type_uint8" -EXT_extended_dynamic_state :: 1 -EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION :: 1 -EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state" -EXT_shader_atomic_float2 :: 1 -EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION :: 1 -EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME :: "VK_EXT_shader_atomic_float2" -EXT_shader_demote_to_helper_invocation :: 1 -EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION :: 1 -EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME :: "VK_EXT_shader_demote_to_helper_invocation" -NV_device_generated_commands :: 1 -NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION :: 3 -NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: "VK_NV_device_generated_commands" -NV_inherited_viewport_scissor :: 1 -NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION :: 1 -NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME :: "VK_NV_inherited_viewport_scissor" -EXT_texel_buffer_alignment :: 1 -EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION :: 1 -EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME :: "VK_EXT_texel_buffer_alignment" -EXT_device_memory_report :: 1 -EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION :: 2 -EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME :: "VK_EXT_device_memory_report" -EXT_acquire_drm_display :: 1 -EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION :: 1 -EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME :: "VK_EXT_acquire_drm_display" -EXT_robustness2 :: 1 -EXT_ROBUSTNESS_2_SPEC_VERSION :: 1 -EXT_ROBUSTNESS_2_EXTENSION_NAME :: "VK_EXT_robustness2" -EXT_custom_border_color :: 1 -EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION :: 12 -EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME :: "VK_EXT_custom_border_color" -GOOGLE_user_type :: 1 -GOOGLE_USER_TYPE_SPEC_VERSION :: 1 -GOOGLE_USER_TYPE_EXTENSION_NAME :: "VK_GOOGLE_user_type" -EXT_private_data :: 1 -EXT_PRIVATE_DATA_SPEC_VERSION :: 1 -EXT_PRIVATE_DATA_EXTENSION_NAME :: "VK_EXT_private_data" -EXT_pipeline_creation_cache_control :: 1 -EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION :: 3 -EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME :: "VK_EXT_pipeline_creation_cache_control" -NV_device_diagnostics_config :: 1 -NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION :: 1 -NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME :: "VK_NV_device_diagnostics_config" -EXT_graphics_pipeline_library :: 1 -EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION :: 1 -EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME :: "VK_EXT_graphics_pipeline_library" -NV_fragment_shading_rate_enums :: 1 -NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION :: 1 -NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME :: "VK_NV_fragment_shading_rate_enums" -NV_ray_tracing_motion_blur :: 1 -NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: 1 -NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: "VK_NV_ray_tracing_motion_blur" -EXT_ycbcr_2plane_444_formats :: 1 -EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION :: 1 -EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME :: "VK_EXT_ycbcr_2plane_444_formats" -EXT_fragment_density_map2 :: 1 -EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION :: 1 -EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME :: "VK_EXT_fragment_density_map2" -EXT_image_robustness :: 1 -EXT_IMAGE_ROBUSTNESS_SPEC_VERSION :: 1 -EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME :: "VK_EXT_image_robustness" -EXT_4444_formats :: 1 -EXT_4444_FORMATS_SPEC_VERSION :: 1 -EXT_4444_FORMATS_EXTENSION_NAME :: "VK_EXT_4444_formats" -EXT_rgba10x6_formats :: 1 -EXT_RGBA10X6_FORMATS_SPEC_VERSION :: 1 -EXT_RGBA10X6_FORMATS_EXTENSION_NAME :: "VK_EXT_rgba10x6_formats" -NV_acquire_winrt_display :: 1 -NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION :: 1 -NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME :: "VK_NV_acquire_winrt_display" -EXT_vertex_input_dynamic_state :: 1 -EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION :: 2 -EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_vertex_input_dynamic_state" -EXT_physical_device_drm :: 1 -EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION :: 1 -EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME :: "VK_EXT_physical_device_drm" -EXT_depth_clip_control :: 1 -EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION :: 1 -EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME :: "VK_EXT_depth_clip_control" -EXT_primitive_topology_list_restart :: 1 -EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION :: 1 -EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME :: "VK_EXT_primitive_topology_list_restart" -NV_external_memory_rdma :: 1 -NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION :: 1 -NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME :: "VK_NV_external_memory_rdma" -EXT_extended_dynamic_state2 :: 1 -EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION :: 1 -EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state2" -EXT_color_write_enable :: 1 -EXT_COLOR_WRITE_ENABLE_SPEC_VERSION :: 1 -EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME :: "VK_EXT_color_write_enable" -EXT_primitives_generated_query :: 1 -EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION :: 1 -EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME :: "VK_EXT_primitives_generated_query" -EXT_global_priority_query :: 1 -EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION :: 1 -EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME :: "VK_EXT_global_priority_query" -EXT_image_view_min_lod :: 1 -EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION :: 1 -EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME :: "VK_EXT_image_view_min_lod" -EXT_multi_draw :: 1 -EXT_MULTI_DRAW_SPEC_VERSION :: 1 -EXT_MULTI_DRAW_EXTENSION_NAME :: "VK_EXT_multi_draw" -EXT_image_2d_view_of_3d :: 1 -EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION :: 1 -EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME :: "VK_EXT_image_2d_view_of_3d" -EXT_load_store_op_none :: 1 -EXT_LOAD_STORE_OP_NONE_SPEC_VERSION :: 1 -EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME :: "VK_EXT_load_store_op_none" -EXT_border_color_swizzle :: 1 -EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION :: 1 -EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME :: "VK_EXT_border_color_swizzle" -EXT_pageable_device_local_memory :: 1 -EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION :: 1 -EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME :: "VK_EXT_pageable_device_local_memory" -NV_linear_color_attachment :: 1 -NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION :: 1 -NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME :: "VK_NV_linear_color_attachment" -GOOGLE_surfaceless_query :: 1 -GOOGLE_SURFACELESS_QUERY_SPEC_VERSION :: 1 -GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME :: "VK_GOOGLE_surfaceless_query" -KHR_acceleration_structure :: 1 -KHR_ACCELERATION_STRUCTURE_SPEC_VERSION :: 13 -KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME :: "VK_KHR_acceleration_structure" -KHR_ray_tracing_pipeline :: 1 -KHR_RAY_TRACING_PIPELINE_SPEC_VERSION :: 1 -KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME :: "VK_KHR_ray_tracing_pipeline" -KHR_ray_query :: 1 -KHR_RAY_QUERY_SPEC_VERSION :: 1 -KHR_RAY_QUERY_EXTENSION_NAME :: "VK_KHR_ray_query" -KHR_win32_surface :: 1 -KHR_WIN32_SURFACE_SPEC_VERSION :: 6 -KHR_WIN32_SURFACE_EXTENSION_NAME :: "VK_KHR_win32_surface" -KHR_external_memory_win32 :: 1 -KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1 -KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_KHR_external_memory_win32" -KHR_win32_keyed_mutex :: 1 -KHR_WIN32_KEYED_MUTEX_SPEC_VERSION :: 1 -KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_KHR_win32_keyed_mutex" -KHR_external_semaphore_win32 :: 1 -KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION :: 1 -KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: "VK_KHR_external_semaphore_win32" -KHR_external_fence_win32 :: 1 -KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION :: 1 -KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: "VK_KHR_external_fence_win32" -NV_external_memory_win32 :: 1 -NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1 -NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_NV_external_memory_win32" -NV_win32_keyed_mutex :: 1 -NV_WIN32_KEYED_MUTEX_SPEC_VERSION :: 2 -NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_NV_win32_keyed_mutex" -EXT_full_screen_exclusive :: 1 -EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION :: 4 -EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME :: "VK_EXT_full_screen_exclusive" -EXT_metal_surface :: 1 -EXT_METAL_SURFACE_SPEC_VERSION :: 1 -EXT_METAL_SURFACE_EXTENSION_NAME :: "VK_EXT_metal_surface" -KHR_wayland_surface :: 1 -KHR_WAYLAND_SURFACE_SPEC_VERSION :: 6 -KHR_WAYLAND_SURFACE_EXTENSION_NAME :: "VK_KHR_wayland_surface" +KHR_surface :: 1 +KHR_SURFACE_SPEC_VERSION :: 25 +KHR_SURFACE_EXTENSION_NAME :: "VK_KHR_surface" +KHR_swapchain :: 1 +KHR_SWAPCHAIN_SPEC_VERSION :: 70 +KHR_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_swapchain" +KHR_display :: 1 +KHR_DISPLAY_SPEC_VERSION :: 23 +KHR_DISPLAY_EXTENSION_NAME :: "VK_KHR_display" +KHR_display_swapchain :: 1 +KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION :: 10 +KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME :: "VK_KHR_display_swapchain" +KHR_sampler_mirror_clamp_to_edge :: 1 +KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION :: 3 +KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME :: "VK_KHR_sampler_mirror_clamp_to_edge" +KHR_video_queue :: 1 +KHR_VIDEO_QUEUE_SPEC_VERSION :: 8 +KHR_VIDEO_QUEUE_EXTENSION_NAME :: "VK_KHR_video_queue" +KHR_video_decode_queue :: 1 +KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION :: 7 +KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME :: "VK_KHR_video_decode_queue" +KHR_video_decode_h264 :: 1 +KHR_VIDEO_DECODE_H264_SPEC_VERSION :: 8 +KHR_VIDEO_DECODE_H264_EXTENSION_NAME :: "VK_KHR_video_decode_h264" +KHR_dynamic_rendering :: 1 +KHR_DYNAMIC_RENDERING_SPEC_VERSION :: 1 +KHR_DYNAMIC_RENDERING_EXTENSION_NAME :: "VK_KHR_dynamic_rendering" +KHR_multiview :: 1 +KHR_MULTIVIEW_SPEC_VERSION :: 1 +KHR_MULTIVIEW_EXTENSION_NAME :: "VK_KHR_multiview" +KHR_get_physical_device_properties2 :: 1 +KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION :: 2 +KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_physical_device_properties2" +KHR_device_group :: 1 +KHR_DEVICE_GROUP_SPEC_VERSION :: 4 +KHR_DEVICE_GROUP_EXTENSION_NAME :: "VK_KHR_device_group" +KHR_shader_draw_parameters :: 1 +KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION :: 1 +KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME :: "VK_KHR_shader_draw_parameters" +KHR_maintenance1 :: 1 +KHR_MAINTENANCE_1_SPEC_VERSION :: 2 +KHR_MAINTENANCE_1_EXTENSION_NAME :: "VK_KHR_maintenance1" +KHR_MAINTENANCE1_SPEC_VERSION :: KHR_MAINTENANCE_1_SPEC_VERSION +KHR_MAINTENANCE1_EXTENSION_NAME :: KHR_MAINTENANCE_1_EXTENSION_NAME +KHR_device_group_creation :: 1 +KHR_DEVICE_GROUP_CREATION_SPEC_VERSION :: 1 +KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME :: "VK_KHR_device_group_creation" +MAX_DEVICE_GROUP_SIZE_KHR :: MAX_DEVICE_GROUP_SIZE +KHR_external_memory_capabilities :: 1 +KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1 +KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_memory_capabilities" +LUID_SIZE_KHR :: LUID_SIZE +KHR_external_memory :: 1 +KHR_EXTERNAL_MEMORY_SPEC_VERSION :: 1 +KHR_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_KHR_external_memory" +QUEUE_FAMILY_EXTERNAL_KHR :: QUEUE_FAMILY_EXTERNAL +KHR_external_memory_fd :: 1 +KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION :: 1 +KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME :: "VK_KHR_external_memory_fd" +KHR_external_semaphore_capabilities :: 1 +KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION :: 1 +KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_semaphore_capabilities" +KHR_external_semaphore :: 1 +KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION :: 1 +KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_external_semaphore" +KHR_external_semaphore_fd :: 1 +KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION :: 1 +KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME :: "VK_KHR_external_semaphore_fd" +KHR_push_descriptor :: 1 +KHR_PUSH_DESCRIPTOR_SPEC_VERSION :: 2 +KHR_PUSH_DESCRIPTOR_EXTENSION_NAME :: "VK_KHR_push_descriptor" +KHR_shader_float16_int8 :: 1 +KHR_SHADER_FLOAT16_INT8_SPEC_VERSION :: 1 +KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME :: "VK_KHR_shader_float16_int8" +KHR_16bit_storage :: 1 +KHR_16BIT_STORAGE_SPEC_VERSION :: 1 +KHR_16BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_16bit_storage" +KHR_incremental_present :: 1 +KHR_INCREMENTAL_PRESENT_SPEC_VERSION :: 2 +KHR_INCREMENTAL_PRESENT_EXTENSION_NAME :: "VK_KHR_incremental_present" +KHR_descriptor_update_template :: 1 +KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION :: 1 +KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME :: "VK_KHR_descriptor_update_template" +KHR_imageless_framebuffer :: 1 +KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION :: 1 +KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME :: "VK_KHR_imageless_framebuffer" +KHR_create_renderpass2 :: 1 +KHR_CREATE_RENDERPASS_2_SPEC_VERSION :: 1 +KHR_CREATE_RENDERPASS_2_EXTENSION_NAME :: "VK_KHR_create_renderpass2" +KHR_shared_presentable_image :: 1 +KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION :: 1 +KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME :: "VK_KHR_shared_presentable_image" +KHR_external_fence_capabilities :: 1 +KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION :: 1 +KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_external_fence_capabilities" +KHR_external_fence :: 1 +KHR_EXTERNAL_FENCE_SPEC_VERSION :: 1 +KHR_EXTERNAL_FENCE_EXTENSION_NAME :: "VK_KHR_external_fence" +KHR_external_fence_fd :: 1 +KHR_EXTERNAL_FENCE_FD_SPEC_VERSION :: 1 +KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME :: "VK_KHR_external_fence_fd" +KHR_performance_query :: 1 +KHR_PERFORMANCE_QUERY_SPEC_VERSION :: 1 +KHR_PERFORMANCE_QUERY_EXTENSION_NAME :: "VK_KHR_performance_query" +KHR_maintenance2 :: 1 +KHR_MAINTENANCE_2_SPEC_VERSION :: 1 +KHR_MAINTENANCE_2_EXTENSION_NAME :: "VK_KHR_maintenance2" +KHR_MAINTENANCE2_SPEC_VERSION :: KHR_MAINTENANCE_2_SPEC_VERSION +KHR_MAINTENANCE2_EXTENSION_NAME :: KHR_MAINTENANCE_2_EXTENSION_NAME +KHR_get_surface_capabilities2 :: 1 +KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION :: 1 +KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME :: "VK_KHR_get_surface_capabilities2" +KHR_variable_pointers :: 1 +KHR_VARIABLE_POINTERS_SPEC_VERSION :: 1 +KHR_VARIABLE_POINTERS_EXTENSION_NAME :: "VK_KHR_variable_pointers" +KHR_get_display_properties2 :: 1 +KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION :: 1 +KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME :: "VK_KHR_get_display_properties2" +KHR_dedicated_allocation :: 1 +KHR_DEDICATED_ALLOCATION_SPEC_VERSION :: 3 +KHR_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_KHR_dedicated_allocation" +KHR_storage_buffer_storage_class :: 1 +KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION :: 1 +KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME :: "VK_KHR_storage_buffer_storage_class" +KHR_relaxed_block_layout :: 1 +KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION :: 1 +KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_KHR_relaxed_block_layout" +KHR_get_memory_requirements2 :: 1 +KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION :: 1 +KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME :: "VK_KHR_get_memory_requirements2" +KHR_image_format_list :: 1 +KHR_IMAGE_FORMAT_LIST_SPEC_VERSION :: 1 +KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME :: "VK_KHR_image_format_list" +KHR_sampler_ycbcr_conversion :: 1 +KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION :: 14 +KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME :: "VK_KHR_sampler_ycbcr_conversion" +KHR_bind_memory2 :: 1 +KHR_BIND_MEMORY_2_SPEC_VERSION :: 1 +KHR_BIND_MEMORY_2_EXTENSION_NAME :: "VK_KHR_bind_memory2" +KHR_maintenance3 :: 1 +KHR_MAINTENANCE_3_SPEC_VERSION :: 1 +KHR_MAINTENANCE_3_EXTENSION_NAME :: "VK_KHR_maintenance3" +KHR_MAINTENANCE3_SPEC_VERSION :: KHR_MAINTENANCE_3_SPEC_VERSION +KHR_MAINTENANCE3_EXTENSION_NAME :: KHR_MAINTENANCE_3_EXTENSION_NAME +KHR_draw_indirect_count :: 1 +KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 1 +KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_KHR_draw_indirect_count" +KHR_shader_subgroup_extended_types :: 1 +KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION :: 1 +KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME :: "VK_KHR_shader_subgroup_extended_types" +KHR_8bit_storage :: 1 +KHR_8BIT_STORAGE_SPEC_VERSION :: 1 +KHR_8BIT_STORAGE_EXTENSION_NAME :: "VK_KHR_8bit_storage" +KHR_shader_atomic_int64 :: 1 +KHR_SHADER_ATOMIC_INT64_SPEC_VERSION :: 1 +KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME :: "VK_KHR_shader_atomic_int64" +KHR_shader_clock :: 1 +KHR_SHADER_CLOCK_SPEC_VERSION :: 1 +KHR_SHADER_CLOCK_EXTENSION_NAME :: "VK_KHR_shader_clock" +KHR_video_decode_h265 :: 1 +KHR_VIDEO_DECODE_H265_SPEC_VERSION :: 7 +KHR_VIDEO_DECODE_H265_EXTENSION_NAME :: "VK_KHR_video_decode_h265" +KHR_global_priority :: 1 +MAX_GLOBAL_PRIORITY_SIZE_KHR :: 16 +KHR_GLOBAL_PRIORITY_SPEC_VERSION :: 1 +KHR_GLOBAL_PRIORITY_EXTENSION_NAME :: "VK_KHR_global_priority" +KHR_driver_properties :: 1 +KHR_DRIVER_PROPERTIES_SPEC_VERSION :: 1 +KHR_DRIVER_PROPERTIES_EXTENSION_NAME :: "VK_KHR_driver_properties" +MAX_DRIVER_NAME_SIZE_KHR :: MAX_DRIVER_NAME_SIZE +MAX_DRIVER_INFO_SIZE_KHR :: MAX_DRIVER_INFO_SIZE +KHR_shader_float_controls :: 1 +KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION :: 4 +KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME :: "VK_KHR_shader_float_controls" +KHR_depth_stencil_resolve :: 1 +KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION :: 1 +KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME :: "VK_KHR_depth_stencil_resolve" +KHR_swapchain_mutable_format :: 1 +KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION :: 1 +KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME :: "VK_KHR_swapchain_mutable_format" +KHR_timeline_semaphore :: 1 +KHR_TIMELINE_SEMAPHORE_SPEC_VERSION :: 2 +KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME :: "VK_KHR_timeline_semaphore" +KHR_vulkan_memory_model :: 1 +KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION :: 3 +KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME :: "VK_KHR_vulkan_memory_model" +KHR_shader_terminate_invocation :: 1 +KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION :: 1 +KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME :: "VK_KHR_shader_terminate_invocation" +KHR_fragment_shading_rate :: 1 +KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION :: 2 +KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME :: "VK_KHR_fragment_shading_rate" +KHR_spirv_1_4 :: 1 +KHR_SPIRV_1_4_SPEC_VERSION :: 1 +KHR_SPIRV_1_4_EXTENSION_NAME :: "VK_KHR_spirv_1_4" +KHR_surface_protected_capabilities :: 1 +KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION :: 1 +KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME :: "VK_KHR_surface_protected_capabilities" +KHR_separate_depth_stencil_layouts :: 1 +KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION :: 1 +KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME :: "VK_KHR_separate_depth_stencil_layouts" +KHR_present_wait :: 1 +KHR_PRESENT_WAIT_SPEC_VERSION :: 1 +KHR_PRESENT_WAIT_EXTENSION_NAME :: "VK_KHR_present_wait" +KHR_uniform_buffer_standard_layout :: 1 +KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION :: 1 +KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME :: "VK_KHR_uniform_buffer_standard_layout" +KHR_buffer_device_address :: 1 +KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 1 +KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_KHR_buffer_device_address" +KHR_deferred_host_operations :: 1 +KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION :: 4 +KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME :: "VK_KHR_deferred_host_operations" +KHR_pipeline_executable_properties :: 1 +KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION :: 1 +KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME :: "VK_KHR_pipeline_executable_properties" +KHR_map_memory2 :: 1 +KHR_MAP_MEMORY_2_SPEC_VERSION :: 1 +KHR_MAP_MEMORY_2_EXTENSION_NAME :: "VK_KHR_map_memory2" +KHR_shader_integer_dot_product :: 1 +KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION :: 1 +KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME :: "VK_KHR_shader_integer_dot_product" +KHR_pipeline_library :: 1 +KHR_PIPELINE_LIBRARY_SPEC_VERSION :: 1 +KHR_PIPELINE_LIBRARY_EXTENSION_NAME :: "VK_KHR_pipeline_library" +KHR_shader_non_semantic_info :: 1 +KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION :: 1 +KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME :: "VK_KHR_shader_non_semantic_info" +KHR_present_id :: 1 +KHR_PRESENT_ID_SPEC_VERSION :: 1 +KHR_PRESENT_ID_EXTENSION_NAME :: "VK_KHR_present_id" +KHR_synchronization2 :: 1 +KHR_SYNCHRONIZATION_2_SPEC_VERSION :: 1 +KHR_SYNCHRONIZATION_2_EXTENSION_NAME :: "VK_KHR_synchronization2" +KHR_fragment_shader_barycentric :: 1 +KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION :: 1 +KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME :: "VK_KHR_fragment_shader_barycentric" +KHR_shader_subgroup_uniform_control_flow :: 1 +KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION :: 1 +KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME :: "VK_KHR_shader_subgroup_uniform_control_flow" +KHR_zero_initialize_workgroup_memory :: 1 +KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION :: 1 +KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME :: "VK_KHR_zero_initialize_workgroup_memory" +KHR_workgroup_memory_explicit_layout :: 1 +KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION :: 1 +KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME :: "VK_KHR_workgroup_memory_explicit_layout" +KHR_copy_commands2 :: 1 +KHR_COPY_COMMANDS_2_SPEC_VERSION :: 1 +KHR_COPY_COMMANDS_2_EXTENSION_NAME :: "VK_KHR_copy_commands2" +KHR_format_feature_flags2 :: 1 +KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION :: 2 +KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME :: "VK_KHR_format_feature_flags2" +KHR_ray_tracing_maintenance1 :: 1 +KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION :: 1 +KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME :: "VK_KHR_ray_tracing_maintenance1" +KHR_portability_enumeration :: 1 +KHR_PORTABILITY_ENUMERATION_SPEC_VERSION :: 1 +KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME :: "VK_KHR_portability_enumeration" +KHR_maintenance4 :: 1 +KHR_MAINTENANCE_4_SPEC_VERSION :: 2 +KHR_MAINTENANCE_4_EXTENSION_NAME :: "VK_KHR_maintenance4" +KHR_ray_tracing_position_fetch :: 1 +KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION :: 1 +KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME :: "VK_KHR_ray_tracing_position_fetch" +EXT_debug_report :: 1 +EXT_DEBUG_REPORT_SPEC_VERSION :: 10 +EXT_DEBUG_REPORT_EXTENSION_NAME :: "VK_EXT_debug_report" +NV_glsl_shader :: 1 +NV_GLSL_SHADER_SPEC_VERSION :: 1 +NV_GLSL_SHADER_EXTENSION_NAME :: "VK_NV_glsl_shader" +EXT_depth_range_unrestricted :: 1 +EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION :: 1 +EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME :: "VK_EXT_depth_range_unrestricted" +AMD_rasterization_order :: 1 +AMD_RASTERIZATION_ORDER_SPEC_VERSION :: 1 +AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: "VK_AMD_rasterization_order" +AMD_shader_trinary_minmax :: 1 +AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION :: 1 +AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME :: "VK_AMD_shader_trinary_minmax" +AMD_shader_explicit_vertex_parameter :: 1 +AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION :: 1 +AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME :: "VK_AMD_shader_explicit_vertex_parameter" +EXT_debug_marker :: 1 +EXT_DEBUG_MARKER_SPEC_VERSION :: 4 +EXT_DEBUG_MARKER_EXTENSION_NAME :: "VK_EXT_debug_marker" +AMD_gcn_shader :: 1 +AMD_GCN_SHADER_SPEC_VERSION :: 1 +AMD_GCN_SHADER_EXTENSION_NAME :: "VK_AMD_gcn_shader" +NV_dedicated_allocation :: 1 +NV_DEDICATED_ALLOCATION_SPEC_VERSION :: 1 +NV_DEDICATED_ALLOCATION_EXTENSION_NAME :: "VK_NV_dedicated_allocation" +EXT_transform_feedback :: 1 +EXT_TRANSFORM_FEEDBACK_SPEC_VERSION :: 1 +EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME :: "VK_EXT_transform_feedback" +NVX_binary_import :: 1 +NVX_BINARY_IMPORT_SPEC_VERSION :: 1 +NVX_BINARY_IMPORT_EXTENSION_NAME :: "VK_NVX_binary_import" +NVX_image_view_handle :: 1 +NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: 2 +NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: "VK_NVX_image_view_handle" +AMD_draw_indirect_count :: 1 +AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION :: 2 +AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME :: "VK_AMD_draw_indirect_count" +AMD_negative_viewport_height :: 1 +AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION :: 1 +AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME :: "VK_AMD_negative_viewport_height" +AMD_gpu_shader_half_float :: 1 +AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION :: 2 +AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME :: "VK_AMD_gpu_shader_half_float" +AMD_shader_ballot :: 1 +AMD_SHADER_BALLOT_SPEC_VERSION :: 1 +AMD_SHADER_BALLOT_EXTENSION_NAME :: "VK_AMD_shader_ballot" +AMD_texture_gather_bias_lod :: 1 +AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION :: 1 +AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME :: "VK_AMD_texture_gather_bias_lod" +AMD_shader_info :: 1 +AMD_SHADER_INFO_SPEC_VERSION :: 1 +AMD_SHADER_INFO_EXTENSION_NAME :: "VK_AMD_shader_info" +AMD_shader_image_load_store_lod :: 1 +AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION :: 1 +AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME :: "VK_AMD_shader_image_load_store_lod" +NV_corner_sampled_image :: 1 +NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION :: 2 +NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME :: "VK_NV_corner_sampled_image" +NV_external_memory_capabilities :: 1 +NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION :: 1 +NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME :: "VK_NV_external_memory_capabilities" +NV_external_memory :: 1 +NV_EXTERNAL_MEMORY_SPEC_VERSION :: 1 +NV_EXTERNAL_MEMORY_EXTENSION_NAME :: "VK_NV_external_memory" +EXT_validation_flags :: 1 +EXT_VALIDATION_FLAGS_SPEC_VERSION :: 2 +EXT_VALIDATION_FLAGS_EXTENSION_NAME :: "VK_EXT_validation_flags" +EXT_shader_subgroup_ballot :: 1 +EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION :: 1 +EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME :: "VK_EXT_shader_subgroup_ballot" +EXT_shader_subgroup_vote :: 1 +EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION :: 1 +EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME :: "VK_EXT_shader_subgroup_vote" +EXT_texture_compression_astc_hdr :: 1 +EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION :: 1 +EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME :: "VK_EXT_texture_compression_astc_hdr" +EXT_astc_decode_mode :: 1 +EXT_ASTC_DECODE_MODE_SPEC_VERSION :: 1 +EXT_ASTC_DECODE_MODE_EXTENSION_NAME :: "VK_EXT_astc_decode_mode" +EXT_pipeline_robustness :: 1 +EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION :: 1 +EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME :: "VK_EXT_pipeline_robustness" +EXT_conditional_rendering :: 1 +EXT_CONDITIONAL_RENDERING_SPEC_VERSION :: 2 +EXT_CONDITIONAL_RENDERING_EXTENSION_NAME :: "VK_EXT_conditional_rendering" +NV_clip_space_w_scaling :: 1 +NV_CLIP_SPACE_W_SCALING_SPEC_VERSION :: 1 +NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME :: "VK_NV_clip_space_w_scaling" +EXT_direct_mode_display :: 1 +EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION :: 1 +EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME :: "VK_EXT_direct_mode_display" +EXT_display_surface_counter :: 1 +EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION :: 1 +EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME :: "VK_EXT_display_surface_counter" +EXT_display_control :: 1 +EXT_DISPLAY_CONTROL_SPEC_VERSION :: 1 +EXT_DISPLAY_CONTROL_EXTENSION_NAME :: "VK_EXT_display_control" +GOOGLE_display_timing :: 1 +GOOGLE_DISPLAY_TIMING_SPEC_VERSION :: 1 +GOOGLE_DISPLAY_TIMING_EXTENSION_NAME :: "VK_GOOGLE_display_timing" +NV_sample_mask_override_coverage :: 1 +NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION :: 1 +NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME :: "VK_NV_sample_mask_override_coverage" +NV_geometry_shader_passthrough :: 1 +NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION :: 1 +NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME :: "VK_NV_geometry_shader_passthrough" +NV_viewport_array2 :: 1 +NV_VIEWPORT_ARRAY_2_SPEC_VERSION :: 1 +NV_VIEWPORT_ARRAY_2_EXTENSION_NAME :: "VK_NV_viewport_array2" +NV_VIEWPORT_ARRAY2_SPEC_VERSION :: NV_VIEWPORT_ARRAY_2_SPEC_VERSION +NV_VIEWPORT_ARRAY2_EXTENSION_NAME :: NV_VIEWPORT_ARRAY_2_EXTENSION_NAME +NVX_multiview_per_view_attributes :: 1 +NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION :: 1 +NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME :: "VK_NVX_multiview_per_view_attributes" +NV_viewport_swizzle :: 1 +NV_VIEWPORT_SWIZZLE_SPEC_VERSION :: 1 +NV_VIEWPORT_SWIZZLE_EXTENSION_NAME :: "VK_NV_viewport_swizzle" +EXT_discard_rectangles :: 1 +EXT_DISCARD_RECTANGLES_SPEC_VERSION :: 2 +EXT_DISCARD_RECTANGLES_EXTENSION_NAME :: "VK_EXT_discard_rectangles" +EXT_conservative_rasterization :: 1 +EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION :: 1 +EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_conservative_rasterization" +EXT_depth_clip_enable :: 1 +EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION :: 1 +EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME :: "VK_EXT_depth_clip_enable" +EXT_swapchain_colorspace :: 1 +EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION :: 4 +EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME :: "VK_EXT_swapchain_colorspace" +EXT_hdr_metadata :: 1 +EXT_HDR_METADATA_SPEC_VERSION :: 2 +EXT_HDR_METADATA_EXTENSION_NAME :: "VK_EXT_hdr_metadata" +EXT_external_memory_dma_buf :: 1 +EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION :: 1 +EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME :: "VK_EXT_external_memory_dma_buf" +EXT_queue_family_foreign :: 1 +EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION :: 1 +EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME :: "VK_EXT_queue_family_foreign" +EXT_debug_utils :: 1 +EXT_DEBUG_UTILS_SPEC_VERSION :: 2 +EXT_DEBUG_UTILS_EXTENSION_NAME :: "VK_EXT_debug_utils" +EXT_sampler_filter_minmax :: 1 +EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION :: 2 +EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME :: "VK_EXT_sampler_filter_minmax" +AMD_gpu_shader_int16 :: 1 +AMD_GPU_SHADER_INT16_SPEC_VERSION :: 2 +AMD_GPU_SHADER_INT16_EXTENSION_NAME :: "VK_AMD_gpu_shader_int16" +AMD_mixed_attachment_samples :: 1 +AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION :: 1 +AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME :: "VK_AMD_mixed_attachment_samples" +AMD_shader_fragment_mask :: 1 +AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION :: 1 +AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME :: "VK_AMD_shader_fragment_mask" +EXT_inline_uniform_block :: 1 +EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION :: 1 +EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME :: "VK_EXT_inline_uniform_block" +EXT_shader_stencil_export :: 1 +EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION :: 1 +EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME :: "VK_EXT_shader_stencil_export" +EXT_sample_locations :: 1 +EXT_SAMPLE_LOCATIONS_SPEC_VERSION :: 1 +EXT_SAMPLE_LOCATIONS_EXTENSION_NAME :: "VK_EXT_sample_locations" +EXT_blend_operation_advanced :: 1 +EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION :: 2 +EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME :: "VK_EXT_blend_operation_advanced" +NV_fragment_coverage_to_color :: 1 +NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION :: 1 +NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME :: "VK_NV_fragment_coverage_to_color" +NV_framebuffer_mixed_samples :: 1 +NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: 1 +NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: "VK_NV_framebuffer_mixed_samples" +NV_fill_rectangle :: 1 +NV_FILL_RECTANGLE_SPEC_VERSION :: 1 +NV_FILL_RECTANGLE_EXTENSION_NAME :: "VK_NV_fill_rectangle" +NV_shader_sm_builtins :: 1 +NV_SHADER_SM_BUILTINS_SPEC_VERSION :: 1 +NV_SHADER_SM_BUILTINS_EXTENSION_NAME :: "VK_NV_shader_sm_builtins" +EXT_post_depth_coverage :: 1 +EXT_POST_DEPTH_COVERAGE_SPEC_VERSION :: 1 +EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME :: "VK_EXT_post_depth_coverage" +EXT_image_drm_format_modifier :: 1 +EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION :: 2 +EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME :: "VK_EXT_image_drm_format_modifier" +EXT_validation_cache :: 1 +EXT_VALIDATION_CACHE_SPEC_VERSION :: 1 +EXT_VALIDATION_CACHE_EXTENSION_NAME :: "VK_EXT_validation_cache" +EXT_descriptor_indexing :: 1 +EXT_DESCRIPTOR_INDEXING_SPEC_VERSION :: 2 +EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME :: "VK_EXT_descriptor_indexing" +EXT_shader_viewport_index_layer :: 1 +EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION :: 1 +EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME :: "VK_EXT_shader_viewport_index_layer" +NV_shading_rate_image :: 1 +NV_SHADING_RATE_IMAGE_SPEC_VERSION :: 3 +NV_SHADING_RATE_IMAGE_EXTENSION_NAME :: "VK_NV_shading_rate_image" +NV_ray_tracing :: 1 +NV_RAY_TRACING_SPEC_VERSION :: 3 +NV_RAY_TRACING_EXTENSION_NAME :: "VK_NV_ray_tracing" +SHADER_UNUSED_KHR :: 0 +NV_representative_fragment_test :: 1 +NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION :: 2 +NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME :: "VK_NV_representative_fragment_test" +EXT_filter_cubic :: 1 +EXT_FILTER_CUBIC_SPEC_VERSION :: 3 +EXT_FILTER_CUBIC_EXTENSION_NAME :: "VK_EXT_filter_cubic" +EXT_global_priority :: 1 +EXT_GLOBAL_PRIORITY_SPEC_VERSION :: 2 +EXT_GLOBAL_PRIORITY_EXTENSION_NAME :: "VK_EXT_global_priority" +EXT_external_memory_host :: 1 +EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION :: 1 +EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME :: "VK_EXT_external_memory_host" +AMD_buffer_marker :: 1 +AMD_BUFFER_MARKER_SPEC_VERSION :: 1 +AMD_BUFFER_MARKER_EXTENSION_NAME :: "VK_AMD_buffer_marker" +AMD_pipeline_compiler_control :: 1 +AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION :: 1 +AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME :: "VK_AMD_pipeline_compiler_control" +EXT_calibrated_timestamps :: 1 +EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION :: 2 +EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME :: "VK_EXT_calibrated_timestamps" +AMD_shader_core_properties :: 1 +AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION :: 2 +AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME :: "VK_AMD_shader_core_properties" +AMD_memory_overallocation_behavior :: 1 +AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION :: 1 +AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME :: "VK_AMD_memory_overallocation_behavior" +EXT_vertex_attribute_divisor :: 1 +EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION :: 3 +EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME :: "VK_EXT_vertex_attribute_divisor" +EXT_pipeline_creation_feedback :: 1 +EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION :: 1 +EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME :: "VK_EXT_pipeline_creation_feedback" +NV_shader_subgroup_partitioned :: 1 +NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION :: 1 +NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME :: "VK_NV_shader_subgroup_partitioned" +NV_compute_shader_derivatives :: 1 +NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION :: 1 +NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME :: "VK_NV_compute_shader_derivatives" +NV_mesh_shader :: 1 +NV_MESH_SHADER_SPEC_VERSION :: 1 +NV_MESH_SHADER_EXTENSION_NAME :: "VK_NV_mesh_shader" +NV_fragment_shader_barycentric :: 1 +NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION :: 1 +NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME :: "VK_NV_fragment_shader_barycentric" +NV_shader_image_footprint :: 1 +NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION :: 2 +NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME :: "VK_NV_shader_image_footprint" +NV_scissor_exclusive :: 1 +NV_SCISSOR_EXCLUSIVE_SPEC_VERSION :: 2 +NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME :: "VK_NV_scissor_exclusive" +NV_device_diagnostic_checkpoints :: 1 +NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION :: 2 +NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME :: "VK_NV_device_diagnostic_checkpoints" +EXT_pci_bus_info :: 1 +EXT_PCI_BUS_INFO_SPEC_VERSION :: 2 +EXT_PCI_BUS_INFO_EXTENSION_NAME :: "VK_EXT_pci_bus_info" +AMD_display_native_hdr :: 1 +AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION :: 1 +AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME :: "VK_AMD_display_native_hdr" +EXT_fragment_density_map :: 1 +EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION :: 2 +EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME :: "VK_EXT_fragment_density_map" +EXT_scalar_block_layout :: 1 +EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION :: 1 +EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME :: "VK_EXT_scalar_block_layout" +GOOGLE_hlsl_functionality1 :: 1 +GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION :: 1 +GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME :: "VK_GOOGLE_hlsl_functionality1" +GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION :: GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION +GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME :: GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME +GOOGLE_decorate_string :: 1 +GOOGLE_DECORATE_STRING_SPEC_VERSION :: 1 +GOOGLE_DECORATE_STRING_EXTENSION_NAME :: "VK_GOOGLE_decorate_string" +EXT_subgroup_size_control :: 1 +EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION :: 2 +EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME :: "VK_EXT_subgroup_size_control" +AMD_shader_core_properties2 :: 1 +AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION :: 1 +AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME :: "VK_AMD_shader_core_properties2" +AMD_device_coherent_memory :: 1 +AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION :: 1 +AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME :: "VK_AMD_device_coherent_memory" +EXT_shader_image_atomic_int64 :: 1 +EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION :: 1 +EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME :: "VK_EXT_shader_image_atomic_int64" +EXT_memory_budget :: 1 +EXT_MEMORY_BUDGET_SPEC_VERSION :: 1 +EXT_MEMORY_BUDGET_EXTENSION_NAME :: "VK_EXT_memory_budget" +EXT_memory_priority :: 1 +EXT_MEMORY_PRIORITY_SPEC_VERSION :: 1 +EXT_MEMORY_PRIORITY_EXTENSION_NAME :: "VK_EXT_memory_priority" +NV_dedicated_allocation_image_aliasing :: 1 +NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION :: 1 +NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME :: "VK_NV_dedicated_allocation_image_aliasing" +EXT_buffer_device_address :: 1 +EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION :: 2 +EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME :: "VK_EXT_buffer_device_address" +EXT_tooling_info :: 1 +EXT_TOOLING_INFO_SPEC_VERSION :: 1 +EXT_TOOLING_INFO_EXTENSION_NAME :: "VK_EXT_tooling_info" +EXT_separate_stencil_usage :: 1 +EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION :: 1 +EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME :: "VK_EXT_separate_stencil_usage" +EXT_validation_features :: 1 +EXT_VALIDATION_FEATURES_SPEC_VERSION :: 5 +EXT_VALIDATION_FEATURES_EXTENSION_NAME :: "VK_EXT_validation_features" +NV_cooperative_matrix :: 1 +NV_COOPERATIVE_MATRIX_SPEC_VERSION :: 1 +NV_COOPERATIVE_MATRIX_EXTENSION_NAME :: "VK_NV_cooperative_matrix" +NV_coverage_reduction_mode :: 1 +NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION :: 1 +NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME :: "VK_NV_coverage_reduction_mode" +EXT_fragment_shader_interlock :: 1 +EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION :: 1 +EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME :: "VK_EXT_fragment_shader_interlock" +EXT_ycbcr_image_arrays :: 1 +EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION :: 1 +EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME :: "VK_EXT_ycbcr_image_arrays" +EXT_provoking_vertex :: 1 +EXT_PROVOKING_VERTEX_SPEC_VERSION :: 1 +EXT_PROVOKING_VERTEX_EXTENSION_NAME :: "VK_EXT_provoking_vertex" +EXT_headless_surface :: 1 +EXT_HEADLESS_SURFACE_SPEC_VERSION :: 1 +EXT_HEADLESS_SURFACE_EXTENSION_NAME :: "VK_EXT_headless_surface" +EXT_line_rasterization :: 1 +EXT_LINE_RASTERIZATION_SPEC_VERSION :: 1 +EXT_LINE_RASTERIZATION_EXTENSION_NAME :: "VK_EXT_line_rasterization" +EXT_shader_atomic_float :: 1 +EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: 1 +EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: "VK_EXT_shader_atomic_float" +EXT_host_query_reset :: 1 +EXT_HOST_QUERY_RESET_SPEC_VERSION :: 1 +EXT_HOST_QUERY_RESET_EXTENSION_NAME :: "VK_EXT_host_query_reset" +EXT_index_type_uint8 :: 1 +EXT_INDEX_TYPE_UINT8_SPEC_VERSION :: 1 +EXT_INDEX_TYPE_UINT8_EXTENSION_NAME :: "VK_EXT_index_type_uint8" +EXT_extended_dynamic_state :: 1 +EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION :: 1 +EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state" +EXT_shader_atomic_float2 :: 1 +EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION :: 1 +EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME :: "VK_EXT_shader_atomic_float2" +EXT_surface_maintenance1 :: 1 +EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION :: 1 +EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME :: "VK_EXT_surface_maintenance1" +EXT_swapchain_maintenance1 :: 1 +EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION :: 1 +EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME :: "VK_EXT_swapchain_maintenance1" +EXT_shader_demote_to_helper_invocation :: 1 +EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION :: 1 +EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME :: "VK_EXT_shader_demote_to_helper_invocation" +NV_device_generated_commands :: 1 +NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION :: 3 +NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME :: "VK_NV_device_generated_commands" +NV_inherited_viewport_scissor :: 1 +NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION :: 1 +NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME :: "VK_NV_inherited_viewport_scissor" +EXT_texel_buffer_alignment :: 1 +EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION :: 1 +EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME :: "VK_EXT_texel_buffer_alignment" +EXT_device_memory_report :: 1 +EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION :: 2 +EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME :: "VK_EXT_device_memory_report" +EXT_acquire_drm_display :: 1 +EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION :: 1 +EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME :: "VK_EXT_acquire_drm_display" +EXT_robustness2 :: 1 +EXT_ROBUSTNESS_2_SPEC_VERSION :: 1 +EXT_ROBUSTNESS_2_EXTENSION_NAME :: "VK_EXT_robustness2" +EXT_custom_border_color :: 1 +EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION :: 12 +EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME :: "VK_EXT_custom_border_color" +GOOGLE_user_type :: 1 +GOOGLE_USER_TYPE_SPEC_VERSION :: 1 +GOOGLE_USER_TYPE_EXTENSION_NAME :: "VK_GOOGLE_user_type" +NV_present_barrier :: 1 +NV_PRESENT_BARRIER_SPEC_VERSION :: 1 +NV_PRESENT_BARRIER_EXTENSION_NAME :: "VK_NV_present_barrier" +EXT_private_data :: 1 +EXT_PRIVATE_DATA_SPEC_VERSION :: 1 +EXT_PRIVATE_DATA_EXTENSION_NAME :: "VK_EXT_private_data" +EXT_pipeline_creation_cache_control :: 1 +EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION :: 3 +EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME :: "VK_EXT_pipeline_creation_cache_control" +NV_device_diagnostics_config :: 1 +NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION :: 2 +NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME :: "VK_NV_device_diagnostics_config" +NV_low_latency :: 1 +NV_LOW_LATENCY_SPEC_VERSION :: 1 +NV_LOW_LATENCY_EXTENSION_NAME :: "VK_NV_low_latency" +EXT_descriptor_buffer :: 1 +EXT_DESCRIPTOR_BUFFER_SPEC_VERSION :: 1 +EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME :: "VK_EXT_descriptor_buffer" +EXT_graphics_pipeline_library :: 1 +EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION :: 1 +EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME :: "VK_EXT_graphics_pipeline_library" +AMD_shader_early_and_late_fragment_tests :: 1 +AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION :: 1 +AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME :: "VK_AMD_shader_early_and_late_fragment_tests" +NV_fragment_shading_rate_enums :: 1 +NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION :: 1 +NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME :: "VK_NV_fragment_shading_rate_enums" +NV_ray_tracing_motion_blur :: 1 +NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: 1 +NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: "VK_NV_ray_tracing_motion_blur" +EXT_ycbcr_2plane_444_formats :: 1 +EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION :: 1 +EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME :: "VK_EXT_ycbcr_2plane_444_formats" +EXT_fragment_density_map2 :: 1 +EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION :: 1 +EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME :: "VK_EXT_fragment_density_map2" +EXT_image_robustness :: 1 +EXT_IMAGE_ROBUSTNESS_SPEC_VERSION :: 1 +EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME :: "VK_EXT_image_robustness" +EXT_image_compression_control :: 1 +EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION :: 1 +EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME :: "VK_EXT_image_compression_control" +EXT_attachment_feedback_loop_layout :: 1 +EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION :: 2 +EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME :: "VK_EXT_attachment_feedback_loop_layout" +EXT_4444_formats :: 1 +EXT_4444_FORMATS_SPEC_VERSION :: 1 +EXT_4444_FORMATS_EXTENSION_NAME :: "VK_EXT_4444_formats" +EXT_device_fault :: 1 +EXT_DEVICE_FAULT_SPEC_VERSION :: 2 +EXT_DEVICE_FAULT_EXTENSION_NAME :: "VK_EXT_device_fault" +EXT_rgba10x6_formats :: 1 +EXT_RGBA10X6_FORMATS_SPEC_VERSION :: 1 +EXT_RGBA10X6_FORMATS_EXTENSION_NAME :: "VK_EXT_rgba10x6_formats" +EXT_vertex_input_dynamic_state :: 1 +EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION :: 2 +EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_vertex_input_dynamic_state" +EXT_physical_device_drm :: 1 +EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION :: 1 +EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME :: "VK_EXT_physical_device_drm" +EXT_device_address_binding_report :: 1 +EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION :: 1 +EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME :: "VK_EXT_device_address_binding_report" +EXT_depth_clip_control :: 1 +EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION :: 1 +EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME :: "VK_EXT_depth_clip_control" +EXT_primitive_topology_list_restart :: 1 +EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION :: 1 +EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME :: "VK_EXT_primitive_topology_list_restart" +NV_external_memory_rdma :: 1 +NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION :: 1 +NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME :: "VK_NV_external_memory_rdma" +EXT_pipeline_properties :: 1 +EXT_PIPELINE_PROPERTIES_SPEC_VERSION :: 1 +EXT_PIPELINE_PROPERTIES_EXTENSION_NAME :: "VK_EXT_pipeline_properties" +EXT_multisampled_render_to_single_sampled :: 1 +EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION :: 1 +EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME :: "VK_EXT_multisampled_render_to_single_sampled" +EXT_extended_dynamic_state2 :: 1 +EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION :: 1 +EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state2" +EXT_color_write_enable :: 1 +EXT_COLOR_WRITE_ENABLE_SPEC_VERSION :: 1 +EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME :: "VK_EXT_color_write_enable" +EXT_primitives_generated_query :: 1 +EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION :: 1 +EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME :: "VK_EXT_primitives_generated_query" +EXT_global_priority_query :: 1 +EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION :: 1 +EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME :: "VK_EXT_global_priority_query" +EXT_image_view_min_lod :: 1 +EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION :: 1 +EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME :: "VK_EXT_image_view_min_lod" +EXT_multi_draw :: 1 +EXT_MULTI_DRAW_SPEC_VERSION :: 1 +EXT_MULTI_DRAW_EXTENSION_NAME :: "VK_EXT_multi_draw" +EXT_image_2d_view_of_3d :: 1 +EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION :: 1 +EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME :: "VK_EXT_image_2d_view_of_3d" +EXT_shader_tile_image :: 1 +EXT_SHADER_TILE_IMAGE_SPEC_VERSION :: 1 +EXT_SHADER_TILE_IMAGE_EXTENSION_NAME :: "VK_EXT_shader_tile_image" +EXT_opacity_micromap :: 1 +EXT_OPACITY_MICROMAP_SPEC_VERSION :: 2 +EXT_OPACITY_MICROMAP_EXTENSION_NAME :: "VK_EXT_opacity_micromap" +EXT_load_store_op_none :: 1 +EXT_LOAD_STORE_OP_NONE_SPEC_VERSION :: 1 +EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME :: "VK_EXT_load_store_op_none" +EXT_border_color_swizzle :: 1 +EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION :: 1 +EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME :: "VK_EXT_border_color_swizzle" +EXT_pageable_device_local_memory :: 1 +EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION :: 1 +EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME :: "VK_EXT_pageable_device_local_memory" +EXT_image_sliced_view_of_3d :: 1 +EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION :: 1 +EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME :: "VK_EXT_image_sliced_view_of_3d" +EXT_depth_clamp_zero_one :: 1 +EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION :: 1 +EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME :: "VK_EXT_depth_clamp_zero_one" +EXT_non_seamless_cube_map :: 1 +EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION :: 1 +EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME :: "VK_EXT_non_seamless_cube_map" +NV_copy_memory_indirect :: 1 +NV_COPY_MEMORY_INDIRECT_SPEC_VERSION :: 1 +NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME :: "VK_NV_copy_memory_indirect" +NV_memory_decompression :: 1 +NV_MEMORY_DECOMPRESSION_SPEC_VERSION :: 1 +NV_MEMORY_DECOMPRESSION_EXTENSION_NAME :: "VK_NV_memory_decompression" +NV_linear_color_attachment :: 1 +NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION :: 1 +NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME :: "VK_NV_linear_color_attachment" +GOOGLE_surfaceless_query :: 1 +GOOGLE_SURFACELESS_QUERY_SPEC_VERSION :: 2 +GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME :: "VK_GOOGLE_surfaceless_query" +EXT_image_compression_control_swapchain :: 1 +EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION :: 1 +EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME :: "VK_EXT_image_compression_control_swapchain" +EXT_extended_dynamic_state3 :: 1 +EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION :: 2 +EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME :: "VK_EXT_extended_dynamic_state3" +EXT_subpass_merge_feedback :: 1 +EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION :: 2 +EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME :: "VK_EXT_subpass_merge_feedback" +EXT_shader_module_identifier :: 1 +EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION :: 1 +EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME :: "VK_EXT_shader_module_identifier" +EXT_rasterization_order_attachment_access :: 1 +EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION :: 1 +EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME :: "VK_EXT_rasterization_order_attachment_access" +NV_optical_flow :: 1 +NV_OPTICAL_FLOW_SPEC_VERSION :: 1 +NV_OPTICAL_FLOW_EXTENSION_NAME :: "VK_NV_optical_flow" +EXT_legacy_dithering :: 1 +EXT_LEGACY_DITHERING_SPEC_VERSION :: 1 +EXT_LEGACY_DITHERING_EXTENSION_NAME :: "VK_EXT_legacy_dithering" +EXT_pipeline_protected_access :: 1 +EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION :: 1 +EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME :: "VK_EXT_pipeline_protected_access" +EXT_shader_object :: 1 +EXT_SHADER_OBJECT_SPEC_VERSION :: 1 +EXT_SHADER_OBJECT_EXTENSION_NAME :: "VK_EXT_shader_object" +NV_ray_tracing_invocation_reorder :: 1 +NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION :: 1 +NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME :: "VK_NV_ray_tracing_invocation_reorder" +EXT_mutable_descriptor_type :: 1 +EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION :: 1 +EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME :: "VK_EXT_mutable_descriptor_type" +EXT_pipeline_library_group_handles :: 1 +EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION :: 1 +EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME :: "VK_EXT_pipeline_library_group_handles" +EXT_attachment_feedback_loop_dynamic_state :: 1 +EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION :: 1 +EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME :: "VK_EXT_attachment_feedback_loop_dynamic_state" +KHR_acceleration_structure :: 1 +KHR_ACCELERATION_STRUCTURE_SPEC_VERSION :: 13 +KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME :: "VK_KHR_acceleration_structure" +KHR_ray_tracing_pipeline :: 1 +KHR_RAY_TRACING_PIPELINE_SPEC_VERSION :: 1 +KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME :: "VK_KHR_ray_tracing_pipeline" +KHR_ray_query :: 1 +KHR_RAY_QUERY_SPEC_VERSION :: 1 +KHR_RAY_QUERY_EXTENSION_NAME :: "VK_KHR_ray_query" +EXT_mesh_shader :: 1 +EXT_MESH_SHADER_SPEC_VERSION :: 1 +EXT_MESH_SHADER_EXTENSION_NAME :: "VK_EXT_mesh_shader" +KHR_win32_surface :: 1 +KHR_WIN32_SURFACE_SPEC_VERSION :: 6 +KHR_WIN32_SURFACE_EXTENSION_NAME :: "VK_KHR_win32_surface" +KHR_external_memory_win32 :: 1 +KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1 +KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_KHR_external_memory_win32" +KHR_win32_keyed_mutex :: 1 +KHR_WIN32_KEYED_MUTEX_SPEC_VERSION :: 1 +KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_KHR_win32_keyed_mutex" +KHR_external_semaphore_win32 :: 1 +KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION :: 1 +KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME :: "VK_KHR_external_semaphore_win32" +KHR_external_fence_win32 :: 1 +KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION :: 1 +KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME :: "VK_KHR_external_fence_win32" +NV_external_memory_win32 :: 1 +NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION :: 1 +NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME :: "VK_NV_external_memory_win32" +NV_win32_keyed_mutex :: 1 +NV_WIN32_KEYED_MUTEX_SPEC_VERSION :: 2 +NV_WIN32_KEYED_MUTEX_EXTENSION_NAME :: "VK_NV_win32_keyed_mutex" +EXT_full_screen_exclusive :: 1 +EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION :: 4 +EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME :: "VK_EXT_full_screen_exclusive" +NV_acquire_winrt_display :: 1 +NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION :: 1 +NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME :: "VK_NV_acquire_winrt_display" +EXT_metal_surface :: 1 +EXT_METAL_SURFACE_SPEC_VERSION :: 1 +EXT_METAL_SURFACE_EXTENSION_NAME :: "VK_EXT_metal_surface" +EXT_metal_objects :: 1 +EXT_METAL_OBJECTS_SPEC_VERSION :: 1 +EXT_METAL_OBJECTS_EXTENSION_NAME :: "VK_EXT_metal_objects" +KHR_wayland_surface :: 1 +KHR_WAYLAND_SURFACE_SPEC_VERSION :: 6 +KHR_WAYLAND_SURFACE_EXTENSION_NAME :: "VK_KHR_wayland_surface" // Handles types Instance :: distinct Handle @@ -823,6 +986,8 @@ SurfaceKHR :: distinct NonDispatchableHandle SwapchainKHR :: distinct NonDispatchableHandle DisplayKHR :: distinct NonDispatchableHandle DisplayModeKHR :: distinct NonDispatchableHandle +VideoSessionKHR :: distinct NonDispatchableHandle +VideoSessionParametersKHR :: distinct NonDispatchableHandle DeferredOperationKHR :: distinct NonDispatchableHandle DebugReportCallbackEXT :: distinct NonDispatchableHandle CuModuleNVX :: distinct NonDispatchableHandle @@ -833,5 +998,8 @@ AccelerationStructureNV :: distinct NonDispatchableHandle PerformanceConfigurationINTEL :: distinct NonDispatchableHandle IndirectCommandsLayoutNV :: distinct NonDispatchableHandle AccelerationStructureKHR :: distinct NonDispatchableHandle +MicromapEXT :: distinct NonDispatchableHandle +OpticalFlowSessionNV :: distinct NonDispatchableHandle +ShaderEXT :: distinct NonDispatchableHandle diff --git a/vendor/vulkan/enums.odin b/vendor/vulkan/enums.odin index 9360a1e3e..8efcf541c 100644 --- a/vendor/vulkan/enums.odin +++ b/vendor/vulkan/enums.odin @@ -19,8 +19,9 @@ AccelerationStructureCompatibilityKHR :: enum c.int { AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags] AccelerationStructureCreateFlagKHR :: enum Flags { - DEVICE_ADDRESS_CAPTURE_REPLAY = 0, - MOTION_NV = 2, + DEVICE_ADDRESS_CAPTURE_REPLAY = 0, + DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 3, + MOTION_NV = 2, } AccelerationStructureMemoryRequirementsTypeNV :: enum c.int { @@ -198,13 +199,14 @@ BorderColor :: enum c.int { BufferCreateFlags :: distinct bit_set[BufferCreateFlag; Flags] BufferCreateFlag :: enum Flags { - SPARSE_BINDING = 0, - SPARSE_RESIDENCY = 1, - SPARSE_ALIASED = 2, - PROTECTED = 3, - DEVICE_ADDRESS_CAPTURE_REPLAY = 4, - DEVICE_ADDRESS_CAPTURE_REPLAY_EXT = DEVICE_ADDRESS_CAPTURE_REPLAY, - DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY, + SPARSE_BINDING = 0, + SPARSE_RESIDENCY = 1, + SPARSE_ALIASED = 2, + PROTECTED = 3, + DEVICE_ADDRESS_CAPTURE_REPLAY = 4, + DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 5, + DEVICE_ADDRESS_CAPTURE_REPLAY_EXT = DEVICE_ADDRESS_CAPTURE_REPLAY, + DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = DEVICE_ADDRESS_CAPTURE_REPLAY, } BufferUsageFlags :: distinct bit_set[BufferUsageFlag; Flags] @@ -229,6 +231,11 @@ BufferUsageFlag :: enum Flags { SHADER_BINDING_TABLE_KHR = 10, VIDEO_ENCODE_DST_KHR = 15, VIDEO_ENCODE_SRC_KHR = 16, + SAMPLER_DESCRIPTOR_BUFFER_EXT = 21, + RESOURCE_DESCRIPTOR_BUFFER_EXT = 22, + PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT = 26, + MICROMAP_BUILD_INPUT_READ_ONLY_EXT = 23, + MICROMAP_STORAGE_EXT = 24, RAY_TRACING_NV = SHADER_BINDING_TABLE_KHR, SHADER_DEVICE_ADDRESS_EXT = SHADER_DEVICE_ADDRESS, SHADER_DEVICE_ADDRESS_KHR = SHADER_DEVICE_ADDRESS, @@ -236,17 +243,22 @@ BufferUsageFlag :: enum Flags { BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags] BuildAccelerationStructureFlagKHR :: enum Flags { - ALLOW_UPDATE = 0, - ALLOW_COMPACTION = 1, - PREFER_FAST_TRACE = 2, - PREFER_FAST_BUILD = 3, - LOW_MEMORY = 4, - MOTION_NV = 5, - ALLOW_UPDATE_NV = ALLOW_UPDATE, - ALLOW_COMPACTION_NV = ALLOW_COMPACTION, - PREFER_FAST_TRACE_NV = PREFER_FAST_TRACE, - PREFER_FAST_BUILD_NV = PREFER_FAST_BUILD, - LOW_MEMORY_NV = LOW_MEMORY, + ALLOW_UPDATE = 0, + ALLOW_COMPACTION = 1, + PREFER_FAST_TRACE = 2, + PREFER_FAST_BUILD = 3, + LOW_MEMORY = 4, + MOTION_NV = 5, + ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 6, + ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 7, + ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 8, + ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = 9, + ALLOW_DATA_ACCESS = 11, + ALLOW_UPDATE_NV = ALLOW_UPDATE, + ALLOW_COMPACTION_NV = ALLOW_COMPACTION, + PREFER_FAST_TRACE_NV = PREFER_FAST_TRACE, + PREFER_FAST_BUILD_NV = PREFER_FAST_BUILD, + LOW_MEMORY_NV = LOW_MEMORY, } BuildAccelerationStructureModeKHR :: enum c.int { @@ -254,6 +266,17 @@ BuildAccelerationStructureModeKHR :: enum c.int { UPDATE = 1, } +BuildMicromapFlagsEXT :: distinct bit_set[BuildMicromapFlagEXT; Flags] +BuildMicromapFlagEXT :: enum Flags { + PREFER_FAST_TRACE = 0, + PREFER_FAST_BUILD = 1, + ALLOW_COMPACTION = 2, +} + +BuildMicromapModeEXT :: enum c.int { + BUILD = 0, +} + ChromaLocation :: enum c.int { COSITED_EVEN = 0, MIDPOINT = 1, @@ -389,6 +412,13 @@ CopyAccelerationStructureModeKHR :: enum c.int { COMPACT_NV = COMPACT, } +CopyMicromapModeEXT :: enum c.int { + CLONE = 0, + SERIALIZE = 1, + DESERIALIZE = 2, + COMPACT = 3, +} + CoverageModulationModeNV :: enum c.int { NONE = 0, RGB = 1, @@ -476,18 +506,20 @@ DebugUtilsMessageSeverityFlagEXT :: enum Flags { DebugUtilsMessageTypeFlagsEXT :: distinct bit_set[DebugUtilsMessageTypeFlagEXT; Flags] DebugUtilsMessageTypeFlagEXT :: enum Flags { - GENERAL = 0, - VALIDATION = 1, - PERFORMANCE = 2, + GENERAL = 0, + VALIDATION = 1, + PERFORMANCE = 2, + DEVICE_ADDRESS_BINDING = 3, } DependencyFlags :: distinct bit_set[DependencyFlag; Flags] DependencyFlag :: enum Flags { - BY_REGION = 0, - DEVICE_GROUP = 2, - VIEW_LOCAL = 1, - VIEW_LOCAL_KHR = VIEW_LOCAL, - DEVICE_GROUP_KHR = DEVICE_GROUP, + BY_REGION = 0, + DEVICE_GROUP = 2, + VIEW_LOCAL = 1, + FEEDBACK_LOOP_EXT = 3, + VIEW_LOCAL_KHR = VIEW_LOCAL, + DEVICE_GROUP_KHR = DEVICE_GROUP, } DescriptorBindingFlags :: distinct bit_set[DescriptorBindingFlag; Flags] @@ -506,16 +538,20 @@ DescriptorPoolCreateFlags :: distinct bit_set[DescriptorPoolCreateFlag; Flags] DescriptorPoolCreateFlag :: enum Flags { FREE_DESCRIPTOR_SET = 0, UPDATE_AFTER_BIND = 1, - HOST_ONLY_VALVE = 2, + HOST_ONLY_EXT = 2, UPDATE_AFTER_BIND_EXT = UPDATE_AFTER_BIND, + HOST_ONLY_VALVE = HOST_ONLY_EXT, } DescriptorSetLayoutCreateFlags :: distinct bit_set[DescriptorSetLayoutCreateFlag; Flags] DescriptorSetLayoutCreateFlag :: enum Flags { - UPDATE_AFTER_BIND_POOL = 1, - PUSH_DESCRIPTOR_KHR = 0, - HOST_ONLY_POOL_VALVE = 2, - UPDATE_AFTER_BIND_POOL_EXT = UPDATE_AFTER_BIND_POOL, + UPDATE_AFTER_BIND_POOL = 1, + PUSH_DESCRIPTOR_KHR = 0, + DESCRIPTOR_BUFFER_EXT = 4, + EMBEDDED_IMMUTABLE_SAMPLERS_EXT = 5, + HOST_ONLY_POOL_EXT = 2, + UPDATE_AFTER_BIND_POOL_EXT = UPDATE_AFTER_BIND_POOL, + HOST_ONLY_POOL_VALVE = HOST_ONLY_POOL_EXT, } DescriptorType :: enum c.int { @@ -533,8 +569,11 @@ DescriptorType :: enum c.int { INLINE_UNIFORM_BLOCK = 1000138000, ACCELERATION_STRUCTURE_KHR = 1000150000, ACCELERATION_STRUCTURE_NV = 1000165000, - MUTABLE_VALVE = 1000351000, + SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + BLOCK_MATCH_IMAGE_QCOM = 1000440001, + MUTABLE_EXT = 1000351000, INLINE_UNIFORM_BLOCK_EXT = INLINE_UNIFORM_BLOCK, + MUTABLE_VALVE = MUTABLE_EXT, } DescriptorUpdateTemplateType :: enum c.int { @@ -543,17 +582,42 @@ DescriptorUpdateTemplateType :: enum c.int { DESCRIPTOR_SET_KHR = DESCRIPTOR_SET, } +DeviceAddressBindingFlagsEXT :: distinct bit_set[DeviceAddressBindingFlagEXT; Flags] +DeviceAddressBindingFlagEXT :: enum Flags { + INTERNAL_OBJECT = 0, +} + +DeviceAddressBindingTypeEXT :: enum c.int { + BIND = 0, + UNBIND = 1, +} + DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags] DeviceDiagnosticsConfigFlagNV :: enum Flags { - ENABLE_SHADER_DEBUG_INFO = 0, - ENABLE_RESOURCE_TRACKING = 1, - ENABLE_AUTOMATIC_CHECKPOINTS = 2, + ENABLE_SHADER_DEBUG_INFO = 0, + ENABLE_RESOURCE_TRACKING = 1, + ENABLE_AUTOMATIC_CHECKPOINTS = 2, + ENABLE_SHADER_ERROR_REPORTING = 3, } DeviceEventTypeEXT :: enum c.int { DISPLAY_HOTPLUG = 0, } +DeviceFaultAddressTypeEXT :: enum c.int { + NONE = 0, + READ_INVALID = 1, + WRITE_INVALID = 2, + EXECUTE_INVALID = 3, + INSTRUCTION_POINTER_UNKNOWN = 4, + INSTRUCTION_POINTER_INVALID = 5, + INSTRUCTION_POINTER_FAULT = 6, +} + +DeviceFaultVendorBinaryHeaderVersionEXT :: enum c.int { + ONE = 1, +} + DeviceGroupPresentModeFlagsKHR :: distinct bit_set[DeviceGroupPresentModeFlagKHR; Flags] DeviceGroupPresentModeFlagKHR :: enum Flags { LOCAL = 0, @@ -575,6 +639,11 @@ DeviceQueueCreateFlag :: enum Flags { PROTECTED = 0, } +DirectDriverLoadingModeLUNARG :: enum c.int { + DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, +} + DiscardRectangleModeEXT :: enum c.int { INCLUSIVE = 0, EXCLUSIVE = 1, @@ -621,6 +690,9 @@ DriverId :: enum c.int { MESA_PANVK = 20, SAMSUNG_PROPRIETARY = 21, MESA_VENUS = 22, + MESA_DOZEN = 23, + MESA_NVK = 24, + IMAGINATION_OPEN_SOURCE_MESA = 25, AMD_PROPRIETARY_KHR = AMD_PROPRIETARY, AMD_OPEN_SOURCE_KHR = AMD_OPEN_SOURCE, MESA_RADV_KHR = MESA_RADV, @@ -636,58 +708,93 @@ DriverId :: enum c.int { } DynamicState :: enum c.int { - VIEWPORT = 0, - SCISSOR = 1, - LINE_WIDTH = 2, - DEPTH_BIAS = 3, - BLEND_CONSTANTS = 4, - DEPTH_BOUNDS = 5, - STENCIL_COMPARE_MASK = 6, - STENCIL_WRITE_MASK = 7, - STENCIL_REFERENCE = 8, - CULL_MODE = 1000267000, - FRONT_FACE = 1000267001, - PRIMITIVE_TOPOLOGY = 1000267002, - VIEWPORT_WITH_COUNT = 1000267003, - SCISSOR_WITH_COUNT = 1000267004, - VERTEX_INPUT_BINDING_STRIDE = 1000267005, - DEPTH_TEST_ENABLE = 1000267006, - DEPTH_WRITE_ENABLE = 1000267007, - DEPTH_COMPARE_OP = 1000267008, - DEPTH_BOUNDS_TEST_ENABLE = 1000267009, - STENCIL_TEST_ENABLE = 1000267010, - STENCIL_OP = 1000267011, - RASTERIZER_DISCARD_ENABLE = 1000377001, - DEPTH_BIAS_ENABLE = 1000377002, - PRIMITIVE_RESTART_ENABLE = 1000377004, - VIEWPORT_W_SCALING_NV = 1000087000, - DISCARD_RECTANGLE_EXT = 1000099000, - SAMPLE_LOCATIONS_EXT = 1000143000, - RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, - VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, - VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, - EXCLUSIVE_SCISSOR_NV = 1000205001, - FRAGMENT_SHADING_RATE_KHR = 1000226000, - LINE_STIPPLE_EXT = 1000259000, - VERTEX_INPUT_EXT = 1000352000, - PATCH_CONTROL_POINTS_EXT = 1000377000, - LOGIC_OP_EXT = 1000377003, - COLOR_WRITE_ENABLE_EXT = 1000381000, - CULL_MODE_EXT = CULL_MODE, - FRONT_FACE_EXT = FRONT_FACE, - PRIMITIVE_TOPOLOGY_EXT = PRIMITIVE_TOPOLOGY, - VIEWPORT_WITH_COUNT_EXT = VIEWPORT_WITH_COUNT, - SCISSOR_WITH_COUNT_EXT = SCISSOR_WITH_COUNT, - VERTEX_INPUT_BINDING_STRIDE_EXT = VERTEX_INPUT_BINDING_STRIDE, - DEPTH_TEST_ENABLE_EXT = DEPTH_TEST_ENABLE, - DEPTH_WRITE_ENABLE_EXT = DEPTH_WRITE_ENABLE, - DEPTH_COMPARE_OP_EXT = DEPTH_COMPARE_OP, - DEPTH_BOUNDS_TEST_ENABLE_EXT = DEPTH_BOUNDS_TEST_ENABLE, - STENCIL_TEST_ENABLE_EXT = STENCIL_TEST_ENABLE, - STENCIL_OP_EXT = STENCIL_OP, - RASTERIZER_DISCARD_ENABLE_EXT = RASTERIZER_DISCARD_ENABLE, - DEPTH_BIAS_ENABLE_EXT = DEPTH_BIAS_ENABLE, - PRIMITIVE_RESTART_ENABLE_EXT = PRIMITIVE_RESTART_ENABLE, + VIEWPORT = 0, + SCISSOR = 1, + LINE_WIDTH = 2, + DEPTH_BIAS = 3, + BLEND_CONSTANTS = 4, + DEPTH_BOUNDS = 5, + STENCIL_COMPARE_MASK = 6, + STENCIL_WRITE_MASK = 7, + STENCIL_REFERENCE = 8, + CULL_MODE = 1000267000, + FRONT_FACE = 1000267001, + PRIMITIVE_TOPOLOGY = 1000267002, + VIEWPORT_WITH_COUNT = 1000267003, + SCISSOR_WITH_COUNT = 1000267004, + VERTEX_INPUT_BINDING_STRIDE = 1000267005, + DEPTH_TEST_ENABLE = 1000267006, + DEPTH_WRITE_ENABLE = 1000267007, + DEPTH_COMPARE_OP = 1000267008, + DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + STENCIL_TEST_ENABLE = 1000267010, + STENCIL_OP = 1000267011, + RASTERIZER_DISCARD_ENABLE = 1000377001, + DEPTH_BIAS_ENABLE = 1000377002, + PRIMITIVE_RESTART_ENABLE = 1000377004, + VIEWPORT_W_SCALING_NV = 1000087000, + DISCARD_RECTANGLE_EXT = 1000099000, + DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + DISCARD_RECTANGLE_MODE_EXT = 1000099002, + SAMPLE_LOCATIONS_EXT = 1000143000, + RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, + EXCLUSIVE_SCISSOR_NV = 1000205001, + FRAGMENT_SHADING_RATE_KHR = 1000226000, + LINE_STIPPLE_EXT = 1000259000, + VERTEX_INPUT_EXT = 1000352000, + PATCH_CONTROL_POINTS_EXT = 1000377000, + LOGIC_OP_EXT = 1000377003, + COLOR_WRITE_ENABLE_EXT = 1000381000, + TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + DEPTH_CLAMP_ENABLE_EXT = 1000455003, + POLYGON_MODE_EXT = 1000455004, + RASTERIZATION_SAMPLES_EXT = 1000455005, + SAMPLE_MASK_EXT = 1000455006, + ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + LOGIC_OP_ENABLE_EXT = 1000455009, + COLOR_BLEND_ENABLE_EXT = 1000455010, + COLOR_BLEND_EQUATION_EXT = 1000455011, + COLOR_WRITE_MASK_EXT = 1000455012, + RASTERIZATION_STREAM_EXT = 1000455013, + CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + DEPTH_CLIP_ENABLE_EXT = 1000455016, + SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + COLOR_BLEND_ADVANCED_EXT = 1000455018, + PROVOKING_VERTEX_MODE_EXT = 1000455019, + LINE_RASTERIZATION_MODE_EXT = 1000455020, + LINE_STIPPLE_ENABLE_EXT = 1000455021, + DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + VIEWPORT_SWIZZLE_NV = 1000455024, + COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + COVERAGE_MODULATION_MODE_NV = 1000455027, + COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + COVERAGE_MODULATION_TABLE_NV = 1000455029, + SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + COVERAGE_REDUCTION_MODE_NV = 1000455032, + ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + CULL_MODE_EXT = CULL_MODE, + FRONT_FACE_EXT = FRONT_FACE, + PRIMITIVE_TOPOLOGY_EXT = PRIMITIVE_TOPOLOGY, + VIEWPORT_WITH_COUNT_EXT = VIEWPORT_WITH_COUNT, + SCISSOR_WITH_COUNT_EXT = SCISSOR_WITH_COUNT, + VERTEX_INPUT_BINDING_STRIDE_EXT = VERTEX_INPUT_BINDING_STRIDE, + DEPTH_TEST_ENABLE_EXT = DEPTH_TEST_ENABLE, + DEPTH_WRITE_ENABLE_EXT = DEPTH_WRITE_ENABLE, + DEPTH_COMPARE_OP_EXT = DEPTH_COMPARE_OP, + DEPTH_BOUNDS_TEST_ENABLE_EXT = DEPTH_BOUNDS_TEST_ENABLE, + STENCIL_TEST_ENABLE_EXT = STENCIL_TEST_ENABLE, + STENCIL_OP_EXT = STENCIL_OP, + RASTERIZER_DISCARD_ENABLE_EXT = RASTERIZER_DISCARD_ENABLE, + DEPTH_BIAS_ENABLE_EXT = DEPTH_BIAS_ENABLE, + PRIMITIVE_RESTART_ENABLE_EXT = PRIMITIVE_RESTART_ENABLE, } EventCreateFlags :: distinct bit_set[EventCreateFlag; Flags] @@ -696,6 +803,16 @@ EventCreateFlag :: enum Flags { DEVICE_ONLY_KHR = DEVICE_ONLY, } +ExportMetalObjectTypeFlagsEXT :: distinct bit_set[ExportMetalObjectTypeFlagEXT; Flags] +ExportMetalObjectTypeFlagEXT :: enum Flags { + METAL_DEVICE = 0, + METAL_COMMAND_QUEUE = 1, + METAL_BUFFER = 2, + METAL_TEXTURE = 3, + METAL_IOSURFACE = 4, + METAL_SHARED_EVENT = 5, +} + ExternalFenceFeatureFlags :: distinct bit_set[ExternalFenceFeatureFlag; Flags] ExternalFenceFeatureFlag :: enum Flags { EXPORTABLE = 0, @@ -803,8 +920,8 @@ FenceImportFlag :: enum Flags { Filter :: enum c.int { NEAREST = 0, LINEAR = 1, - CUBIC_IMG = 1000015000, - CUBIC_EXT = CUBIC_IMG, + CUBIC_EXT = 1000015000, + CUBIC_IMG = CUBIC_EXT, } Format :: enum c.int { @@ -1055,6 +1172,7 @@ Format :: enum c.int { PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + R16G16_S10_5_NV = 1000464000, ASTC_4x4_SFLOAT_BLOCK_EXT = ASTC_4x4_SFLOAT_BLOCK, ASTC_5x4_SFLOAT_BLOCK_EXT = ASTC_5x4_SFLOAT_BLOCK, ASTC_5x5_SFLOAT_BLOCK_EXT = ASTC_5x5_SFLOAT_BLOCK, @@ -1136,14 +1254,15 @@ FormatFeatureFlag :: enum Flags { DISJOINT = 22, COSITED_CHROMA_SAMPLES = 23, SAMPLED_IMAGE_FILTER_MINMAX = 16, - SAMPLED_IMAGE_FILTER_CUBIC_IMG = 13, VIDEO_DECODE_OUTPUT_KHR = 25, VIDEO_DECODE_DPB_KHR = 26, ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR = 29, + SAMPLED_IMAGE_FILTER_CUBIC_EXT = 13, FRAGMENT_DENSITY_MAP_EXT = 24, FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = 30, VIDEO_ENCODE_INPUT_KHR = 27, VIDEO_ENCODE_DPB_KHR = 28, + SAMPLED_IMAGE_FILTER_CUBIC_IMG = SAMPLED_IMAGE_FILTER_CUBIC_EXT, TRANSFER_SRC_KHR = TRANSFER_SRC, TRANSFER_DST_KHR = TRANSFER_DST, SAMPLED_IMAGE_FILTER_MINMAX_EXT = SAMPLED_IMAGE_FILTER_MINMAX, @@ -1154,7 +1273,6 @@ FormatFeatureFlag :: enum Flags { SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR = SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE, DISJOINT_KHR = DISJOINT, COSITED_CHROMA_SAMPLES_KHR = COSITED_CHROMA_SAMPLES, - SAMPLED_IMAGE_FILTER_CUBIC_EXT = SAMPLED_IMAGE_FILTER_CUBIC_IMG, } FragmentShadingRateCombinerOpKHR :: enum c.int { @@ -1217,6 +1335,8 @@ GeometryInstanceFlagKHR :: enum Flags { TRIANGLE_FLIP_FACING = 1, FORCE_OPAQUE = 2, FORCE_NO_OPAQUE = 3, + FORCE_OPACITY_MICROMAP_2_STATE_EXT = 4, + DISABLE_OPACITY_MICROMAPS_EXT = 5, TRIANGLE_FRONT_COUNTERCLOCKWISE = TRIANGLE_FLIP_FACING, TRIANGLE_CULL_DISABLE_NV = TRIANGLE_FACING_CULL_DISABLE, TRIANGLE_FRONT_COUNTERCLOCKWISE_NV = TRIANGLE_FRONT_COUNTERCLOCKWISE, @@ -1261,31 +1381,74 @@ ImageAspectFlag :: enum Flags { ImageAspectFlags_NONE :: ImageAspectFlags{} +ImageCompressionFixedRateFlagsEXT :: distinct bit_set[ImageCompressionFixedRateFlagEXT; Flags] +ImageCompressionFixedRateFlagEXT :: enum Flags { + _1BPC = 0, + _2BPC = 1, + _3BPC = 2, + _4BPC = 3, + _5BPC = 4, + _6BPC = 5, + _7BPC = 6, + _8BPC = 7, + _9BPC = 8, + _10BPC = 9, + _11BPC = 10, + _12BPC = 11, + _13BPC = 12, + _14BPC = 13, + _15BPC = 14, + _16BPC = 15, + _17BPC = 16, + _18BPC = 17, + _19BPC = 18, + _20BPC = 19, + _21BPC = 20, + _22BPC = 21, + _23BPC = 22, + _24BPC = 23, +} + +ImageCompressionFixedRateFlagsEXT_NONE :: ImageCompressionFixedRateFlagsEXT{} + + +ImageCompressionFlagsEXT :: distinct bit_set[ImageCompressionFlagEXT; Flags] +ImageCompressionFlagEXT :: enum Flags { + FIXED_RATE_DEFAULT = 0, + FIXED_RATE_EXPLICIT = 1, + DISABLED = 2, +} + +ImageCompressionFlagsEXT_DEFAULT :: ImageCompressionFlagsEXT{} + + ImageCreateFlags :: distinct bit_set[ImageCreateFlag; Flags] ImageCreateFlag :: enum Flags { - SPARSE_BINDING = 0, - SPARSE_RESIDENCY = 1, - SPARSE_ALIASED = 2, - MUTABLE_FORMAT = 3, - CUBE_COMPATIBLE = 4, - ALIAS = 10, - SPLIT_INSTANCE_BIND_REGIONS = 6, - D2_ARRAY_COMPATIBLE = 5, - BLOCK_TEXEL_VIEW_COMPATIBLE = 7, - EXTENDED_USAGE = 8, - PROTECTED = 11, - DISJOINT = 9, - CORNER_SAMPLED_NV = 13, - SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT = 12, - SUBSAMPLED_EXT = 14, - D2_VIEW_COMPATIBLE_EXT = 17, - FRAGMENT_DENSITY_MAP_OFFSET_QCOM = 15, - SPLIT_INSTANCE_BIND_REGIONS_KHR = SPLIT_INSTANCE_BIND_REGIONS, - D2_ARRAY_COMPATIBLE_KHR = D2_ARRAY_COMPATIBLE, - BLOCK_TEXEL_VIEW_COMPATIBLE_KHR = BLOCK_TEXEL_VIEW_COMPATIBLE, - EXTENDED_USAGE_KHR = EXTENDED_USAGE, - DISJOINT_KHR = DISJOINT, - ALIAS_KHR = ALIAS, + SPARSE_BINDING = 0, + SPARSE_RESIDENCY = 1, + SPARSE_ALIASED = 2, + MUTABLE_FORMAT = 3, + CUBE_COMPATIBLE = 4, + ALIAS = 10, + SPLIT_INSTANCE_BIND_REGIONS = 6, + D2_ARRAY_COMPATIBLE = 5, + BLOCK_TEXEL_VIEW_COMPATIBLE = 7, + EXTENDED_USAGE = 8, + PROTECTED = 11, + DISJOINT = 9, + CORNER_SAMPLED_NV = 13, + SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT = 12, + SUBSAMPLED_EXT = 14, + DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 16, + MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT = 18, + D2_VIEW_COMPATIBLE_EXT = 17, + FRAGMENT_DENSITY_MAP_OFFSET_QCOM = 15, + SPLIT_INSTANCE_BIND_REGIONS_KHR = SPLIT_INSTANCE_BIND_REGIONS, + D2_ARRAY_COMPATIBLE_KHR = D2_ARRAY_COMPATIBLE, + BLOCK_TEXEL_VIEW_COMPATIBLE_KHR = BLOCK_TEXEL_VIEW_COMPATIBLE, + EXTENDED_USAGE_KHR = EXTENDED_USAGE, + DISJOINT_KHR = DISJOINT, + ALIAS_KHR = ALIAS, } ImageLayout :: enum c.int { @@ -1316,6 +1479,7 @@ ImageLayout :: enum c.int { VIDEO_ENCODE_DST_KHR = 1000299000, VIDEO_ENCODE_SRC_KHR = 1000299001, VIDEO_ENCODE_DPB_KHR = 1000299002, + ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, SHADING_RATE_OPTIMAL_NV = FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, @@ -1357,14 +1521,18 @@ ImageUsageFlag :: enum Flags { VIDEO_ENCODE_DST_KHR = 13, VIDEO_ENCODE_SRC_KHR = 14, VIDEO_ENCODE_DPB_KHR = 15, + ATTACHMENT_FEEDBACK_LOOP_EXT = 19, INVOCATION_MASK_HUAWEI = 18, + SAMPLE_WEIGHT_QCOM = 20, + SAMPLE_BLOCK_MATCH_QCOM = 21, SHADING_RATE_IMAGE_NV = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR, } ImageViewCreateFlags :: distinct bit_set[ImageViewCreateFlag; Flags] ImageViewCreateFlag :: enum Flags { - FRAGMENT_DENSITY_MAP_DYNAMIC_EXT = 0, - FRAGMENT_DENSITY_MAP_DEFERRED_EXT = 1, + FRAGMENT_DENSITY_MAP_DYNAMIC_EXT = 0, + DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 2, + FRAGMENT_DENSITY_MAP_DEFERRED_EXT = 1, } ImageViewType :: enum c.int { @@ -1393,14 +1561,15 @@ IndirectCommandsLayoutUsageFlagNV :: enum Flags { } IndirectCommandsTokenTypeNV :: enum c.int { - SHADER_GROUP = 0, - STATE_FLAGS = 1, - INDEX_BUFFER = 2, - VERTEX_BUFFER = 3, - PUSH_CONSTANT = 4, - DRAW_INDEXED = 5, - DRAW = 6, - DRAW_TASKS = 7, + SHADER_GROUP = 0, + STATE_FLAGS = 1, + INDEX_BUFFER = 2, + VERTEX_BUFFER = 3, + PUSH_CONSTANT = 4, + DRAW_INDEXED = 5, + DRAW = 6, + DRAW_TASKS = 7, + DRAW_MESH_TASKS = 1000328000, } IndirectStateFlagsNV :: distinct bit_set[IndirectStateFlagNV; Flags] @@ -1479,6 +1648,16 @@ MemoryPropertyFlag :: enum Flags { RDMA_CAPABLE_NV = 8, } +MicromapCreateFlagsEXT :: distinct bit_set[MicromapCreateFlagEXT; Flags] +MicromapCreateFlagEXT :: enum Flags { + DEVICE_ADDRESS_CAPTURE_REPLAY = 0, +} + +MicromapTypeEXT :: enum c.int { + OPACITY_MICROMAP = 0, + DISPLACEMENT_MICROMAP_NV = 1000397000, +} + ObjectType :: enum c.int { UNKNOWN = 0, INSTANCE = 1, @@ -1526,11 +1705,82 @@ ObjectType :: enum c.int { DEFERRED_OPERATION_KHR = 1000268000, INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, BUFFER_COLLECTION_FUCHSIA = 1000366000, + MICROMAP_EXT = 1000396000, + OPTICAL_FLOW_SESSION_NV = 1000464000, + SHADER_EXT = 1000482000, DESCRIPTOR_UPDATE_TEMPLATE_KHR = DESCRIPTOR_UPDATE_TEMPLATE, SAMPLER_YCBCR_CONVERSION_KHR = SAMPLER_YCBCR_CONVERSION, PRIVATE_DATA_SLOT_EXT = PRIVATE_DATA_SLOT, } +OpacityMicromapFormatEXT :: enum c.int { + _2_STATE = 1, + _4_STATE = 2, +} + +OpacityMicromapSpecialIndexEXT :: enum c.int { + FULLY_TRANSPARENT = -1, + FULLY_OPAQUE = -2, + FULLY_UNKNOWN_TRANSPARENT = -3, + FULLY_UNKNOWN_OPAQUE = -4, +} + +OpticalFlowExecuteFlagsNV :: distinct bit_set[OpticalFlowExecuteFlagNV; Flags] +OpticalFlowExecuteFlagNV :: enum Flags { + DISABLE_TEMPORAL_HINTS = 0, +} + +OpticalFlowGridSizeFlagsNV :: distinct bit_set[OpticalFlowGridSizeFlagNV; Flags] +OpticalFlowGridSizeFlagNV :: enum Flags { + _1X1 = 0, + _2X2 = 1, + _4X4 = 2, + _8X8 = 3, +} + +OpticalFlowGridSizeFlagsNV_UNKNOWN :: OpticalFlowGridSizeFlagsNV{} + + +OpticalFlowPerformanceLevelNV :: enum c.int { + UNKNOWN = 0, + SLOW = 1, + MEDIUM = 2, + FAST = 3, +} + +OpticalFlowSessionBindingPointNV :: enum c.int { + UNKNOWN = 0, + INPUT = 1, + REFERENCE = 2, + HINT = 3, + FLOW_VECTOR = 4, + BACKWARD_FLOW_VECTOR = 5, + COST = 6, + BACKWARD_COST = 7, + GLOBAL_FLOW = 8, +} + +OpticalFlowSessionCreateFlagsNV :: distinct bit_set[OpticalFlowSessionCreateFlagNV; Flags] +OpticalFlowSessionCreateFlagNV :: enum Flags { + ENABLE_HINT = 0, + ENABLE_COST = 1, + ENABLE_GLOBAL_FLOW = 2, + ALLOW_REGIONS = 3, + BOTH_DIRECTIONS = 4, +} + +OpticalFlowUsageFlagsNV :: distinct bit_set[OpticalFlowUsageFlagNV; Flags] +OpticalFlowUsageFlagNV :: enum Flags { + INPUT = 0, + OUTPUT = 1, + HINT = 2, + COST = 3, + GLOBAL_FLOW = 4, +} + +OpticalFlowUsageFlagsNV_UNKNOWN :: OpticalFlowUsageFlagsNV{} + + PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags] PeerMemoryFeatureFlag :: enum Flags { COPY_SRC = 0, @@ -1631,7 +1881,8 @@ PipelineCacheHeaderVersion :: enum c.int { PipelineColorBlendStateCreateFlags :: distinct bit_set[PipelineColorBlendStateCreateFlag; Flags] PipelineColorBlendStateCreateFlag :: enum Flags { - RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM = 0, + RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT = 0, + RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT, } PipelineCompilerControlFlagsAMD :: distinct bit_set[PipelineCompilerControlFlagAMD; Flags] @@ -1661,9 +1912,16 @@ PipelineCreateFlag :: enum Flags { CAPTURE_INTERNAL_REPRESENTATIONS_KHR = 7, INDIRECT_BINDABLE_NV = 18, LIBRARY_KHR = 11, + DESCRIPTOR_BUFFER_EXT = 29, RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT = 23, LINK_TIME_OPTIMIZATION_EXT = 10, RAY_TRACING_ALLOW_MOTION_NV = 20, + COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT = 25, + DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT = 26, + RAY_TRACING_OPACITY_MICROMAP_EXT = 24, + RAY_TRACING_DISPLACEMENT_MICROMAP_NV = 28, + NO_PROTECTED_ACCESS_EXT = 27, + PROTECTED_ACCESS_ONLY_EXT = 30, PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR, PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT = RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT, VIEW_INDEX_FROM_DEVICE_INDEX_KHR = VIEW_INDEX_FROM_DEVICE_INDEX, @@ -1684,8 +1942,10 @@ PipelineCreationFeedbackFlag :: enum Flags { PipelineDepthStencilStateCreateFlags :: distinct bit_set[PipelineDepthStencilStateCreateFlag; Flags] PipelineDepthStencilStateCreateFlag :: enum Flags { - RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM = 0, - RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM = 1, + RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT = 0, + RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT = 1, + RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT, + RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT, } PipelineExecutableStatisticFormatKHR :: enum c.int { @@ -1700,6 +1960,20 @@ PipelineLayoutCreateFlag :: enum Flags { INDEPENDENT_SETS_EXT = 1, } +PipelineRobustnessBufferBehaviorEXT :: enum c.int { + DEVICE_DEFAULT = 0, + DISABLED = 1, + ROBUST_BUFFER_ACCESS = 2, + ROBUST_BUFFER_ACCESS_2 = 3, +} + +PipelineRobustnessImageBehaviorEXT :: enum c.int { + DEVICE_DEFAULT = 0, + DISABLED = 1, + ROBUST_IMAGE_ACCESS = 2, + ROBUST_IMAGE_ACCESS_2 = 3, +} + PipelineShaderStageCreateFlags :: distinct bit_set[PipelineShaderStageCreateFlag; Flags] PipelineShaderStageCreateFlag :: enum Flags { ALLOW_VARYING_SUBGROUP_SIZE = 0, @@ -1731,14 +2005,16 @@ PipelineStageFlag :: enum Flags { CONDITIONAL_RENDERING_EXT = 18, ACCELERATION_STRUCTURE_BUILD_KHR = 25, RAY_TRACING_SHADER_KHR = 21, - TASK_SHADER_NV = 19, - MESH_SHADER_NV = 20, FRAGMENT_DENSITY_PROCESS_EXT = 23, FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = 22, COMMAND_PREPROCESS_NV = 17, + TASK_SHADER_EXT = 19, + MESH_SHADER_EXT = 20, SHADING_RATE_IMAGE_NV = FRAGMENT_SHADING_RATE_ATTACHMENT_KHR, RAY_TRACING_SHADER_NV = RAY_TRACING_SHADER_KHR, ACCELERATION_STRUCTURE_BUILD_NV = ACCELERATION_STRUCTURE_BUILD_KHR, + TASK_SHADER_NV = TASK_SHADER_EXT, + MESH_SHADER_NV = MESH_SHADER_EXT, } PipelineStageFlags_NONE :: PipelineStageFlags{} @@ -1758,6 +2034,13 @@ PolygonMode :: enum c.int { FILL_RECTANGLE_NV = 1000153000, } +PresentGravityFlagsEXT :: distinct bit_set[PresentGravityFlagEXT; Flags] +PresentGravityFlagEXT :: enum Flags { + MIN = 0, + MAX = 1, + CENTERED = 2, +} + PresentModeKHR :: enum c.int { IMMEDIATE = 0, MAILBOX = 1, @@ -1767,6 +2050,13 @@ PresentModeKHR :: enum c.int { SHARED_CONTINUOUS_REFRESH = 1000111001, } +PresentScalingFlagsEXT :: distinct bit_set[PresentScalingFlagEXT; Flags] +PresentScalingFlagEXT :: enum Flags { + ONE_TO_ONE = 0, + ASPECT_RATIO_STRETCH = 1, + STRETCH = 2, +} + PrimitiveTopology :: enum c.int { POINT_LIST = 0, LINE_LIST = 1, @@ -1804,6 +2094,9 @@ QueryPipelineStatisticFlag :: enum Flags { TESSELLATION_CONTROL_SHADER_PATCHES = 8, TESSELLATION_EVALUATION_SHADER_INVOCATIONS = 9, COMPUTE_SHADER_INVOCATIONS = 10, + TASK_SHADER_INVOCATIONS_EXT = 11, + MESH_SHADER_INVOCATIONS_EXT = 12, + CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI = 13, } QueryPoolSamplingModeINTEL :: enum c.int { @@ -1819,19 +2112,30 @@ QueryResultFlag :: enum Flags { WITH_STATUS_KHR = 4, } +QueryResultStatusKHR :: enum c.int { + ERROR = -1, + NOT_READY = 0, + COMPLETE = 1, +} + QueryType :: enum c.int { - OCCLUSION = 0, - PIPELINE_STATISTICS = 1, - TIMESTAMP = 2, - RESULT_STATUS_ONLY_KHR = 1000023000, - TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - PERFORMANCE_QUERY_KHR = 1000116000, - ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, - ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, - ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, - PERFORMANCE_QUERY_INTEL = 1000210000, - VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000, - PRIMITIVES_GENERATED_EXT = 1000382000, + OCCLUSION = 0, + PIPELINE_STATISTICS = 1, + TIMESTAMP = 2, + RESULT_STATUS_ONLY_KHR = 1000023000, + TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + PERFORMANCE_QUERY_KHR = 1000116000, + ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, + ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, + ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + PERFORMANCE_QUERY_INTEL = 1000210000, + VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, + MESH_PRIMITIVES_GENERATED_EXT = 1000328000, + PRIMITIVES_GENERATED_EXT = 1000382000, + ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + MICROMAP_COMPACTED_SIZE_EXT = 1000396001, } QueueFlags :: distinct bit_set[QueueFlag; Flags] @@ -1843,6 +2147,7 @@ QueueFlag :: enum Flags { PROTECTED = 4, VIDEO_DECODE_KHR = 5, VIDEO_ENCODE_KHR = 6, + OPTICAL_FLOW_NV = 8, } QueueGlobalPriorityKHR :: enum c.int { @@ -1861,6 +2166,11 @@ RasterizationOrderAMD :: enum c.int { RELAXED = 1, } +RayTracingInvocationReorderModeNV :: enum c.int { + NONE = 0, + REORDER = 1, +} + RayTracingShaderGroupTypeKHR :: enum c.int { GENERAL = 0, TRIANGLES_HIT_GROUP = 1, @@ -1880,6 +2190,7 @@ RenderingFlag :: enum Flags { CONTENTS_SECONDARY_COMMAND_BUFFERS = 0, SUSPENDING = 1, RESUMING = 2, + ENABLE_LEGACY_DITHERING_EXT = 3, CONTENTS_SECONDARY_COMMAND_BUFFERS_KHR = CONTENTS_SECONDARY_COMMAND_BUFFERS, SUSPENDING_KHR = SUSPENDING, RESUMING_KHR = RESUMING, @@ -1932,6 +2243,12 @@ Result :: enum c.int { ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, ERROR_VALIDATION_FAILED_EXT = -1000011001, ERROR_INVALID_SHADER_NV = -1000012000, + ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, ERROR_NOT_PERMITTED_KHR = -1000174001, ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, @@ -1939,6 +2256,9 @@ Result :: enum c.int { THREAD_DONE_KHR = 1000268001, OPERATION_DEFERRED_KHR = 1000268002, OPERATION_NOT_DEFERRED_KHR = 1000268003, + ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, + ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, ERROR_OUT_OF_POOL_MEMORY_KHR = ERROR_OUT_OF_POOL_MEMORY, ERROR_INVALID_EXTERNAL_HANDLE_KHR = ERROR_INVALID_EXTERNAL_HANDLE, ERROR_FRAGMENTATION_EXT = ERROR_FRAGMENTATION, @@ -1973,6 +2293,9 @@ SamplerCreateFlags :: distinct bit_set[SamplerCreateFlag; Flags] SamplerCreateFlag :: enum Flags { SUBSAMPLED_EXT = 0, SUBSAMPLED_COARSE_RECONSTRUCTION_EXT = 1, + DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 3, + NON_SEAMLESS_CUBE_MAP_EXT = 2, + IMAGE_PROCESSING_QCOM = 4, } SamplerMipmapMode :: enum c.int { @@ -2035,10 +2358,26 @@ SemaphoreWaitFlag :: enum Flags { ANY_KHR = ANY, } +ShaderCodeTypeEXT :: enum c.int { + BINARY = 0, + SPIRV = 1, +} + ShaderCorePropertiesFlagsAMD :: distinct bit_set[ShaderCorePropertiesFlagAMD; Flags] ShaderCorePropertiesFlagAMD :: enum Flags { } +ShaderCreateFlagsEXT :: distinct bit_set[ShaderCreateFlagEXT; Flags] +ShaderCreateFlagEXT :: enum Flags { + LINK_STAGE = 0, + ALLOW_VARYING_SUBGROUP_SIZE = 1, + REQUIRE_FULL_SUBGROUPS = 2, + NO_TASK_SHADER = 3, + DISPATCH_BASE = 4, + FRAGMENT_SHADING_RATE_ATTACHMENT = 5, + FRAGMENT_DENSITY_MAP_ATTACHMENT = 6, +} + ShaderFloatControlsIndependence :: enum c.int { _32_BIT_ONLY = 0, ALL = 1, @@ -2074,20 +2413,23 @@ ShaderStageFlag :: enum Flags { MISS_KHR = 11, INTERSECTION_KHR = 12, CALLABLE_KHR = 13, - TASK_NV = 6, - MESH_NV = 7, + TASK_EXT = 6, + MESH_EXT = 7, SUBPASS_SHADING_HUAWEI = 14, + CLUSTER_CULLING_HUAWEI = 19, RAYGEN_NV = RAYGEN_KHR, ANY_HIT_NV = ANY_HIT_KHR, CLOSEST_HIT_NV = CLOSEST_HIT_KHR, MISS_NV = MISS_KHR, INTERSECTION_NV = INTERSECTION_KHR, CALLABLE_NV = CALLABLE_KHR, + TASK_NV = TASK_EXT, + MESH_NV = MESH_EXT, _MAX = 31, // Needed for the *_ALL bit set } ShaderStageFlags_ALL_GRAPHICS :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT} -ShaderStageFlags_ALL :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT, .COMPUTE, .TASK_NV, .MESH_NV, .RAYGEN_KHR, .ANY_HIT_KHR, .CLOSEST_HIT_KHR, .MISS_KHR, .INTERSECTION_KHR, .CALLABLE_KHR, .SUBPASS_SHADING_HUAWEI, ShaderStageFlag(15), ShaderStageFlag(16), ShaderStageFlag(17), ShaderStageFlag(18), ShaderStageFlag(19), ShaderStageFlag(20), ShaderStageFlag(21), ShaderStageFlag(22), ShaderStageFlag(23), ShaderStageFlag(24), ShaderStageFlag(25), ShaderStageFlag(26), ShaderStageFlag(27), ShaderStageFlag(28), ShaderStageFlag(29), ShaderStageFlag(30)} +ShaderStageFlags_ALL :: ShaderStageFlags{.VERTEX, .TESSELLATION_CONTROL, .TESSELLATION_EVALUATION, .GEOMETRY, .FRAGMENT, .COMPUTE, .TASK_EXT, .MESH_EXT, .RAYGEN_KHR, .ANY_HIT_KHR, .CLOSEST_HIT_KHR, .MISS_KHR, .INTERSECTION_KHR, .CALLABLE_KHR, .SUBPASS_SHADING_HUAWEI, ShaderStageFlag(15), ShaderStageFlag(16), ShaderStageFlag(17), ShaderStageFlag(18), .CLUSTER_CULLING_HUAWEI, ShaderStageFlag(20), ShaderStageFlag(21), ShaderStageFlag(22), ShaderStageFlag(23), ShaderStageFlag(24), ShaderStageFlag(25), ShaderStageFlag(26), ShaderStageFlag(27), ShaderStageFlag(28), ShaderStageFlag(29), ShaderStageFlag(30)} ShadingRatePaletteEntryNV :: enum c.int { @@ -2143,809 +2485,945 @@ StencilOp :: enum c.int { } StructureType :: enum c.int { - APPLICATION_INFO = 0, - INSTANCE_CREATE_INFO = 1, - DEVICE_QUEUE_CREATE_INFO = 2, - DEVICE_CREATE_INFO = 3, - SUBMIT_INFO = 4, - MEMORY_ALLOCATE_INFO = 5, - MAPPED_MEMORY_RANGE = 6, - BIND_SPARSE_INFO = 7, - FENCE_CREATE_INFO = 8, - SEMAPHORE_CREATE_INFO = 9, - EVENT_CREATE_INFO = 10, - QUERY_POOL_CREATE_INFO = 11, - BUFFER_CREATE_INFO = 12, - BUFFER_VIEW_CREATE_INFO = 13, - IMAGE_CREATE_INFO = 14, - IMAGE_VIEW_CREATE_INFO = 15, - SHADER_MODULE_CREATE_INFO = 16, - PIPELINE_CACHE_CREATE_INFO = 17, - PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - GRAPHICS_PIPELINE_CREATE_INFO = 28, - COMPUTE_PIPELINE_CREATE_INFO = 29, - PIPELINE_LAYOUT_CREATE_INFO = 30, - SAMPLER_CREATE_INFO = 31, - DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - DESCRIPTOR_POOL_CREATE_INFO = 33, - DESCRIPTOR_SET_ALLOCATE_INFO = 34, - WRITE_DESCRIPTOR_SET = 35, - COPY_DESCRIPTOR_SET = 36, - FRAMEBUFFER_CREATE_INFO = 37, - RENDER_PASS_CREATE_INFO = 38, - COMMAND_POOL_CREATE_INFO = 39, - COMMAND_BUFFER_ALLOCATE_INFO = 40, - COMMAND_BUFFER_INHERITANCE_INFO = 41, - COMMAND_BUFFER_BEGIN_INFO = 42, - RENDER_PASS_BEGIN_INFO = 43, - BUFFER_MEMORY_BARRIER = 44, - IMAGE_MEMORY_BARRIER = 45, - MEMORY_BARRIER = 46, - LOADER_INSTANCE_CREATE_INFO = 47, - LOADER_DEVICE_CREATE_INFO = 48, - PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - BIND_BUFFER_MEMORY_INFO = 1000157000, - BIND_IMAGE_MEMORY_INFO = 1000157001, - PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - DEVICE_GROUP_SUBMIT_INFO = 1000060005, - DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - MEMORY_REQUIREMENTS_2 = 1000146003, - SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - FORMAT_PROPERTIES_2 = 1000059002, - IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, - PROTECTED_SUBMIT_INFO = 1000145000, - PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - DEVICE_QUEUE_INFO_2 = 1000145003, - SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - EXTERNAL_BUFFER_PROPERTIES = 1000071003, - PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - EXTERNAL_FENCE_PROPERTIES = 1000112001, - EXPORT_FENCE_CREATE_INFO = 1000113000, - EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, - PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, - PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, - PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, - PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, - IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, - ATTACHMENT_DESCRIPTION_2 = 1000109000, - ATTACHMENT_REFERENCE_2 = 1000109001, - SUBPASS_DESCRIPTION_2 = 1000109002, - SUBPASS_DEPENDENCY_2 = 1000109003, - RENDER_PASS_CREATE_INFO_2 = 1000109004, - SUBPASS_BEGIN_INFO = 1000109005, - SUBPASS_END_INFO = 1000109006, - PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, - PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, - PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, - PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, - PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, - DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, - PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, - PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, - DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, - DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, - PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, - SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, - PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, - IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, - PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, - SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, - PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, - PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, - FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, - FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, - RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, - PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, - PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, - PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, - ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, - ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, - PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, - PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, - SEMAPHORE_TYPE_CREATE_INFO = 1000207002, - TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, - SEMAPHORE_WAIT_INFO = 1000207004, - SEMAPHORE_SIGNAL_INFO = 1000207005, - PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, - BUFFER_DEVICE_ADDRESS_INFO = 1000244001, - BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, - MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, - DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, - PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, - PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, - PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, - PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, - PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, - PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, - PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, - DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, - PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, - PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, - MEMORY_BARRIER_2 = 1000314000, - BUFFER_MEMORY_BARRIER_2 = 1000314001, - IMAGE_MEMORY_BARRIER_2 = 1000314002, - DEPENDENCY_INFO = 1000314003, - SUBMIT_INFO_2 = 1000314004, - SEMAPHORE_SUBMIT_INFO = 1000314005, - COMMAND_BUFFER_SUBMIT_INFO = 1000314006, - PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, - PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, - PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, - COPY_BUFFER_INFO_2 = 1000337000, - COPY_IMAGE_INFO_2 = 1000337001, - COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, - COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, - BLIT_IMAGE_INFO_2 = 1000337004, - RESOLVE_IMAGE_INFO_2 = 1000337005, - BUFFER_COPY_2 = 1000337006, - IMAGE_COPY_2 = 1000337007, - IMAGE_BLIT_2 = 1000337008, - BUFFER_IMAGE_COPY_2 = 1000337009, - IMAGE_RESOLVE_2 = 1000337010, - PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, - PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, - PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, - PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, - PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, - WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, - DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, - PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, - RENDERING_INFO = 1000044000, - RENDERING_ATTACHMENT_INFO = 1000044001, - PIPELINE_RENDERING_CREATE_INFO = 1000044002, - PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, - COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, - PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, - PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, - PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, - FORMAT_PROPERTIES_3 = 1000360000, - PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, - PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, - DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, - DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, - SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - PRESENT_INFO_KHR = 1000001001, - DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - DISPLAY_PRESENT_INFO_KHR = 1000003000, - XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, - VIDEO_PROFILE_KHR = 1000023000, - VIDEO_CAPABILITIES_KHR = 1000023001, - VIDEO_PICTURE_RESOURCE_KHR = 1000023002, - VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003, - VIDEO_BIND_MEMORY_KHR = 1000023004, - VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, - VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, - VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, - VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, - VIDEO_END_CODING_INFO_KHR = 1000023009, - VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, - VIDEO_REFERENCE_SLOT_KHR = 1000023011, - VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012, - VIDEO_PROFILES_KHR = 1000023013, - PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, - VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, - QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016, - VIDEO_DECODE_INFO_KHR = 1000024000, - VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, - DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, - PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, - PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, - CU_MODULE_CREATE_INFO_NVX = 1000029000, - CU_FUNCTION_CREATE_INFO_NVX = 1000029001, - CU_LAUNCH_INFO_NVX = 1000029002, - IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, - IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, - VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000, - VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001, - VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002, - VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003, - VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, - VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038005, - VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038006, - VIDEO_ENCODE_H264_PROFILE_EXT = 1000038007, - VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008, - VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, - VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT = 1000038010, - VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, - VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001, - VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002, - VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003, - VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, - VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT = 1000039005, - VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT = 1000039006, - VIDEO_ENCODE_H265_PROFILE_EXT = 1000039007, - VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT = 1000039008, - VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009, - VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, - VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000, - VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040001, - VIDEO_DECODE_H264_MVC_EXT = 1000040002, - VIDEO_DECODE_H264_PROFILE_EXT = 1000040003, - VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040004, - VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040005, - VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040006, - TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, - RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, - ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, - MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, - STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, - PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, - EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - VALIDATION_FLAGS_EXT = 1000061000, - VI_SURFACE_CREATE_INFO_NN = 1000062000, - IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, - PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, - IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, - IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - MEMORY_FD_PROPERTIES_KHR = 1000074001, - MEMORY_GET_FD_INFO_KHR = 1000074002, - WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, - IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, - COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, - PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, - CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - PRESENT_REGIONS_KHR = 1000084000, - PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - SURFACE_CAPABILITIES_2_EXT = 1000090000, - DISPLAY_POWER_INFO_EXT = 1000091000, - DEVICE_EVENT_INFO_EXT = 1000091001, - DISPLAY_EVENT_INFO_EXT = 1000091002, - SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - PRESENT_TIMES_INFO_GOOGLE = 1000092000, - PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, - PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, - HDR_METADATA_EXT = 1000105000, - SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - IMPORT_FENCE_FD_INFO_KHR = 1000115000, - FENCE_GET_FD_INFO_KHR = 1000115001, - PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, - PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, - QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, - PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, - ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, - PERFORMANCE_COUNTER_KHR = 1000116005, - PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, - PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - SURFACE_CAPABILITIES_2_KHR = 1000119001, - SURFACE_FORMAT_2_KHR = 1000119002, - DISPLAY_PROPERTIES_2_KHR = 1000121000, - DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - DISPLAY_PLANE_INFO_2_KHR = 1000121003, - DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - DEBUG_UTILS_LABEL_EXT = 1000128002, - DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - EXTERNAL_FORMAT_ANDROID = 1000129005, - ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, - SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - MULTISAMPLE_PROPERTIES_EXT = 1000143004, - PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, - ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, - ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, - ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, - ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, - ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, - ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, - ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, - COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, - COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, - COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, - PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, - PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, - ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, - ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, - PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, - PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, - RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, - RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, - RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, - PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, - PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, - PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, - DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, - PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, - IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, - IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, - IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, - DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, - VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, - PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, - PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, - PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, - PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, - PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, - PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, - ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, - GEOMETRY_NV = 1000165003, - GEOMETRY_TRIANGLES_NV = 1000165004, - GEOMETRY_AABB_NV = 1000165005, - BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, - WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, - ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, - PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, - RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, - ACCELERATION_STRUCTURE_INFO_NV = 1000165012, - PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, - PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, - PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, - FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, - IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, - PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, - CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, - PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, - VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000, - VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187001, - VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187002, - VIDEO_DECODE_H265_PROFILE_EXT = 1000187003, - VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187004, - VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187005, - DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, - PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, - QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, - DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, - PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, - PRESENT_FRAME_TOKEN_GGP = 1000191000, - PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, - PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, - PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, - PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, - PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, - PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, - PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, - CHECKPOINT_DATA_NV = 1000206000, - QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, - QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, - INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, - PERFORMANCE_MARKER_INFO_INTEL = 1000210002, - PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, - PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, - PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, - PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, - DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, - SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, - IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, - METAL_SURFACE_CREATE_INFO_EXT = 1000217000, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, - RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, - FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, - PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, - PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, - PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, - PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, - PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, - PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, - PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, - PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, - PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, - MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, - SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, - PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, - PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, - VALIDATION_FEATURES_EXT = 1000247000, - PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, - PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, - COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, - PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, - PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, - PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, - FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, - PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, - PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, - PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, - PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, - PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, - SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, - SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, - SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, - HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, - PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, - PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, - PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, - PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, - PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, - PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, - PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, - PIPELINE_INFO_KHR = 1000269001, - PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, - PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, - PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, - PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, - PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, - PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, - GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, - GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, - INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, - INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, - GENERATED_COMMANDS_INFO_NV = 1000277005, - GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, - PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, - PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, - COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, - PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, - COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, - RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, - PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, - DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, - DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, - PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, - PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, - SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, - PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, - PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, - PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, - PRESENT_ID_KHR = 1000294000, - PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, - VIDEO_ENCODE_INFO_KHR = 1000299000, - VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, - VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, - VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, - PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, - DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, - QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, - CHECKPOINT_DATA_2_NV = 1000314009, - PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, - PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, - GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, - PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, - PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, - PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, - PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, - ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, - PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, - ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, - PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, - COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, - PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, - PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, - PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = 1000342000, - PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, - DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, - PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000, - MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002, - PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, - VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, - VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, - PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, - PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, - PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, - PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, - IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, - MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, - MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, - IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, - SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, - BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, - IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, - BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, - BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, - BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, - BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, - IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, - IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, - SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, - BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, - SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, - PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, - PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, - PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, - MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, - PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, - PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, - SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, - PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, - PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, - PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, - PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, - IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, - PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, - PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, - PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, - PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, - SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, - PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, - PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, - DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, - DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, - PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, - SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, - PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, - PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, - DEBUG_REPORT_CREATE_INFO_EXT = DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - RENDERING_INFO_KHR = RENDERING_INFO, - RENDERING_ATTACHMENT_INFO_KHR = RENDERING_ATTACHMENT_INFO, - PIPELINE_RENDERING_CREATE_INFO_KHR = PIPELINE_RENDERING_CREATE_INFO, - PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, - COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, - ATTACHMENT_SAMPLE_COUNT_INFO_NV = ATTACHMENT_SAMPLE_COUNT_INFO_AMD, - RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = RENDER_PASS_MULTIVIEW_CREATE_INFO, - PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - PHYSICAL_DEVICE_FEATURES_2_KHR = PHYSICAL_DEVICE_FEATURES_2, - PHYSICAL_DEVICE_PROPERTIES_2_KHR = PHYSICAL_DEVICE_PROPERTIES_2, - FORMAT_PROPERTIES_2_KHR = FORMAT_PROPERTIES_2, - IMAGE_FORMAT_PROPERTIES_2_KHR = IMAGE_FORMAT_PROPERTIES_2, - PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - QUEUE_FAMILY_PROPERTIES_2_KHR = QUEUE_FAMILY_PROPERTIES_2, - PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = SPARSE_IMAGE_FORMAT_PROPERTIES_2, - PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - MEMORY_ALLOCATE_FLAGS_INFO_KHR = MEMORY_ALLOCATE_FLAGS_INFO, - DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - DEVICE_GROUP_SUBMIT_INFO_KHR = DEVICE_GROUP_SUBMIT_INFO, - DEVICE_GROUP_BIND_SPARSE_INFO_KHR = DEVICE_GROUP_BIND_SPARSE_INFO, - BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, - PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = PHYSICAL_DEVICE_GROUP_PROPERTIES, - DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = DEVICE_GROUP_DEVICE_CREATE_INFO, - PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = EXTERNAL_IMAGE_FORMAT_PROPERTIES, - PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - EXTERNAL_BUFFER_PROPERTIES_KHR = EXTERNAL_BUFFER_PROPERTIES, - PHYSICAL_DEVICE_ID_PROPERTIES_KHR = PHYSICAL_DEVICE_ID_PROPERTIES, - EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - EXPORT_MEMORY_ALLOCATE_INFO_KHR = EXPORT_MEMORY_ALLOCATE_INFO, - PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - EXTERNAL_SEMAPHORE_PROPERTIES_KHR = EXTERNAL_SEMAPHORE_PROPERTIES, - EXPORT_SEMAPHORE_CREATE_INFO_KHR = EXPORT_SEMAPHORE_CREATE_INFO, - PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - SURFACE_CAPABILITIES2_EXT = SURFACE_CAPABILITIES_2_EXT, - PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, - FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, - FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, - RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = RENDER_PASS_ATTACHMENT_BEGIN_INFO, - ATTACHMENT_DESCRIPTION_2_KHR = ATTACHMENT_DESCRIPTION_2, - ATTACHMENT_REFERENCE_2_KHR = ATTACHMENT_REFERENCE_2, - SUBPASS_DESCRIPTION_2_KHR = SUBPASS_DESCRIPTION_2, - SUBPASS_DEPENDENCY_2_KHR = SUBPASS_DEPENDENCY_2, - RENDER_PASS_CREATE_INFO_2_KHR = RENDER_PASS_CREATE_INFO_2, - SUBPASS_BEGIN_INFO_KHR = SUBPASS_BEGIN_INFO, - SUBPASS_END_INFO_KHR = SUBPASS_END_INFO, - PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - EXTERNAL_FENCE_PROPERTIES_KHR = EXTERNAL_FENCE_PROPERTIES, - EXPORT_FENCE_CREATE_INFO_KHR = EXPORT_FENCE_CREATE_INFO, - PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - IMAGE_VIEW_USAGE_CREATE_INFO_KHR = IMAGE_VIEW_USAGE_CREATE_INFO, - PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, - MEMORY_DEDICATED_REQUIREMENTS_KHR = MEMORY_DEDICATED_REQUIREMENTS, - MEMORY_DEDICATED_ALLOCATE_INFO_KHR = MEMORY_DEDICATED_ALLOCATE_INFO, - PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, - SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = SAMPLER_REDUCTION_MODE_CREATE_INFO, - PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, - PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, - WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, - DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, - BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = BUFFER_MEMORY_REQUIREMENTS_INFO_2, - IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = IMAGE_MEMORY_REQUIREMENTS_INFO_2, - IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - MEMORY_REQUIREMENTS_2_KHR = MEMORY_REQUIREMENTS_2, - SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - IMAGE_FORMAT_LIST_CREATE_INFO_KHR = IMAGE_FORMAT_LIST_CREATE_INFO, - SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - SAMPLER_YCBCR_CONVERSION_INFO_KHR = SAMPLER_YCBCR_CONVERSION_INFO, - BIND_IMAGE_PLANE_MEMORY_INFO_KHR = BIND_IMAGE_PLANE_MEMORY_INFO, - IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - BIND_BUFFER_MEMORY_INFO_KHR = BIND_BUFFER_MEMORY_INFO, - BIND_IMAGE_MEMORY_INFO_KHR = BIND_IMAGE_MEMORY_INFO, - DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, - PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, - DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, - PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = DESCRIPTOR_SET_LAYOUT_SUPPORT, - DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, - PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, - PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, - PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, - PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = PIPELINE_CREATION_FEEDBACK_CREATE_INFO, - PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = PHYSICAL_DEVICE_DRIVER_PROPERTIES, - PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, - PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, - SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, - PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, - PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, - SEMAPHORE_TYPE_CREATE_INFO_KHR = SEMAPHORE_TYPE_CREATE_INFO, - TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = TIMELINE_SEMAPHORE_SUBMIT_INFO, - SEMAPHORE_WAIT_INFO_KHR = SEMAPHORE_WAIT_INFO, - SEMAPHORE_SIGNAL_INFO_KHR = SEMAPHORE_SIGNAL_INFO, - QUERY_POOL_CREATE_INFO_INTEL = QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, - PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, - PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, - PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, - PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, - PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, - PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, - ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = ATTACHMENT_REFERENCE_STENCIL_LAYOUT, - ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, - PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, - BUFFER_DEVICE_ADDRESS_INFO_EXT = BUFFER_DEVICE_ADDRESS_INFO, - PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = PHYSICAL_DEVICE_TOOL_PROPERTIES, - IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = IMAGE_STENCIL_USAGE_CREATE_INFO, - PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, - PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, - BUFFER_DEVICE_ADDRESS_INFO_KHR = BUFFER_DEVICE_ADDRESS_INFO, - BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, - MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, - DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, - PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, - PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, - PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, - PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, - PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, - PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, - DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = DEVICE_PRIVATE_DATA_CREATE_INFO, - PRIVATE_DATA_SLOT_CREATE_INFO_EXT = PRIVATE_DATA_SLOT_CREATE_INFO, - PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, - MEMORY_BARRIER_2_KHR = MEMORY_BARRIER_2, - BUFFER_MEMORY_BARRIER_2_KHR = BUFFER_MEMORY_BARRIER_2, - IMAGE_MEMORY_BARRIER_2_KHR = IMAGE_MEMORY_BARRIER_2, - DEPENDENCY_INFO_KHR = DEPENDENCY_INFO, - SUBMIT_INFO_2_KHR = SUBMIT_INFO_2, - SEMAPHORE_SUBMIT_INFO_KHR = SEMAPHORE_SUBMIT_INFO, - COMMAND_BUFFER_SUBMIT_INFO_KHR = COMMAND_BUFFER_SUBMIT_INFO, - PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, - PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, - PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, - COPY_BUFFER_INFO_2_KHR = COPY_BUFFER_INFO_2, - COPY_IMAGE_INFO_2_KHR = COPY_IMAGE_INFO_2, - COPY_BUFFER_TO_IMAGE_INFO_2_KHR = COPY_BUFFER_TO_IMAGE_INFO_2, - COPY_IMAGE_TO_BUFFER_INFO_2_KHR = COPY_IMAGE_TO_BUFFER_INFO_2, - BLIT_IMAGE_INFO_2_KHR = BLIT_IMAGE_INFO_2, - RESOLVE_IMAGE_INFO_2_KHR = RESOLVE_IMAGE_INFO_2, - BUFFER_COPY_2_KHR = BUFFER_COPY_2, - IMAGE_COPY_2_KHR = IMAGE_COPY_2, - IMAGE_BLIT_2_KHR = IMAGE_BLIT_2, - BUFFER_IMAGE_COPY_2_KHR = BUFFER_IMAGE_COPY_2, - IMAGE_RESOLVE_2_KHR = IMAGE_RESOLVE_2, - FORMAT_PROPERTIES_3_KHR = FORMAT_PROPERTIES_3, - PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, - QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, - PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, - PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, - DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = DEVICE_BUFFER_MEMORY_REQUIREMENTS, - DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = DEVICE_IMAGE_MEMORY_REQUIREMENTS, + APPLICATION_INFO = 0, + INSTANCE_CREATE_INFO = 1, + DEVICE_QUEUE_CREATE_INFO = 2, + DEVICE_CREATE_INFO = 3, + SUBMIT_INFO = 4, + MEMORY_ALLOCATE_INFO = 5, + MAPPED_MEMORY_RANGE = 6, + BIND_SPARSE_INFO = 7, + FENCE_CREATE_INFO = 8, + SEMAPHORE_CREATE_INFO = 9, + EVENT_CREATE_INFO = 10, + QUERY_POOL_CREATE_INFO = 11, + BUFFER_CREATE_INFO = 12, + BUFFER_VIEW_CREATE_INFO = 13, + IMAGE_CREATE_INFO = 14, + IMAGE_VIEW_CREATE_INFO = 15, + SHADER_MODULE_CREATE_INFO = 16, + PIPELINE_CACHE_CREATE_INFO = 17, + PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + GRAPHICS_PIPELINE_CREATE_INFO = 28, + COMPUTE_PIPELINE_CREATE_INFO = 29, + PIPELINE_LAYOUT_CREATE_INFO = 30, + SAMPLER_CREATE_INFO = 31, + DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + DESCRIPTOR_POOL_CREATE_INFO = 33, + DESCRIPTOR_SET_ALLOCATE_INFO = 34, + WRITE_DESCRIPTOR_SET = 35, + COPY_DESCRIPTOR_SET = 36, + FRAMEBUFFER_CREATE_INFO = 37, + RENDER_PASS_CREATE_INFO = 38, + COMMAND_POOL_CREATE_INFO = 39, + COMMAND_BUFFER_ALLOCATE_INFO = 40, + COMMAND_BUFFER_INHERITANCE_INFO = 41, + COMMAND_BUFFER_BEGIN_INFO = 42, + RENDER_PASS_BEGIN_INFO = 43, + BUFFER_MEMORY_BARRIER = 44, + IMAGE_MEMORY_BARRIER = 45, + MEMORY_BARRIER = 46, + LOADER_INSTANCE_CREATE_INFO = 47, + LOADER_DEVICE_CREATE_INFO = 48, + PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + BIND_BUFFER_MEMORY_INFO = 1000157000, + BIND_IMAGE_MEMORY_INFO = 1000157001, + PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + DEVICE_GROUP_SUBMIT_INFO = 1000060005, + DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + MEMORY_REQUIREMENTS_2 = 1000146003, + SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + FORMAT_PROPERTIES_2 = 1000059002, + IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + PROTECTED_SUBMIT_INFO = 1000145000, + PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + DEVICE_QUEUE_INFO_2 = 1000145003, + SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + EXTERNAL_BUFFER_PROPERTIES = 1000071003, + PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + EXTERNAL_FENCE_PROPERTIES = 1000112001, + EXPORT_FENCE_CREATE_INFO = 1000113000, + EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + ATTACHMENT_DESCRIPTION_2 = 1000109000, + ATTACHMENT_REFERENCE_2 = 1000109001, + SUBPASS_DESCRIPTION_2 = 1000109002, + SUBPASS_DEPENDENCY_2 = 1000109003, + RENDER_PASS_CREATE_INFO_2 = 1000109004, + SUBPASS_BEGIN_INFO = 1000109005, + SUBPASS_END_INFO = 1000109006, + PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + SEMAPHORE_WAIT_INFO = 1000207004, + SEMAPHORE_SIGNAL_INFO = 1000207005, + PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + MEMORY_BARRIER_2 = 1000314000, + BUFFER_MEMORY_BARRIER_2 = 1000314001, + IMAGE_MEMORY_BARRIER_2 = 1000314002, + DEPENDENCY_INFO = 1000314003, + SUBMIT_INFO_2 = 1000314004, + SEMAPHORE_SUBMIT_INFO = 1000314005, + COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + COPY_BUFFER_INFO_2 = 1000337000, + COPY_IMAGE_INFO_2 = 1000337001, + COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + BLIT_IMAGE_INFO_2 = 1000337004, + RESOLVE_IMAGE_INFO_2 = 1000337005, + BUFFER_COPY_2 = 1000337006, + IMAGE_COPY_2 = 1000337007, + IMAGE_BLIT_2 = 1000337008, + BUFFER_IMAGE_COPY_2 = 1000337009, + IMAGE_RESOLVE_2 = 1000337010, + PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + RENDERING_INFO = 1000044000, + RENDERING_ATTACHMENT_INFO = 1000044001, + PIPELINE_RENDERING_CREATE_INFO = 1000044002, + PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + FORMAT_PROPERTIES_3 = 1000360000, + PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + PRESENT_INFO_KHR = 1000001001, + DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + DISPLAY_PRESENT_INFO_KHR = 1000003000, + XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VIDEO_PROFILE_INFO_KHR = 1000023000, + VIDEO_CAPABILITIES_KHR = 1000023001, + VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, + VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, + VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, + VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, + VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, + VIDEO_END_CODING_INFO_KHR = 1000023009, + VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, + VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, + PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, + VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, + QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, + VIDEO_DECODE_INFO_KHR = 1000024000, + VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, + VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, + DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + CU_MODULE_CREATE_INFO_NVX = 1000029000, + CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + CU_LAUNCH_INFO_NVX = 1000029002, + IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, + VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000, + VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001, + VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002, + VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003, + VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, + VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005, + VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007, + VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008, + VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, + VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, + VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001, + VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002, + VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003, + VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, + VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005, + VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007, + VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009, + VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, + VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, + TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VALIDATION_FLAGS_EXT = 1000061000, + VI_SURFACE_CREATE_INFO_NN = 1000062000, + IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000, + PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001, + PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002, + IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + MEMORY_FD_PROPERTIES_KHR = 1000074001, + MEMORY_GET_FD_INFO_KHR = 1000074002, + WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + PRESENT_REGIONS_KHR = 1000084000, + PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + SURFACE_CAPABILITIES_2_EXT = 1000090000, + DISPLAY_POWER_INFO_EXT = 1000091000, + DEVICE_EVENT_INFO_EXT = 1000091001, + DISPLAY_EVENT_INFO_EXT = 1000091002, + SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + PRESENT_TIMES_INFO_GOOGLE = 1000092000, + PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + HDR_METADATA_EXT = 1000105000, + SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + IMPORT_FENCE_FD_INFO_KHR = 1000115000, + FENCE_GET_FD_INFO_KHR = 1000115001, + PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + PERFORMANCE_COUNTER_KHR = 1000116005, + PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + SURFACE_CAPABILITIES_2_KHR = 1000119001, + SURFACE_FORMAT_2_KHR = 1000119002, + DISPLAY_PROPERTIES_2_KHR = 1000121000, + DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + DISPLAY_PLANE_INFO_2_KHR = 1000121003, + DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + DEBUG_UTILS_LABEL_EXT = 1000128002, + DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + EXTERNAL_FORMAT_ANDROID = 1000129005, + ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + MULTISAMPLE_PROPERTIES_EXT = 1000143004, + PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, + PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, + PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + GEOMETRY_NV = 1000165003, + GEOMETRY_TRIANGLES_NV = 1000165004, + GEOMETRY_AABB_NV = 1000165005, + BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, + DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, + PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, + QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, + DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + PRESENT_FRAME_TOKEN_GGP = 1000191000, + PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + CHECKPOINT_DATA_NV = 1000206000, + QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VALIDATION_FEATURES_EXT = 1000247000, + PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + PIPELINE_INFO_KHR = 1000269001, + PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + MEMORY_MAP_INFO_KHR = 1000271000, + MEMORY_UNMAP_INFO_KHR = 1000271001, + PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + SURFACE_PRESENT_MODE_EXT = 1000274000, + SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, + SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, + PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, + SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, + SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, + SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, + SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, + RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, + PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + GENERATED_COMMANDS_INFO_NV = 1000277005, + GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, + PRESENT_ID_KHR = 1000294000, + PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, + VIDEO_ENCODE_INFO_KHR = 1000299000, + VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, + VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, + VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, + VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, + QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, + PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, + QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + CHECKPOINT_DATA_2_NV = 1000314009, + PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + DESCRIPTOR_GET_INFO_EXT = 1000316004, + BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, + PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, + GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, + PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, + PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + SUBRESOURCE_LAYOUT_2_EXT = 1000338002, + IMAGE_SUBRESOURCE_2_EXT = 1000338003, + IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, + PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + DEVICE_FAULT_COUNTS_EXT = 1000341001, + DEVICE_FAULT_INFO_EXT = 1000341002, + PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, + PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, + PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, + PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, + PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, + IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, + PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + MICROMAP_BUILD_INFO_EXT = 1000396000, + MICROMAP_VERSION_INFO_EXT = 1000396001, + COPY_MICROMAP_INFO_EXT = 1000396002, + COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + MICROMAP_CREATE_INFO_EXT = 1000396007, + MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, + PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, + PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, + ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, + PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, + PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, + DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, + DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, + PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, + PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, + SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, + PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001, + PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000, + PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001, + PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, + PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, + PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + SHADER_CREATE_INFO_EXT = 1000482002, + PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + TILE_PROPERTIES_QCOM = 1000484001, + PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, + PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + DEBUG_REPORT_CREATE_INFO_EXT = DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + RENDERING_INFO_KHR = RENDERING_INFO, + RENDERING_ATTACHMENT_INFO_KHR = RENDERING_ATTACHMENT_INFO, + PIPELINE_RENDERING_CREATE_INFO_KHR = PIPELINE_RENDERING_CREATE_INFO, + PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + ATTACHMENT_SAMPLE_COUNT_INFO_NV = ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = RENDER_PASS_MULTIVIEW_CREATE_INFO, + PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + PHYSICAL_DEVICE_FEATURES_2_KHR = PHYSICAL_DEVICE_FEATURES_2, + PHYSICAL_DEVICE_PROPERTIES_2_KHR = PHYSICAL_DEVICE_PROPERTIES_2, + FORMAT_PROPERTIES_2_KHR = FORMAT_PROPERTIES_2, + IMAGE_FORMAT_PROPERTIES_2_KHR = IMAGE_FORMAT_PROPERTIES_2, + PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + QUEUE_FAMILY_PROPERTIES_2_KHR = QUEUE_FAMILY_PROPERTIES_2, + PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = SPARSE_IMAGE_FORMAT_PROPERTIES_2, + PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + MEMORY_ALLOCATE_FLAGS_INFO_KHR = MEMORY_ALLOCATE_FLAGS_INFO, + DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + DEVICE_GROUP_SUBMIT_INFO_KHR = DEVICE_GROUP_SUBMIT_INFO, + DEVICE_GROUP_BIND_SPARSE_INFO_KHR = DEVICE_GROUP_BIND_SPARSE_INFO, + BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = PHYSICAL_DEVICE_GROUP_PROPERTIES, + DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = DEVICE_GROUP_DEVICE_CREATE_INFO, + PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = EXTERNAL_IMAGE_FORMAT_PROPERTIES, + PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + EXTERNAL_BUFFER_PROPERTIES_KHR = EXTERNAL_BUFFER_PROPERTIES, + PHYSICAL_DEVICE_ID_PROPERTIES_KHR = PHYSICAL_DEVICE_ID_PROPERTIES, + EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + EXPORT_MEMORY_ALLOCATE_INFO_KHR = EXPORT_MEMORY_ALLOCATE_INFO, + PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + EXTERNAL_SEMAPHORE_PROPERTIES_KHR = EXTERNAL_SEMAPHORE_PROPERTIES, + EXPORT_SEMAPHORE_CREATE_INFO_KHR = EXPORT_SEMAPHORE_CREATE_INFO, + PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + SURFACE_CAPABILITIES2_EXT = SURFACE_CAPABILITIES_2_EXT, + PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = RENDER_PASS_ATTACHMENT_BEGIN_INFO, + ATTACHMENT_DESCRIPTION_2_KHR = ATTACHMENT_DESCRIPTION_2, + ATTACHMENT_REFERENCE_2_KHR = ATTACHMENT_REFERENCE_2, + SUBPASS_DESCRIPTION_2_KHR = SUBPASS_DESCRIPTION_2, + SUBPASS_DEPENDENCY_2_KHR = SUBPASS_DEPENDENCY_2, + RENDER_PASS_CREATE_INFO_2_KHR = RENDER_PASS_CREATE_INFO_2, + SUBPASS_BEGIN_INFO_KHR = SUBPASS_BEGIN_INFO, + SUBPASS_END_INFO_KHR = SUBPASS_END_INFO, + PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + EXTERNAL_FENCE_PROPERTIES_KHR = EXTERNAL_FENCE_PROPERTIES, + EXPORT_FENCE_CREATE_INFO_KHR = EXPORT_FENCE_CREATE_INFO, + PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + IMAGE_VIEW_USAGE_CREATE_INFO_KHR = IMAGE_VIEW_USAGE_CREATE_INFO, + PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + MEMORY_DEDICATED_REQUIREMENTS_KHR = MEMORY_DEDICATED_REQUIREMENTS, + MEMORY_DEDICATED_ALLOCATE_INFO_KHR = MEMORY_DEDICATED_ALLOCATE_INFO, + PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = SAMPLER_REDUCTION_MODE_CREATE_INFO, + PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = BUFFER_MEMORY_REQUIREMENTS_INFO_2, + IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = IMAGE_MEMORY_REQUIREMENTS_INFO_2, + IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + MEMORY_REQUIREMENTS_2_KHR = MEMORY_REQUIREMENTS_2, + SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + IMAGE_FORMAT_LIST_CREATE_INFO_KHR = IMAGE_FORMAT_LIST_CREATE_INFO, + SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + SAMPLER_YCBCR_CONVERSION_INFO_KHR = SAMPLER_YCBCR_CONVERSION_INFO, + BIND_IMAGE_PLANE_MEMORY_INFO_KHR = BIND_IMAGE_PLANE_MEMORY_INFO, + IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + BIND_BUFFER_MEMORY_INFO_KHR = BIND_BUFFER_MEMORY_INFO, + BIND_IMAGE_MEMORY_INFO_KHR = BIND_IMAGE_MEMORY_INFO, + DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = DESCRIPTOR_SET_LAYOUT_SUPPORT, + DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, + PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = PHYSICAL_DEVICE_DRIVER_PROPERTIES, + PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + SEMAPHORE_TYPE_CREATE_INFO_KHR = SEMAPHORE_TYPE_CREATE_INFO, + TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = TIMELINE_SEMAPHORE_SUBMIT_INFO, + SEMAPHORE_WAIT_INFO_KHR = SEMAPHORE_WAIT_INFO, + SEMAPHORE_SIGNAL_INFO_KHR = SEMAPHORE_SIGNAL_INFO, + QUERY_POOL_CREATE_INFO_INTEL = QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + BUFFER_DEVICE_ADDRESS_INFO_EXT = BUFFER_DEVICE_ADDRESS_INFO, + PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = PHYSICAL_DEVICE_TOOL_PROPERTIES, + IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = IMAGE_STENCIL_USAGE_CREATE_INFO, + PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + BUFFER_DEVICE_ADDRESS_INFO_KHR = BUFFER_DEVICE_ADDRESS_INFO, + BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = DEVICE_PRIVATE_DATA_CREATE_INFO, + PRIVATE_DATA_SLOT_CREATE_INFO_EXT = PRIVATE_DATA_SLOT_CREATE_INFO, + PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + MEMORY_BARRIER_2_KHR = MEMORY_BARRIER_2, + BUFFER_MEMORY_BARRIER_2_KHR = BUFFER_MEMORY_BARRIER_2, + IMAGE_MEMORY_BARRIER_2_KHR = IMAGE_MEMORY_BARRIER_2, + DEPENDENCY_INFO_KHR = DEPENDENCY_INFO, + SUBMIT_INFO_2_KHR = SUBMIT_INFO_2, + SEMAPHORE_SUBMIT_INFO_KHR = SEMAPHORE_SUBMIT_INFO, + COMMAND_BUFFER_SUBMIT_INFO_KHR = COMMAND_BUFFER_SUBMIT_INFO, + PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + COPY_BUFFER_INFO_2_KHR = COPY_BUFFER_INFO_2, + COPY_IMAGE_INFO_2_KHR = COPY_IMAGE_INFO_2, + COPY_BUFFER_TO_IMAGE_INFO_2_KHR = COPY_BUFFER_TO_IMAGE_INFO_2, + COPY_IMAGE_TO_BUFFER_INFO_2_KHR = COPY_IMAGE_TO_BUFFER_INFO_2, + BLIT_IMAGE_INFO_2_KHR = BLIT_IMAGE_INFO_2, + RESOLVE_IMAGE_INFO_2_KHR = RESOLVE_IMAGE_INFO_2, + BUFFER_COPY_2_KHR = BUFFER_COPY_2, + IMAGE_COPY_2_KHR = IMAGE_COPY_2, + IMAGE_BLIT_2_KHR = IMAGE_BLIT_2, + BUFFER_IMAGE_COPY_2_KHR = BUFFER_IMAGE_COPY_2, + IMAGE_RESOLVE_2_KHR = IMAGE_RESOLVE_2, + PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + FORMAT_PROPERTIES_3_KHR = FORMAT_PROPERTIES_3, + PIPELINE_INFO_EXT = PIPELINE_INFO_KHR, + PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, + QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, + PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = DEVICE_BUFFER_MEMORY_REQUIREMENTS, + DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = DEVICE_IMAGE_MEMORY_REQUIREMENTS, + SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, } SubgroupFeatureFlags :: distinct bit_set[SubgroupFeatureFlag; Flags] @@ -2978,9 +3456,30 @@ SubpassDescriptionFlag :: enum Flags { PER_VIEW_POSITION_X_ONLY_NVX = 1, FRAGMENT_REGION_QCOM = 2, SHADER_RESOLVE_QCOM = 3, - RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM = 4, - RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM = 5, - RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM = 6, + RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT = 4, + RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT = 5, + RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT = 6, + ENABLE_LEGACY_DITHERING_EXT = 7, + RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT, + RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT, + RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM = RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT, +} + +SubpassMergeStatusEXT :: enum c.int { + MERGED = 0, + DISALLOWED = 1, + NOT_MERGED_SIDE_EFFECTS = 2, + NOT_MERGED_SAMPLES_MISMATCH = 3, + NOT_MERGED_VIEWS_MISMATCH = 4, + NOT_MERGED_ALIASING = 5, + NOT_MERGED_DEPENDENCIES = 6, + NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT = 7, + NOT_MERGED_TOO_MANY_ATTACHMENTS = 8, + NOT_MERGED_INSUFFICIENT_STORAGE = 9, + NOT_MERGED_DEPTH_STENCIL_COUNT = 10, + NOT_MERGED_RESOLVE_ATTACHMENT_REUSE = 11, + NOT_MERGED_SINGLE_SUBPASS = 12, + NOT_MERGED_UNSPECIFIED = 13, } SurfaceCounterFlagsEXT :: distinct bit_set[SurfaceCounterFlagEXT; Flags] @@ -3003,9 +3502,10 @@ SurfaceTransformFlagKHR :: enum Flags { SwapchainCreateFlagsKHR :: distinct bit_set[SwapchainCreateFlagKHR; Flags] SwapchainCreateFlagKHR :: enum Flags { - SPLIT_INSTANCE_BIND_REGIONS = 0, - PROTECTED = 1, - MUTABLE_FORMAT = 2, + SPLIT_INSTANCE_BIND_REGIONS = 0, + PROTECTED = 1, + MUTABLE_FORMAT = 2, + DEFERRED_MEMORY_ALLOCATION_EXT = 3, } SystemAllocationScope :: enum c.int { @@ -3081,6 +3581,7 @@ VendorId :: enum c.int { CODEPLAY = 0x10004, MESA = 0x10005, POCL = 0x10006, + MOBILEYE = 0x10007, } VertexInputRate :: enum c.int { @@ -3088,6 +3589,141 @@ VertexInputRate :: enum c.int { INSTANCE = 1, } +VideoCapabilityFlagsKHR :: distinct bit_set[VideoCapabilityFlagKHR; Flags] +VideoCapabilityFlagKHR :: enum Flags { + PROTECTED_CONTENT = 0, + SEPARATE_REFERENCE_IMAGES = 1, +} + +VideoChromaSubsamplingFlagsKHR :: distinct bit_set[VideoChromaSubsamplingFlagKHR; Flags] +VideoChromaSubsamplingFlagKHR :: enum Flags { + MONOCHROME = 0, + _420 = 1, + _422 = 2, + _444 = 3, +} + +VideoChromaSubsamplingFlagsKHR_INVALID :: VideoChromaSubsamplingFlagsKHR{} + + +VideoCodecOperationFlagsKHR :: distinct bit_set[VideoCodecOperationFlagKHR; Flags] +VideoCodecOperationFlagKHR :: enum Flags { + ENCODE_H264_EXT = 16, + ENCODE_H265_EXT = 17, + DECODE_H264 = 0, + DECODE_H265 = 1, +} + +VideoCodecOperationFlagsKHR_NONE :: VideoCodecOperationFlagsKHR{} + + +VideoCodingControlFlagsKHR :: distinct bit_set[VideoCodingControlFlagKHR; Flags] +VideoCodingControlFlagKHR :: enum Flags { + RESET = 0, + ENCODE_RATE_CONTROL = 1, + ENCODE_RATE_CONTROL_LAYER = 2, +} + +VideoComponentBitDepthFlagsKHR :: distinct bit_set[VideoComponentBitDepthFlagKHR; Flags] +VideoComponentBitDepthFlagKHR :: enum Flags { + _8 = 0, + _10 = 2, + _12 = 4, +} + +VideoComponentBitDepthFlagsKHR_INVALID :: VideoComponentBitDepthFlagsKHR{} + + +VideoDecodeCapabilityFlagsKHR :: distinct bit_set[VideoDecodeCapabilityFlagKHR; Flags] +VideoDecodeCapabilityFlagKHR :: enum Flags { + DPB_AND_OUTPUT_COINCIDE = 0, + DPB_AND_OUTPUT_DISTINCT = 1, +} + +VideoDecodeH264FieldOrderCount :: enum c.int { +} + +VideoDecodeH264PictureLayoutFlagsKHR :: distinct bit_set[VideoDecodeH264PictureLayoutFlagKHR; Flags] +VideoDecodeH264PictureLayoutFlagKHR :: enum Flags { + INTERLACED_INTERLEAVED_LINES = 0, + INTERLACED_SEPARATE_PLANES = 1, +} + +VideoDecodeH264PictureLayoutFlagsKHR_PROGRESSIVE :: VideoDecodeH264PictureLayoutFlagsKHR{} + + +VideoDecodeUsageFlagsKHR :: distinct bit_set[VideoDecodeUsageFlagKHR; Flags] +VideoDecodeUsageFlagKHR :: enum Flags { + TRANSCODING = 0, + OFFLINE = 1, + STREAMING = 2, +} + +VideoDecodeUsageFlagsKHR_DEFAULT :: VideoDecodeUsageFlagsKHR{} + + +VideoH264AspectRatioIdc :: enum c.int { +} + +VideoH264CabacInitIdc :: enum c.int { +} + +VideoH264ChromaFormatIdc :: enum c.int { +} + +VideoH264DisableDeblockingFilterIdc :: enum c.int { +} + +VideoH264LevelIdc :: enum c.int { +} + +VideoH264MemMgmtControlOp :: enum c.int { +} + +VideoH264ModificationOfPicNumsIdc :: enum c.int { +} + +VideoH264NonVclNaluType :: enum c.int { +} + +VideoH264PictureType :: enum c.int { +} + +VideoH264PocType :: enum c.int { +} + +VideoH264ProfileIdc :: enum c.int { +} + +VideoH264SliceType :: enum c.int { +} + +VideoH264WeightedBipredIdc :: enum c.int { +} + +VideoH265AspectRatioIdc :: enum c.int { +} + +VideoH265ChromaFormatIdc :: enum c.int { +} + +VideoH265LevelIdc :: enum c.int { +} + +VideoH265PictureType :: enum c.int { +} + +VideoH265ProfileIdc :: enum c.int { +} + +VideoH265SliceType :: enum c.int { +} + +VideoSessionCreateFlagsKHR :: distinct bit_set[VideoSessionCreateFlagKHR; Flags] +VideoSessionCreateFlagKHR :: enum Flags { + PROTECTED_CONTENT = 0, +} + ViewportCoordinateSwizzleNV :: enum c.int { POSITIVE_X = 0, NEGATIVE_X = 1, @@ -3119,6 +3755,8 @@ DeviceCreateFlags :: distinct bit_set[DeviceC DeviceCreateFlag :: enum u32 {} DeviceMemoryReportFlagsEXT :: distinct bit_set[DeviceMemoryReportFlagEXT; Flags] DeviceMemoryReportFlagEXT :: enum u32 {} +DirectDriverLoadingFlagsLUNARG :: distinct bit_set[DirectDriverLoadingFlagLUNARG; Flags] +DirectDriverLoadingFlagLUNARG :: enum u32 {} DisplayModeCreateFlagsKHR :: distinct bit_set[DisplayModeCreateFlagKHR; Flags] DisplayModeCreateFlagKHR :: enum u32 {} DisplaySurfaceCreateFlagsKHR :: distinct bit_set[DisplaySurfaceCreateFlagKHR; Flags] @@ -3131,6 +3769,8 @@ MacOSSurfaceCreateFlagsMVK :: distinct bit_set[MacOSSu MacOSSurfaceCreateFlagMVK :: enum u32 {} MemoryMapFlags :: distinct bit_set[MemoryMapFlag; Flags] MemoryMapFlag :: enum u32 {} +MemoryUnmapFlagsKHR :: distinct bit_set[MemoryUnmapFlagKHR; Flags] +MemoryUnmapFlagKHR :: enum u32 {} MetalSurfaceCreateFlagsEXT :: distinct bit_set[MetalSurfaceCreateFlagEXT; Flags] MetalSurfaceCreateFlagEXT :: enum u32 {} PipelineCoverageModulationStateCreateFlagsNV :: distinct bit_set[PipelineCoverageModulationStateCreateFlagNV; Flags] @@ -3173,6 +3813,14 @@ ShaderModuleCreateFlags :: distinct bit_set[ShaderM ShaderModuleCreateFlag :: enum u32 {} ValidationCacheCreateFlagsEXT :: distinct bit_set[ValidationCacheCreateFlagEXT; Flags] ValidationCacheCreateFlagEXT :: enum u32 {} +VideoBeginCodingFlagsKHR :: distinct bit_set[VideoBeginCodingFlagKHR; Flags] +VideoBeginCodingFlagKHR :: enum u32 {} +VideoDecodeFlagsKHR :: distinct bit_set[VideoDecodeFlagKHR; Flags] +VideoDecodeFlagKHR :: enum u32 {} +VideoEndCodingFlagsKHR :: distinct bit_set[VideoEndCodingFlagKHR; Flags] +VideoEndCodingFlagKHR :: enum u32 {} +VideoSessionParametersCreateFlagsKHR :: distinct bit_set[VideoSessionParametersCreateFlagKHR; Flags] +VideoSessionParametersCreateFlagKHR :: enum u32 {} WaylandSurfaceCreateFlagsKHR :: distinct bit_set[WaylandSurfaceCreateFlagKHR; Flags] WaylandSurfaceCreateFlagKHR :: enum u32 {} Win32SurfaceCreateFlagsKHR :: distinct bit_set[Win32SurfaceCreateFlagKHR; Flags] diff --git a/vendor/vulkan/procedures.odin b/vendor/vulkan/procedures.odin index 8459a5e06..694945215 100644 --- a/vendor/vulkan/procedures.odin +++ b/vendor/vulkan/procedures.odin @@ -54,6 +54,7 @@ ProcGetDisplayPlaneCapabilitiesKHR :: #type pro ProcGetDisplayPlaneSupportedDisplaysKHR :: #type proc "system" (physicalDevice: PhysicalDevice, planeIndex: u32, pDisplayCount: ^u32, pDisplays: [^]DisplayKHR) -> Result ProcGetDrmDisplayEXT :: #type proc "system" (physicalDevice: PhysicalDevice, drmFd: i32, connectorId: u32, display: ^DisplayKHR) -> Result ProcGetInstanceProcAddr :: #type proc "system" (instance: Instance, pName: cstring) -> ProcVoidFunction +ProcGetInstanceProcAddrLUNARG :: #type proc "system" (instance: Instance, pName: cstring) -> ProcVoidFunction ProcGetPhysicalDeviceCalibrateableTimeDomainsEXT :: #type proc "system" (physicalDevice: PhysicalDevice, pTimeDomainCount: ^u32, pTimeDomains: [^]TimeDomainEXT) -> Result ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]CooperativeMatrixPropertiesNV) -> Result ProcGetPhysicalDeviceDisplayPlaneProperties2KHR :: #type proc "system" (physicalDevice: PhysicalDevice, pPropertyCount: ^u32, pProperties: [^]DisplayPlaneProperties2KHR) -> Result @@ -81,6 +82,7 @@ ProcGetPhysicalDeviceMemoryProperties :: #type pro ProcGetPhysicalDeviceMemoryProperties2 :: #type proc "system" (physicalDevice: PhysicalDevice, pMemoryProperties: [^]PhysicalDeviceMemoryProperties2) ProcGetPhysicalDeviceMemoryProperties2KHR :: #type proc "system" (physicalDevice: PhysicalDevice, pMemoryProperties: [^]PhysicalDeviceMemoryProperties2) ProcGetPhysicalDeviceMultisamplePropertiesEXT :: #type proc "system" (physicalDevice: PhysicalDevice, samples: SampleCountFlags, pMultisampleProperties: [^]MultisamplePropertiesEXT) +ProcGetPhysicalDeviceOpticalFlowImageFormatsNV :: #type proc "system" (physicalDevice: PhysicalDevice, pOpticalFlowImageFormatInfo: ^OpticalFlowImageFormatInfoNV, pFormatCount: ^u32, pImageFormatProperties: [^]OpticalFlowImageFormatPropertiesNV) -> Result ProcGetPhysicalDevicePresentRectanglesKHR :: #type proc "system" (physicalDevice: PhysicalDevice, surface: SurfaceKHR, pRectCount: ^u32, pRects: [^]Rect2D) -> Result ProcGetPhysicalDeviceProperties :: #type proc "system" (physicalDevice: PhysicalDevice, pProperties: [^]PhysicalDeviceProperties) ProcGetPhysicalDeviceProperties2 :: #type proc "system" (physicalDevice: PhysicalDevice, pProperties: [^]PhysicalDeviceProperties2) @@ -103,6 +105,8 @@ ProcGetPhysicalDeviceSurfacePresentModesKHR :: #type pro ProcGetPhysicalDeviceSurfaceSupportKHR :: #type proc "system" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, surface: SurfaceKHR, pSupported: ^b32) -> Result ProcGetPhysicalDeviceToolProperties :: #type proc "system" (physicalDevice: PhysicalDevice, pToolCount: ^u32, pToolProperties: [^]PhysicalDeviceToolProperties) -> Result ProcGetPhysicalDeviceToolPropertiesEXT :: #type proc "system" (physicalDevice: PhysicalDevice, pToolCount: ^u32, pToolProperties: [^]PhysicalDeviceToolProperties) -> Result +ProcGetPhysicalDeviceVideoCapabilitiesKHR :: #type proc "system" (physicalDevice: PhysicalDevice, pVideoProfile: ^VideoProfileInfoKHR, pCapabilities: [^]VideoCapabilitiesKHR) -> Result +ProcGetPhysicalDeviceVideoFormatPropertiesKHR :: #type proc "system" (physicalDevice: PhysicalDevice, pVideoFormatInfo: ^PhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: ^u32, pVideoFormatProperties: [^]VideoFormatPropertiesKHR) -> Result ProcGetPhysicalDeviceWaylandPresentationSupportKHR :: #type proc "system" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32, display: ^wl_display) -> b32 ProcGetPhysicalDeviceWin32PresentationSupportKHR :: #type proc "system" (physicalDevice: PhysicalDevice, queueFamilyIndex: u32) -> b32 ProcGetWinrtDisplayNV :: #type proc "system" (physicalDevice: PhysicalDevice, deviceRelativeId: u32, pDisplay: ^DisplayKHR) -> Result @@ -110,422 +114,522 @@ ProcReleaseDisplayEXT :: #type pro ProcSubmitDebugUtilsMessageEXT :: #type proc "system" (instance: Instance, messageSeverity: DebugUtilsMessageSeverityFlagsEXT, messageTypes: DebugUtilsMessageTypeFlagsEXT, pCallbackData: ^DebugUtilsMessengerCallbackDataEXT) // Device Procedure Types -ProcAcquireFullScreenExclusiveModeEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result -ProcAcquireNextImage2KHR :: #type proc "system" (device: Device, pAcquireInfo: ^AcquireNextImageInfoKHR, pImageIndex: ^u32) -> Result -ProcAcquireNextImageKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, timeout: u64, semaphore: Semaphore, fence: Fence, pImageIndex: ^u32) -> Result -ProcAcquirePerformanceConfigurationINTEL :: #type proc "system" (device: Device, pAcquireInfo: ^PerformanceConfigurationAcquireInfoINTEL, pConfiguration: ^PerformanceConfigurationINTEL) -> Result -ProcAcquireProfilingLockKHR :: #type proc "system" (device: Device, pInfo: ^AcquireProfilingLockInfoKHR) -> Result -ProcAllocateCommandBuffers :: #type proc "system" (device: Device, pAllocateInfo: ^CommandBufferAllocateInfo, pCommandBuffers: [^]CommandBuffer) -> Result -ProcAllocateDescriptorSets :: #type proc "system" (device: Device, pAllocateInfo: ^DescriptorSetAllocateInfo, pDescriptorSets: [^]DescriptorSet) -> Result -ProcAllocateMemory :: #type proc "system" (device: Device, pAllocateInfo: ^MemoryAllocateInfo, pAllocator: ^AllocationCallbacks, pMemory: ^DeviceMemory) -> Result -ProcBeginCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer, pBeginInfo: ^CommandBufferBeginInfo) -> Result -ProcBindAccelerationStructureMemoryNV :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindAccelerationStructureMemoryInfoNV) -> Result -ProcBindBufferMemory :: #type proc "system" (device: Device, buffer: Buffer, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result -ProcBindBufferMemory2 :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindBufferMemoryInfo) -> Result -ProcBindBufferMemory2KHR :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindBufferMemoryInfo) -> Result -ProcBindImageMemory :: #type proc "system" (device: Device, image: Image, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result -ProcBindImageMemory2 :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindImageMemoryInfo) -> Result -ProcBindImageMemory2KHR :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindImageMemoryInfo) -> Result -ProcBuildAccelerationStructuresKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^[^]AccelerationStructureBuildRangeInfoKHR) -> Result -ProcCmdBeginConditionalRenderingEXT :: #type proc "system" (commandBuffer: CommandBuffer, pConditionalRenderingBegin: ^ConditionalRenderingBeginInfoEXT) -ProcCmdBeginDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT) -ProcCmdBeginQuery :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags) -ProcCmdBeginQueryIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags, index: u32) -ProcCmdBeginRenderPass :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, contents: SubpassContents) -ProcCmdBeginRenderPass2 :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo) -ProcCmdBeginRenderPass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo) -ProcCmdBeginRendering :: #type proc "system" (commandBuffer: CommandBuffer, pRenderingInfo: ^RenderingInfo) -ProcCmdBeginRenderingKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRenderingInfo: ^RenderingInfo) -ProcCmdBeginTransformFeedbackEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [^]Buffer, pCounterBufferOffsets: [^]DeviceSize) -ProcCmdBindDescriptorSets :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: [^]DescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: [^]u32) -ProcCmdBindIndexBuffer :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, indexType: IndexType) -ProcCmdBindInvocationMaskHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout) -ProcCmdBindPipeline :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline) -ProcCmdBindPipelineShaderGroupNV :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline, groupIndex: u32) -ProcCmdBindShadingRateImageNV :: #type proc "system" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout) -ProcCmdBindTransformFeedbackBuffersEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize) -ProcCmdBindVertexBuffers :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize) -ProcCmdBindVertexBuffers2 :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize, pStrides: [^]DeviceSize) -ProcCmdBindVertexBuffers2EXT :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize, pStrides: [^]DeviceSize) -ProcCmdBlitImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageBlit, filter: Filter) -ProcCmdBlitImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2) -ProcCmdBlitImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2) -ProcCmdBuildAccelerationStructureNV :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: b32, dst: AccelerationStructureNV, src: AccelerationStructureNV, scratch: Buffer, scratchOffset: DeviceSize) -ProcCmdBuildAccelerationStructuresIndirectKHR :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: [^]DeviceAddress, pIndirectStrides: [^]u32, ppMaxPrimitiveCounts: ^[^]u32) -ProcCmdBuildAccelerationStructuresKHR :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^[^]AccelerationStructureBuildRangeInfoKHR) -ProcCmdClearAttachments :: #type proc "system" (commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: [^]ClearAttachment, rectCount: u32, pRects: [^]ClearRect) -ProcCmdClearColorImage :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: ^ClearColorValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange) -ProcCmdClearDepthStencilImage :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: ^ClearDepthStencilValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange) -ProcCmdCopyAccelerationStructureKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureInfoKHR) -ProcCmdCopyAccelerationStructureNV :: #type proc "system" (commandBuffer: CommandBuffer, dst: AccelerationStructureNV, src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR) -ProcCmdCopyAccelerationStructureToMemoryKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -ProcCmdCopyBuffer :: #type proc "system" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstBuffer: Buffer, regionCount: u32, pRegions: [^]BufferCopy) -ProcCmdCopyBuffer2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2) -ProcCmdCopyBuffer2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2) -ProcCmdCopyBufferToImage :: #type proc "system" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]BufferImageCopy) -ProcCmdCopyBufferToImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2) -ProcCmdCopyBufferToImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2) -ProcCmdCopyImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageCopy) -ProcCmdCopyImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2) -ProcCmdCopyImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2) -ProcCmdCopyImageToBuffer :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstBuffer: Buffer, regionCount: u32, pRegions: [^]BufferImageCopy) -ProcCmdCopyImageToBuffer2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2) -ProcCmdCopyImageToBuffer2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2) -ProcCmdCopyMemoryToAccelerationStructureKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) -ProcCmdCopyQueryPoolResults :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dstBuffer: Buffer, dstOffset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags) -ProcCmdCuLaunchKernelNVX :: #type proc "system" (commandBuffer: CommandBuffer, pLaunchInfo: ^CuLaunchInfoNVX) -ProcCmdDebugMarkerBeginEXT :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT) -ProcCmdDebugMarkerEndEXT :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdDebugMarkerInsertEXT :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT) -ProcCmdDispatch :: #type proc "system" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) -ProcCmdDispatchBase :: #type proc "system" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) -ProcCmdDispatchBaseKHR :: #type proc "system" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) -ProcCmdDispatchIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) -ProcCmdDraw :: #type proc "system" (commandBuffer: CommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) -ProcCmdDrawIndexed :: #type proc "system" (commandBuffer: CommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32) -ProcCmdDrawIndexedIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) -ProcCmdDrawIndexedIndirectCount :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawIndexedIndirectCountAMD :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawIndexedIndirectCountKHR :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) -ProcCmdDrawIndirectByteCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: Buffer, counterBufferOffset: DeviceSize, counterOffset: u32, vertexStride: u32) -ProcCmdDrawIndirectCount :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawIndirectCountAMD :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawIndirectCountKHR :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawMeshTasksIndirectCountNV :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) -ProcCmdDrawMeshTasksIndirectNV :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) -ProcCmdDrawMeshTasksNV :: #type proc "system" (commandBuffer: CommandBuffer, taskCount: u32, firstTask: u32) -ProcCmdDrawMultiEXT :: #type proc "system" (commandBuffer: CommandBuffer, drawCount: u32, pVertexInfo: ^MultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32) -ProcCmdDrawMultiIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, drawCount: u32, pIndexInfo: ^MultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: ^i32) -ProcCmdEndConditionalRenderingEXT :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdEndDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdEndQuery :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32) -ProcCmdEndQueryIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, index: u32) -ProcCmdEndRenderPass :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdEndRenderPass2 :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo) -ProcCmdEndRenderPass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo) -ProcCmdEndRendering :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdEndRenderingKHR :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdEndTransformFeedbackEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [^]Buffer, pCounterBufferOffsets: [^]DeviceSize) -ProcCmdExecuteCommands :: #type proc "system" (commandBuffer: CommandBuffer, commandBufferCount: u32, pCommandBuffers: [^]CommandBuffer) -ProcCmdExecuteGeneratedCommandsNV :: #type proc "system" (commandBuffer: CommandBuffer, isPreprocessed: b32, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV) -ProcCmdFillBuffer :: #type proc "system" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, size: DeviceSize, data: u32) -ProcCmdInsertDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT) -ProcCmdNextSubpass :: #type proc "system" (commandBuffer: CommandBuffer, contents: SubpassContents) -ProcCmdNextSubpass2 :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo) -ProcCmdNextSubpass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo) -ProcCmdPipelineBarrier :: #type proc "system" (commandBuffer: CommandBuffer, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, dependencyFlags: DependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: [^]MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [^]BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [^]ImageMemoryBarrier) -ProcCmdPipelineBarrier2 :: #type proc "system" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfo) -ProcCmdPipelineBarrier2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfo) -ProcCmdPreprocessGeneratedCommandsNV :: #type proc "system" (commandBuffer: CommandBuffer, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV) -ProcCmdPushConstants :: #type proc "system" (commandBuffer: CommandBuffer, layout: PipelineLayout, stageFlags: ShaderStageFlags, offset: u32, size: u32, pValues: rawptr) -ProcCmdPushDescriptorSetKHR :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: [^]WriteDescriptorSet) -ProcCmdPushDescriptorSetWithTemplateKHR :: #type proc "system" (commandBuffer: CommandBuffer, descriptorUpdateTemplate: DescriptorUpdateTemplate, layout: PipelineLayout, set: u32, pData: rawptr) -ProcCmdResetEvent :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) -ProcCmdResetEvent2 :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2) -ProcCmdResetEvent2KHR :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2) -ProcCmdResetQueryPool :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32) -ProcCmdResolveImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageResolve) -ProcCmdResolveImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2) -ProcCmdResolveImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2) -ProcCmdSetBlendConstants :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdSetCheckpointNV :: #type proc "system" (commandBuffer: CommandBuffer, pCheckpointMarker: rawptr) -ProcCmdSetCoarseSampleOrderNV :: #type proc "system" (commandBuffer: CommandBuffer, sampleOrderType: CoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: [^]CoarseSampleOrderCustomNV) -ProcCmdSetCullMode :: #type proc "system" (commandBuffer: CommandBuffer, cullMode: CullModeFlags) -ProcCmdSetCullModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, cullMode: CullModeFlags) -ProcCmdSetDepthBias :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32) -ProcCmdSetDepthBiasEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasEnable: b32) -ProcCmdSetDepthBiasEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasEnable: b32) -ProcCmdSetDepthBounds :: #type proc "system" (commandBuffer: CommandBuffer, minDepthBounds: f32, maxDepthBounds: f32) -ProcCmdSetDepthBoundsTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32) -ProcCmdSetDepthBoundsTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32) -ProcCmdSetDepthCompareOp :: #type proc "system" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp) -ProcCmdSetDepthCompareOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp) -ProcCmdSetDepthTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthTestEnable: b32) -ProcCmdSetDepthTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthTestEnable: b32) -ProcCmdSetDepthWriteEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthWriteEnable: b32) -ProcCmdSetDepthWriteEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthWriteEnable: b32) -ProcCmdSetDeviceMask :: #type proc "system" (commandBuffer: CommandBuffer, deviceMask: u32) -ProcCmdSetDeviceMaskKHR :: #type proc "system" (commandBuffer: CommandBuffer, deviceMask: u32) -ProcCmdSetDiscardRectangleEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: [^]Rect2D) -ProcCmdSetEvent :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) -ProcCmdSetEvent2 :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfo) -ProcCmdSetEvent2KHR :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfo) -ProcCmdSetExclusiveScissorNV :: #type proc "system" (commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: [^]Rect2D) -ProcCmdSetFragmentShadingRateEnumNV :: #type proc "system" (commandBuffer: CommandBuffer, shadingRate: FragmentShadingRateNV) -ProcCmdSetFragmentShadingRateKHR :: #type proc "system" (commandBuffer: CommandBuffer, pFragmentSize: ^Extent2D) -ProcCmdSetFrontFace :: #type proc "system" (commandBuffer: CommandBuffer, frontFace: FrontFace) -ProcCmdSetFrontFaceEXT :: #type proc "system" (commandBuffer: CommandBuffer, frontFace: FrontFace) -ProcCmdSetLineStippleEXT :: #type proc "system" (commandBuffer: CommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16) -ProcCmdSetLineWidth :: #type proc "system" (commandBuffer: CommandBuffer, lineWidth: f32) -ProcCmdSetLogicOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, logicOp: LogicOp) -ProcCmdSetPatchControlPointsEXT :: #type proc "system" (commandBuffer: CommandBuffer, patchControlPoints: u32) -ProcCmdSetPerformanceMarkerINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceMarkerInfoINTEL) -> Result -ProcCmdSetPerformanceOverrideINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pOverrideInfo: ^PerformanceOverrideInfoINTEL) -> Result -ProcCmdSetPerformanceStreamMarkerINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceStreamMarkerInfoINTEL) -> Result -ProcCmdSetPrimitiveRestartEnable :: #type proc "system" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32) -ProcCmdSetPrimitiveRestartEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32) -ProcCmdSetPrimitiveTopology :: #type proc "system" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology) -ProcCmdSetPrimitiveTopologyEXT :: #type proc "system" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology) -ProcCmdSetRasterizerDiscardEnable :: #type proc "system" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32) -ProcCmdSetRasterizerDiscardEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32) -ProcCmdSetRayTracingPipelineStackSizeKHR :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStackSize: u32) -ProcCmdSetSampleLocationsEXT :: #type proc "system" (commandBuffer: CommandBuffer, pSampleLocationsInfo: ^SampleLocationsInfoEXT) -ProcCmdSetScissor :: #type proc "system" (commandBuffer: CommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: [^]Rect2D) -ProcCmdSetScissorWithCount :: #type proc "system" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: [^]Rect2D) -ProcCmdSetScissorWithCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: [^]Rect2D) -ProcCmdSetStencilCompareMask :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, compareMask: u32) -ProcCmdSetStencilOp :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp) -ProcCmdSetStencilOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp) -ProcCmdSetStencilReference :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, reference: u32) -ProcCmdSetStencilTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, stencilTestEnable: b32) -ProcCmdSetStencilTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, stencilTestEnable: b32) -ProcCmdSetStencilWriteMask :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, writeMask: u32) -ProcCmdSetVertexInputEXT :: #type proc "system" (commandBuffer: CommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: [^]VertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: [^]VertexInputAttributeDescription2EXT) -ProcCmdSetViewport :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: [^]Viewport) -ProcCmdSetViewportShadingRatePaletteNV :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: [^]ShadingRatePaletteNV) -ProcCmdSetViewportWScalingNV :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: [^]ViewportWScalingNV) -ProcCmdSetViewportWithCount :: #type proc "system" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: [^]Viewport) -ProcCmdSetViewportWithCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: [^]Viewport) -ProcCmdSubpassShadingHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer) -ProcCmdTraceRaysIndirectKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pMissShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pHitShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: [^]StridedDeviceAddressRegionKHR, indirectDeviceAddress: DeviceAddress) -ProcCmdTraceRaysKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pMissShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pHitShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: [^]StridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32) -ProcCmdTraceRaysNV :: #type proc "system" (commandBuffer: CommandBuffer, raygenShaderBindingTableBuffer: Buffer, raygenShaderBindingOffset: DeviceSize, missShaderBindingTableBuffer: Buffer, missShaderBindingOffset: DeviceSize, missShaderBindingStride: DeviceSize, hitShaderBindingTableBuffer: Buffer, hitShaderBindingOffset: DeviceSize, hitShaderBindingStride: DeviceSize, callableShaderBindingTableBuffer: Buffer, callableShaderBindingOffset: DeviceSize, callableShaderBindingStride: DeviceSize, width: u32, height: u32, depth: u32) -ProcCmdUpdateBuffer :: #type proc "system" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, dataSize: DeviceSize, pData: rawptr) -ProcCmdWaitEvents :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: [^]MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [^]BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [^]ImageMemoryBarrier) -ProcCmdWaitEvents2 :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, pDependencyInfos: [^]DependencyInfo) -ProcCmdWaitEvents2KHR :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, pDependencyInfos: [^]DependencyInfo) -ProcCmdWriteAccelerationStructuresPropertiesKHR :: #type proc "system" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) -ProcCmdWriteAccelerationStructuresPropertiesNV :: #type proc "system" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureNV, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) -ProcCmdWriteBufferMarker2AMD :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32) -ProcCmdWriteBufferMarkerAMD :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32) -ProcCmdWriteTimestamp :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, queryPool: QueryPool, query: u32) -ProcCmdWriteTimestamp2 :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32) -ProcCmdWriteTimestamp2KHR :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32) -ProcCompileDeferredNV :: #type proc "system" (device: Device, pipeline: Pipeline, shader: u32) -> Result -ProcCopyAccelerationStructureKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureInfoKHR) -> Result -ProcCopyAccelerationStructureToMemoryKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -> Result -ProcCopyMemoryToAccelerationStructureKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) -> Result -ProcCreateAccelerationStructureKHR :: #type proc "system" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoKHR, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureKHR) -> Result -ProcCreateAccelerationStructureNV :: #type proc "system" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoNV, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureNV) -> Result -ProcCreateBuffer :: #type proc "system" (device: Device, pCreateInfo: ^BufferCreateInfo, pAllocator: ^AllocationCallbacks, pBuffer: ^Buffer) -> Result -ProcCreateBufferView :: #type proc "system" (device: Device, pCreateInfo: ^BufferViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^BufferView) -> Result -ProcCreateCommandPool :: #type proc "system" (device: Device, pCreateInfo: ^CommandPoolCreateInfo, pAllocator: ^AllocationCallbacks, pCommandPool: ^CommandPool) -> Result -ProcCreateComputePipelines :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]ComputePipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result -ProcCreateCuFunctionNVX :: #type proc "system" (device: Device, pCreateInfo: ^CuFunctionCreateInfoNVX, pAllocator: ^AllocationCallbacks, pFunction: ^CuFunctionNVX) -> Result -ProcCreateCuModuleNVX :: #type proc "system" (device: Device, pCreateInfo: ^CuModuleCreateInfoNVX, pAllocator: ^AllocationCallbacks, pModule: ^CuModuleNVX) -> Result -ProcCreateDeferredOperationKHR :: #type proc "system" (device: Device, pAllocator: ^AllocationCallbacks, pDeferredOperation: ^DeferredOperationKHR) -> Result -ProcCreateDescriptorPool :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorPoolCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorPool: ^DescriptorPool) -> Result -ProcCreateDescriptorSetLayout :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pSetLayout: ^DescriptorSetLayout) -> Result -ProcCreateDescriptorUpdateTemplate :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result -ProcCreateDescriptorUpdateTemplateKHR :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result -ProcCreateEvent :: #type proc "system" (device: Device, pCreateInfo: ^EventCreateInfo, pAllocator: ^AllocationCallbacks, pEvent: ^Event) -> Result -ProcCreateFence :: #type proc "system" (device: Device, pCreateInfo: ^FenceCreateInfo, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result -ProcCreateFramebuffer :: #type proc "system" (device: Device, pCreateInfo: ^FramebufferCreateInfo, pAllocator: ^AllocationCallbacks, pFramebuffer: ^Framebuffer) -> Result -ProcCreateGraphicsPipelines :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]GraphicsPipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result -ProcCreateImage :: #type proc "system" (device: Device, pCreateInfo: ^ImageCreateInfo, pAllocator: ^AllocationCallbacks, pImage: ^Image) -> Result -ProcCreateImageView :: #type proc "system" (device: Device, pCreateInfo: ^ImageViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^ImageView) -> Result -ProcCreateIndirectCommandsLayoutNV :: #type proc "system" (device: Device, pCreateInfo: ^IndirectCommandsLayoutCreateInfoNV, pAllocator: ^AllocationCallbacks, pIndirectCommandsLayout: ^IndirectCommandsLayoutNV) -> Result -ProcCreatePipelineCache :: #type proc "system" (device: Device, pCreateInfo: ^PipelineCacheCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineCache: ^PipelineCache) -> Result -ProcCreatePipelineLayout :: #type proc "system" (device: Device, pCreateInfo: ^PipelineLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineLayout: ^PipelineLayout) -> Result -ProcCreatePrivateDataSlot :: #type proc "system" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfo, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlot) -> Result -ProcCreatePrivateDataSlotEXT :: #type proc "system" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfo, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlot) -> Result -ProcCreateQueryPool :: #type proc "system" (device: Device, pCreateInfo: ^QueryPoolCreateInfo, pAllocator: ^AllocationCallbacks, pQueryPool: ^QueryPool) -> Result -ProcCreateRayTracingPipelinesKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]RayTracingPipelineCreateInfoKHR, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result -ProcCreateRayTracingPipelinesNV :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]RayTracingPipelineCreateInfoNV, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result -ProcCreateRenderPass :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result -ProcCreateRenderPass2 :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result -ProcCreateRenderPass2KHR :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result -ProcCreateSampler :: #type proc "system" (device: Device, pCreateInfo: ^SamplerCreateInfo, pAllocator: ^AllocationCallbacks, pSampler: ^Sampler) -> Result -ProcCreateSamplerYcbcrConversion :: #type proc "system" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result -ProcCreateSamplerYcbcrConversionKHR :: #type proc "system" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result -ProcCreateSemaphore :: #type proc "system" (device: Device, pCreateInfo: ^SemaphoreCreateInfo, pAllocator: ^AllocationCallbacks, pSemaphore: ^Semaphore) -> Result -ProcCreateShaderModule :: #type proc "system" (device: Device, pCreateInfo: ^ShaderModuleCreateInfo, pAllocator: ^AllocationCallbacks, pShaderModule: ^ShaderModule) -> Result -ProcCreateSharedSwapchainsKHR :: #type proc "system" (device: Device, swapchainCount: u32, pCreateInfos: [^]SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchains: [^]SwapchainKHR) -> Result -ProcCreateSwapchainKHR :: #type proc "system" (device: Device, pCreateInfo: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchain: ^SwapchainKHR) -> Result -ProcCreateValidationCacheEXT :: #type proc "system" (device: Device, pCreateInfo: ^ValidationCacheCreateInfoEXT, pAllocator: ^AllocationCallbacks, pValidationCache: ^ValidationCacheEXT) -> Result -ProcDebugMarkerSetObjectNameEXT :: #type proc "system" (device: Device, pNameInfo: ^DebugMarkerObjectNameInfoEXT) -> Result -ProcDebugMarkerSetObjectTagEXT :: #type proc "system" (device: Device, pTagInfo: ^DebugMarkerObjectTagInfoEXT) -> Result -ProcDeferredOperationJoinKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> Result -ProcDestroyAccelerationStructureKHR :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: ^AllocationCallbacks) -ProcDestroyAccelerationStructureNV :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureNV, pAllocator: ^AllocationCallbacks) -ProcDestroyBuffer :: #type proc "system" (device: Device, buffer: Buffer, pAllocator: ^AllocationCallbacks) -ProcDestroyBufferView :: #type proc "system" (device: Device, bufferView: BufferView, pAllocator: ^AllocationCallbacks) -ProcDestroyCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, pAllocator: ^AllocationCallbacks) -ProcDestroyCuFunctionNVX :: #type proc "system" (device: Device, function: CuFunctionNVX, pAllocator: ^AllocationCallbacks) -ProcDestroyCuModuleNVX :: #type proc "system" (device: Device, module: CuModuleNVX, pAllocator: ^AllocationCallbacks) -ProcDestroyDeferredOperationKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR, pAllocator: ^AllocationCallbacks) -ProcDestroyDescriptorPool :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, pAllocator: ^AllocationCallbacks) -ProcDestroyDescriptorSetLayout :: #type proc "system" (device: Device, descriptorSetLayout: DescriptorSetLayout, pAllocator: ^AllocationCallbacks) -ProcDestroyDescriptorUpdateTemplate :: #type proc "system" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks) -ProcDestroyDescriptorUpdateTemplateKHR :: #type proc "system" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks) -ProcDestroyDevice :: #type proc "system" (device: Device, pAllocator: ^AllocationCallbacks) -ProcDestroyEvent :: #type proc "system" (device: Device, event: Event, pAllocator: ^AllocationCallbacks) -ProcDestroyFence :: #type proc "system" (device: Device, fence: Fence, pAllocator: ^AllocationCallbacks) -ProcDestroyFramebuffer :: #type proc "system" (device: Device, framebuffer: Framebuffer, pAllocator: ^AllocationCallbacks) -ProcDestroyImage :: #type proc "system" (device: Device, image: Image, pAllocator: ^AllocationCallbacks) -ProcDestroyImageView :: #type proc "system" (device: Device, imageView: ImageView, pAllocator: ^AllocationCallbacks) -ProcDestroyIndirectCommandsLayoutNV :: #type proc "system" (device: Device, indirectCommandsLayout: IndirectCommandsLayoutNV, pAllocator: ^AllocationCallbacks) -ProcDestroyPipeline :: #type proc "system" (device: Device, pipeline: Pipeline, pAllocator: ^AllocationCallbacks) -ProcDestroyPipelineCache :: #type proc "system" (device: Device, pipelineCache: PipelineCache, pAllocator: ^AllocationCallbacks) -ProcDestroyPipelineLayout :: #type proc "system" (device: Device, pipelineLayout: PipelineLayout, pAllocator: ^AllocationCallbacks) -ProcDestroyPrivateDataSlot :: #type proc "system" (device: Device, privateDataSlot: PrivateDataSlot, pAllocator: ^AllocationCallbacks) -ProcDestroyPrivateDataSlotEXT :: #type proc "system" (device: Device, privateDataSlot: PrivateDataSlot, pAllocator: ^AllocationCallbacks) -ProcDestroyQueryPool :: #type proc "system" (device: Device, queryPool: QueryPool, pAllocator: ^AllocationCallbacks) -ProcDestroyRenderPass :: #type proc "system" (device: Device, renderPass: RenderPass, pAllocator: ^AllocationCallbacks) -ProcDestroySampler :: #type proc "system" (device: Device, sampler: Sampler, pAllocator: ^AllocationCallbacks) -ProcDestroySamplerYcbcrConversion :: #type proc "system" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks) -ProcDestroySamplerYcbcrConversionKHR :: #type proc "system" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks) -ProcDestroySemaphore :: #type proc "system" (device: Device, semaphore: Semaphore, pAllocator: ^AllocationCallbacks) -ProcDestroyShaderModule :: #type proc "system" (device: Device, shaderModule: ShaderModule, pAllocator: ^AllocationCallbacks) -ProcDestroySwapchainKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pAllocator: ^AllocationCallbacks) -ProcDestroyValidationCacheEXT :: #type proc "system" (device: Device, validationCache: ValidationCacheEXT, pAllocator: ^AllocationCallbacks) -ProcDeviceWaitIdle :: #type proc "system" (device: Device) -> Result -ProcDisplayPowerControlEXT :: #type proc "system" (device: Device, display: DisplayKHR, pDisplayPowerInfo: ^DisplayPowerInfoEXT) -> Result -ProcEndCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer) -> Result -ProcFlushMappedMemoryRanges :: #type proc "system" (device: Device, memoryRangeCount: u32, pMemoryRanges: [^]MappedMemoryRange) -> Result -ProcFreeCommandBuffers :: #type proc "system" (device: Device, commandPool: CommandPool, commandBufferCount: u32, pCommandBuffers: [^]CommandBuffer) -ProcFreeDescriptorSets :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, descriptorSetCount: u32, pDescriptorSets: [^]DescriptorSet) -> Result -ProcFreeMemory :: #type proc "system" (device: Device, memory: DeviceMemory, pAllocator: ^AllocationCallbacks) -ProcGetAccelerationStructureBuildSizesKHR :: #type proc "system" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^AccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: [^]u32, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR) -ProcGetAccelerationStructureDeviceAddressKHR :: #type proc "system" (device: Device, pInfo: ^AccelerationStructureDeviceAddressInfoKHR) -> DeviceAddress -ProcGetAccelerationStructureHandleNV :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureNV, dataSize: int, pData: rawptr) -> Result -ProcGetAccelerationStructureMemoryRequirementsNV :: #type proc "system" (device: Device, pInfo: ^AccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: [^]MemoryRequirements2KHR) -ProcGetBufferDeviceAddress :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress -ProcGetBufferDeviceAddressEXT :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress -ProcGetBufferDeviceAddressKHR :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress -ProcGetBufferMemoryRequirements :: #type proc "system" (device: Device, buffer: Buffer, pMemoryRequirements: [^]MemoryRequirements) -ProcGetBufferMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetBufferMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetBufferOpaqueCaptureAddress :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64 -ProcGetBufferOpaqueCaptureAddressKHR :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64 -ProcGetCalibratedTimestampsEXT :: #type proc "system" (device: Device, timestampCount: u32, pTimestampInfos: [^]CalibratedTimestampInfoEXT, pTimestamps: [^]u64, pMaxDeviation: ^u64) -> Result -ProcGetDeferredOperationMaxConcurrencyKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> u32 -ProcGetDeferredOperationResultKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> Result -ProcGetDescriptorSetHostMappingVALVE :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, ppData: ^rawptr) -ProcGetDescriptorSetLayoutHostMappingInfoVALVE :: #type proc "system" (device: Device, pBindingReference: ^DescriptorSetBindingReferenceVALVE, pHostMapping: ^DescriptorSetLayoutHostMappingInfoVALVE) -ProcGetDescriptorSetLayoutSupport :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport) -ProcGetDescriptorSetLayoutSupportKHR :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport) -ProcGetDeviceAccelerationStructureCompatibilityKHR :: #type proc "system" (device: Device, pVersionInfo: ^AccelerationStructureVersionInfoKHR, pCompatibility: ^AccelerationStructureCompatibilityKHR) -ProcGetDeviceBufferMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceBufferMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetDeviceBufferMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceBufferMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetDeviceGroupPeerMemoryFeatures :: #type proc "system" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [^]PeerMemoryFeatureFlags) -ProcGetDeviceGroupPeerMemoryFeaturesKHR :: #type proc "system" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [^]PeerMemoryFeatureFlags) -ProcGetDeviceGroupPresentCapabilitiesKHR :: #type proc "system" (device: Device, pDeviceGroupPresentCapabilities: [^]DeviceGroupPresentCapabilitiesKHR) -> Result -ProcGetDeviceGroupSurfacePresentModes2EXT :: #type proc "system" (device: Device, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pModes: [^]DeviceGroupPresentModeFlagsKHR) -> Result -ProcGetDeviceGroupSurfacePresentModesKHR :: #type proc "system" (device: Device, surface: SurfaceKHR, pModes: [^]DeviceGroupPresentModeFlagsKHR) -> Result -ProcGetDeviceImageMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetDeviceImageMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetDeviceImageSparseMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) -ProcGetDeviceImageSparseMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) -ProcGetDeviceMemoryCommitment :: #type proc "system" (device: Device, memory: DeviceMemory, pCommittedMemoryInBytes: [^]DeviceSize) -ProcGetDeviceMemoryOpaqueCaptureAddress :: #type proc "system" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64 -ProcGetDeviceMemoryOpaqueCaptureAddressKHR :: #type proc "system" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64 -ProcGetDeviceProcAddr :: #type proc "system" (device: Device, pName: cstring) -> ProcVoidFunction -ProcGetDeviceQueue :: #type proc "system" (device: Device, queueFamilyIndex: u32, queueIndex: u32, pQueue: ^Queue) -ProcGetDeviceQueue2 :: #type proc "system" (device: Device, pQueueInfo: ^DeviceQueueInfo2, pQueue: ^Queue) -ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI :: #type proc "system" (device: Device, renderpass: RenderPass, pMaxWorkgroupSize: ^Extent2D) -> Result -ProcGetEventStatus :: #type proc "system" (device: Device, event: Event) -> Result -ProcGetFenceFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^FenceGetFdInfoKHR, pFd: ^c.int) -> Result -ProcGetFenceStatus :: #type proc "system" (device: Device, fence: Fence) -> Result -ProcGetFenceWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^FenceGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result -ProcGetGeneratedCommandsMemoryRequirementsNV :: #type proc "system" (device: Device, pInfo: ^GeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetImageDrmFormatModifierPropertiesEXT :: #type proc "system" (device: Device, image: Image, pProperties: [^]ImageDrmFormatModifierPropertiesEXT) -> Result -ProcGetImageMemoryRequirements :: #type proc "system" (device: Device, image: Image, pMemoryRequirements: [^]MemoryRequirements) -ProcGetImageMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetImageMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) -ProcGetImageSparseMemoryRequirements :: #type proc "system" (device: Device, image: Image, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements) -ProcGetImageSparseMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) -ProcGetImageSparseMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) -ProcGetImageSubresourceLayout :: #type proc "system" (device: Device, image: Image, pSubresource: ^ImageSubresource, pLayout: ^SubresourceLayout) -ProcGetImageViewAddressNVX :: #type proc "system" (device: Device, imageView: ImageView, pProperties: [^]ImageViewAddressPropertiesNVX) -> Result -ProcGetImageViewHandleNVX :: #type proc "system" (device: Device, pInfo: ^ImageViewHandleInfoNVX) -> u32 -ProcGetMemoryFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^MemoryGetFdInfoKHR, pFd: ^c.int) -> Result -ProcGetMemoryFdPropertiesKHR :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, fd: c.int, pMemoryFdProperties: [^]MemoryFdPropertiesKHR) -> Result -ProcGetMemoryHostPointerPropertiesEXT :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHostPointer: rawptr, pMemoryHostPointerProperties: [^]MemoryHostPointerPropertiesEXT) -> Result -ProcGetMemoryRemoteAddressNV :: #type proc "system" (device: Device, pMemoryGetRemoteAddressInfo: ^MemoryGetRemoteAddressInfoNV, pAddress: [^]RemoteAddressNV) -> Result -ProcGetMemoryWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^MemoryGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result -ProcGetMemoryWin32HandleNV :: #type proc "system" (device: Device, memory: DeviceMemory, handleType: ExternalMemoryHandleTypeFlagsNV, pHandle: ^HANDLE) -> Result -ProcGetMemoryWin32HandlePropertiesKHR :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: [^]MemoryWin32HandlePropertiesKHR) -> Result -ProcGetPastPresentationTimingGOOGLE :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: ^u32, pPresentationTimings: [^]PastPresentationTimingGOOGLE) -> Result -ProcGetPerformanceParameterINTEL :: #type proc "system" (device: Device, parameter: PerformanceParameterTypeINTEL, pValue: ^PerformanceValueINTEL) -> Result -ProcGetPipelineCacheData :: #type proc "system" (device: Device, pipelineCache: PipelineCache, pDataSize: ^int, pData: rawptr) -> Result -ProcGetPipelineExecutableInternalRepresentationsKHR :: #type proc "system" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pInternalRepresentationCount: ^u32, pInternalRepresentations: [^]PipelineExecutableInternalRepresentationKHR) -> Result -ProcGetPipelineExecutablePropertiesKHR :: #type proc "system" (device: Device, pPipelineInfo: ^PipelineInfoKHR, pExecutableCount: ^u32, pProperties: [^]PipelineExecutablePropertiesKHR) -> Result -ProcGetPipelineExecutableStatisticsKHR :: #type proc "system" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pStatisticCount: ^u32, pStatistics: [^]PipelineExecutableStatisticKHR) -> Result -ProcGetPrivateData :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, pData: ^u64) -ProcGetPrivateDataEXT :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, pData: ^u64) -ProcGetQueryPoolResults :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dataSize: int, pData: rawptr, stride: DeviceSize, flags: QueryResultFlags) -> Result -ProcGetQueueCheckpointData2NV :: #type proc "system" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointData2NV) -ProcGetQueueCheckpointDataNV :: #type proc "system" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointDataNV) -ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result -ProcGetRayTracingShaderGroupHandlesKHR :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result -ProcGetRayTracingShaderGroupHandlesNV :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result -ProcGetRayTracingShaderGroupStackSizeKHR :: #type proc "system" (device: Device, pipeline: Pipeline, group: u32, groupShader: ShaderGroupShaderKHR) -> DeviceSize -ProcGetRefreshCycleDurationGOOGLE :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pDisplayTimingProperties: [^]RefreshCycleDurationGOOGLE) -> Result -ProcGetRenderAreaGranularity :: #type proc "system" (device: Device, renderPass: RenderPass, pGranularity: ^Extent2D) -ProcGetSemaphoreCounterValue :: #type proc "system" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result -ProcGetSemaphoreCounterValueKHR :: #type proc "system" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result -ProcGetSemaphoreFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^SemaphoreGetFdInfoKHR, pFd: ^c.int) -> Result -ProcGetSemaphoreWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^SemaphoreGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result -ProcGetShaderInfoAMD :: #type proc "system" (device: Device, pipeline: Pipeline, shaderStage: ShaderStageFlags, infoType: ShaderInfoTypeAMD, pInfoSize: ^int, pInfo: rawptr) -> Result -ProcGetSwapchainCounterEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, pCounterValue: ^u64) -> Result -ProcGetSwapchainImagesKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pSwapchainImageCount: ^u32, pSwapchainImages: [^]Image) -> Result -ProcGetSwapchainStatusKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result -ProcGetValidationCacheDataEXT :: #type proc "system" (device: Device, validationCache: ValidationCacheEXT, pDataSize: ^int, pData: rawptr) -> Result -ProcImportFenceFdKHR :: #type proc "system" (device: Device, pImportFenceFdInfo: ^ImportFenceFdInfoKHR) -> Result -ProcImportFenceWin32HandleKHR :: #type proc "system" (device: Device, pImportFenceWin32HandleInfo: ^ImportFenceWin32HandleInfoKHR) -> Result -ProcImportSemaphoreFdKHR :: #type proc "system" (device: Device, pImportSemaphoreFdInfo: ^ImportSemaphoreFdInfoKHR) -> Result -ProcImportSemaphoreWin32HandleKHR :: #type proc "system" (device: Device, pImportSemaphoreWin32HandleInfo: ^ImportSemaphoreWin32HandleInfoKHR) -> Result -ProcInitializePerformanceApiINTEL :: #type proc "system" (device: Device, pInitializeInfo: ^InitializePerformanceApiInfoINTEL) -> Result -ProcInvalidateMappedMemoryRanges :: #type proc "system" (device: Device, memoryRangeCount: u32, pMemoryRanges: [^]MappedMemoryRange) -> Result -ProcMapMemory :: #type proc "system" (device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, ppData: ^rawptr) -> Result -ProcMergePipelineCaches :: #type proc "system" (device: Device, dstCache: PipelineCache, srcCacheCount: u32, pSrcCaches: [^]PipelineCache) -> Result -ProcMergeValidationCachesEXT :: #type proc "system" (device: Device, dstCache: ValidationCacheEXT, srcCacheCount: u32, pSrcCaches: [^]ValidationCacheEXT) -> Result -ProcQueueBeginDebugUtilsLabelEXT :: #type proc "system" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT) -ProcQueueBindSparse :: #type proc "system" (queue: Queue, bindInfoCount: u32, pBindInfo: ^BindSparseInfo, fence: Fence) -> Result -ProcQueueEndDebugUtilsLabelEXT :: #type proc "system" (queue: Queue) -ProcQueueInsertDebugUtilsLabelEXT :: #type proc "system" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT) -ProcQueuePresentKHR :: #type proc "system" (queue: Queue, pPresentInfo: ^PresentInfoKHR) -> Result -ProcQueueSetPerformanceConfigurationINTEL :: #type proc "system" (queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result -ProcQueueSubmit :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo, fence: Fence) -> Result -ProcQueueSubmit2 :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo2, fence: Fence) -> Result -ProcQueueSubmit2KHR :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo2, fence: Fence) -> Result -ProcQueueWaitIdle :: #type proc "system" (queue: Queue) -> Result -ProcRegisterDeviceEventEXT :: #type proc "system" (device: Device, pDeviceEventInfo: ^DeviceEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result -ProcRegisterDisplayEventEXT :: #type proc "system" (device: Device, display: DisplayKHR, pDisplayEventInfo: ^DisplayEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result -ProcReleaseFullScreenExclusiveModeEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result -ProcReleasePerformanceConfigurationINTEL :: #type proc "system" (device: Device, configuration: PerformanceConfigurationINTEL) -> Result -ProcReleaseProfilingLockKHR :: #type proc "system" (device: Device) -ProcResetCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result -ProcResetCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolResetFlags) -> Result -ProcResetDescriptorPool :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, flags: DescriptorPoolResetFlags) -> Result -ProcResetEvent :: #type proc "system" (device: Device, event: Event) -> Result -ProcResetFences :: #type proc "system" (device: Device, fenceCount: u32, pFences: [^]Fence) -> Result -ProcResetQueryPool :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) -ProcResetQueryPoolEXT :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) -ProcSetDebugUtilsObjectNameEXT :: #type proc "system" (device: Device, pNameInfo: ^DebugUtilsObjectNameInfoEXT) -> Result -ProcSetDebugUtilsObjectTagEXT :: #type proc "system" (device: Device, pTagInfo: ^DebugUtilsObjectTagInfoEXT) -> Result -ProcSetDeviceMemoryPriorityEXT :: #type proc "system" (device: Device, memory: DeviceMemory, priority: f32) -ProcSetEvent :: #type proc "system" (device: Device, event: Event) -> Result -ProcSetHdrMetadataEXT :: #type proc "system" (device: Device, swapchainCount: u32, pSwapchains: [^]SwapchainKHR, pMetadata: ^HdrMetadataEXT) -ProcSetLocalDimmingAMD :: #type proc "system" (device: Device, swapChain: SwapchainKHR, localDimmingEnable: b32) -ProcSetPrivateData :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, data: u64) -> Result -ProcSetPrivateDataEXT :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, data: u64) -> Result -ProcSignalSemaphore :: #type proc "system" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result -ProcSignalSemaphoreKHR :: #type proc "system" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result -ProcTrimCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) -ProcTrimCommandPoolKHR :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) -ProcUninitializePerformanceApiINTEL :: #type proc "system" (device: Device) -ProcUnmapMemory :: #type proc "system" (device: Device, memory: DeviceMemory) -ProcUpdateDescriptorSetWithTemplate :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr) -ProcUpdateDescriptorSetWithTemplateKHR :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr) -ProcUpdateDescriptorSets :: #type proc "system" (device: Device, descriptorWriteCount: u32, pDescriptorWrites: [^]WriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: [^]CopyDescriptorSet) -ProcWaitForFences :: #type proc "system" (device: Device, fenceCount: u32, pFences: [^]Fence, waitAll: b32, timeout: u64) -> Result -ProcWaitForPresentKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, presentId: u64, timeout: u64) -> Result -ProcWaitSemaphores :: #type proc "system" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result -ProcWaitSemaphoresKHR :: #type proc "system" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result -ProcWriteAccelerationStructuresPropertiesKHR :: #type proc "system" (device: Device, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureKHR, queryType: QueryType, dataSize: int, pData: rawptr, stride: int) -> Result +ProcAcquireFullScreenExclusiveModeEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result +ProcAcquireNextImage2KHR :: #type proc "system" (device: Device, pAcquireInfo: ^AcquireNextImageInfoKHR, pImageIndex: ^u32) -> Result +ProcAcquireNextImageKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, timeout: u64, semaphore: Semaphore, fence: Fence, pImageIndex: ^u32) -> Result +ProcAcquirePerformanceConfigurationINTEL :: #type proc "system" (device: Device, pAcquireInfo: ^PerformanceConfigurationAcquireInfoINTEL, pConfiguration: ^PerformanceConfigurationINTEL) -> Result +ProcAcquireProfilingLockKHR :: #type proc "system" (device: Device, pInfo: ^AcquireProfilingLockInfoKHR) -> Result +ProcAllocateCommandBuffers :: #type proc "system" (device: Device, pAllocateInfo: ^CommandBufferAllocateInfo, pCommandBuffers: [^]CommandBuffer) -> Result +ProcAllocateDescriptorSets :: #type proc "system" (device: Device, pAllocateInfo: ^DescriptorSetAllocateInfo, pDescriptorSets: [^]DescriptorSet) -> Result +ProcAllocateMemory :: #type proc "system" (device: Device, pAllocateInfo: ^MemoryAllocateInfo, pAllocator: ^AllocationCallbacks, pMemory: ^DeviceMemory) -> Result +ProcBeginCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer, pBeginInfo: ^CommandBufferBeginInfo) -> Result +ProcBindAccelerationStructureMemoryNV :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindAccelerationStructureMemoryInfoNV) -> Result +ProcBindBufferMemory :: #type proc "system" (device: Device, buffer: Buffer, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result +ProcBindBufferMemory2 :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindBufferMemoryInfo) -> Result +ProcBindBufferMemory2KHR :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindBufferMemoryInfo) -> Result +ProcBindImageMemory :: #type proc "system" (device: Device, image: Image, memory: DeviceMemory, memoryOffset: DeviceSize) -> Result +ProcBindImageMemory2 :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindImageMemoryInfo) -> Result +ProcBindImageMemory2KHR :: #type proc "system" (device: Device, bindInfoCount: u32, pBindInfos: [^]BindImageMemoryInfo) -> Result +ProcBindOpticalFlowSessionImageNV :: #type proc "system" (device: Device, session: OpticalFlowSessionNV, bindingPoint: OpticalFlowSessionBindingPointNV, view: ImageView, layout: ImageLayout) -> Result +ProcBindVideoSessionMemoryKHR :: #type proc "system" (device: Device, videoSession: VideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: [^]BindVideoSessionMemoryInfoKHR) -> Result +ProcBuildAccelerationStructuresKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^[^]AccelerationStructureBuildRangeInfoKHR) -> Result +ProcBuildMicromapsEXT :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, infoCount: u32, pInfos: [^]MicromapBuildInfoEXT) -> Result +ProcCmdBeginConditionalRenderingEXT :: #type proc "system" (commandBuffer: CommandBuffer, pConditionalRenderingBegin: ^ConditionalRenderingBeginInfoEXT) +ProcCmdBeginDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT) +ProcCmdBeginQuery :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags) +ProcCmdBeginQueryIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, flags: QueryControlFlags, index: u32) +ProcCmdBeginRenderPass :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, contents: SubpassContents) +ProcCmdBeginRenderPass2 :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo) +ProcCmdBeginRenderPass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pRenderPassBegin: ^RenderPassBeginInfo, pSubpassBeginInfo: ^SubpassBeginInfo) +ProcCmdBeginRendering :: #type proc "system" (commandBuffer: CommandBuffer, pRenderingInfo: ^RenderingInfo) +ProcCmdBeginRenderingKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRenderingInfo: ^RenderingInfo) +ProcCmdBeginTransformFeedbackEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [^]Buffer, pCounterBufferOffsets: [^]DeviceSize) +ProcCmdBeginVideoCodingKHR :: #type proc "system" (commandBuffer: CommandBuffer, pBeginInfo: ^VideoBeginCodingInfoKHR) +ProcCmdBindDescriptorBufferEmbeddedSamplersEXT :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32) +ProcCmdBindDescriptorBuffersEXT :: #type proc "system" (commandBuffer: CommandBuffer, bufferCount: u32, pBindingInfos: [^]DescriptorBufferBindingInfoEXT) +ProcCmdBindDescriptorSets :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: [^]DescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: [^]u32) +ProcCmdBindIndexBuffer :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, indexType: IndexType) +ProcCmdBindInvocationMaskHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout) +ProcCmdBindPipeline :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline) +ProcCmdBindPipelineShaderGroupNV :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, pipeline: Pipeline, groupIndex: u32) +ProcCmdBindShadersEXT :: #type proc "system" (commandBuffer: CommandBuffer, stageCount: u32, pStages: [^]ShaderStageFlags, pShaders: [^]ShaderEXT) +ProcCmdBindShadingRateImageNV :: #type proc "system" (commandBuffer: CommandBuffer, imageView: ImageView, imageLayout: ImageLayout) +ProcCmdBindTransformFeedbackBuffersEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize) +ProcCmdBindVertexBuffers :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize) +ProcCmdBindVertexBuffers2 :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize, pStrides: [^]DeviceSize) +ProcCmdBindVertexBuffers2EXT :: #type proc "system" (commandBuffer: CommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: [^]Buffer, pOffsets: [^]DeviceSize, pSizes: [^]DeviceSize, pStrides: [^]DeviceSize) +ProcCmdBlitImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageBlit, filter: Filter) +ProcCmdBlitImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2) +ProcCmdBlitImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pBlitImageInfo: ^BlitImageInfo2) +ProcCmdBuildAccelerationStructureNV :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^AccelerationStructureInfoNV, instanceData: Buffer, instanceOffset: DeviceSize, update: b32, dst: AccelerationStructureNV, src: AccelerationStructureNV, scratch: Buffer, scratchOffset: DeviceSize) +ProcCmdBuildAccelerationStructuresIndirectKHR :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: [^]DeviceAddress, pIndirectStrides: [^]u32, ppMaxPrimitiveCounts: ^[^]u32) +ProcCmdBuildAccelerationStructuresKHR :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]AccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: ^[^]AccelerationStructureBuildRangeInfoKHR) +ProcCmdBuildMicromapsEXT :: #type proc "system" (commandBuffer: CommandBuffer, infoCount: u32, pInfos: [^]MicromapBuildInfoEXT) +ProcCmdClearAttachments :: #type proc "system" (commandBuffer: CommandBuffer, attachmentCount: u32, pAttachments: [^]ClearAttachment, rectCount: u32, pRects: [^]ClearRect) +ProcCmdClearColorImage :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pColor: ^ClearColorValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange) +ProcCmdClearDepthStencilImage :: #type proc "system" (commandBuffer: CommandBuffer, image: Image, imageLayout: ImageLayout, pDepthStencil: ^ClearDepthStencilValue, rangeCount: u32, pRanges: [^]ImageSubresourceRange) +ProcCmdControlVideoCodingKHR :: #type proc "system" (commandBuffer: CommandBuffer, pCodingControlInfo: ^VideoCodingControlInfoKHR) +ProcCmdCopyAccelerationStructureKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureInfoKHR) +ProcCmdCopyAccelerationStructureNV :: #type proc "system" (commandBuffer: CommandBuffer, dst: AccelerationStructureNV, src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR) +ProcCmdCopyAccelerationStructureToMemoryKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) +ProcCmdCopyBuffer :: #type proc "system" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstBuffer: Buffer, regionCount: u32, pRegions: [^]BufferCopy) +ProcCmdCopyBuffer2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2) +ProcCmdCopyBuffer2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferInfo: ^CopyBufferInfo2) +ProcCmdCopyBufferToImage :: #type proc "system" (commandBuffer: CommandBuffer, srcBuffer: Buffer, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]BufferImageCopy) +ProcCmdCopyBufferToImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2) +ProcCmdCopyBufferToImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyBufferToImageInfo: ^CopyBufferToImageInfo2) +ProcCmdCopyImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageCopy) +ProcCmdCopyImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2) +ProcCmdCopyImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageInfo: ^CopyImageInfo2) +ProcCmdCopyImageToBuffer :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstBuffer: Buffer, regionCount: u32, pRegions: [^]BufferImageCopy) +ProcCmdCopyImageToBuffer2 :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2) +ProcCmdCopyImageToBuffer2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pCopyImageToBufferInfo: ^CopyImageToBufferInfo2) +ProcCmdCopyMemoryIndirectNV :: #type proc "system" (commandBuffer: CommandBuffer, copyBufferAddress: DeviceAddress, copyCount: u32, stride: u32) +ProcCmdCopyMemoryToAccelerationStructureKHR :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) +ProcCmdCopyMemoryToImageIndirectNV :: #type proc "system" (commandBuffer: CommandBuffer, copyBufferAddress: DeviceAddress, copyCount: u32, stride: u32, dstImage: Image, dstImageLayout: ImageLayout, pImageSubresources: [^]ImageSubresourceLayers) +ProcCmdCopyMemoryToMicromapEXT :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyMemoryToMicromapInfoEXT) +ProcCmdCopyMicromapEXT :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyMicromapInfoEXT) +ProcCmdCopyMicromapToMemoryEXT :: #type proc "system" (commandBuffer: CommandBuffer, pInfo: ^CopyMicromapToMemoryInfoEXT) +ProcCmdCopyQueryPoolResults :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dstBuffer: Buffer, dstOffset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags) +ProcCmdCuLaunchKernelNVX :: #type proc "system" (commandBuffer: CommandBuffer, pLaunchInfo: ^CuLaunchInfoNVX) +ProcCmdDebugMarkerBeginEXT :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT) +ProcCmdDebugMarkerEndEXT :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdDebugMarkerInsertEXT :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^DebugMarkerMarkerInfoEXT) +ProcCmdDecodeVideoKHR :: #type proc "system" (commandBuffer: CommandBuffer, pDecodeInfo: ^VideoDecodeInfoKHR) +ProcCmdDecompressMemoryIndirectCountNV :: #type proc "system" (commandBuffer: CommandBuffer, indirectCommandsAddress: DeviceAddress, indirectCommandsCountAddress: DeviceAddress, stride: u32) +ProcCmdDecompressMemoryNV :: #type proc "system" (commandBuffer: CommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: [^]DecompressMemoryRegionNV) +ProcCmdDispatch :: #type proc "system" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) +ProcCmdDispatchBase :: #type proc "system" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) +ProcCmdDispatchBaseKHR :: #type proc "system" (commandBuffer: CommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) +ProcCmdDispatchIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) +ProcCmdDraw :: #type proc "system" (commandBuffer: CommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) +ProcCmdDrawClusterHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) +ProcCmdDrawClusterIndirectHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) +ProcCmdDrawIndexed :: #type proc "system" (commandBuffer: CommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32) +ProcCmdDrawIndexedIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) +ProcCmdDrawIndexedIndirectCount :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawIndexedIndirectCountAMD :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawIndexedIndirectCountKHR :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawIndirect :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) +ProcCmdDrawIndirectByteCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: Buffer, counterBufferOffset: DeviceSize, counterOffset: u32, vertexStride: u32) +ProcCmdDrawIndirectCount :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawIndirectCountAMD :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawIndirectCountKHR :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawMeshTasksEXT :: #type proc "system" (commandBuffer: CommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) +ProcCmdDrawMeshTasksIndirectCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawMeshTasksIndirectCountNV :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, countBuffer: Buffer, countBufferOffset: DeviceSize, maxDrawCount: u32, stride: u32) +ProcCmdDrawMeshTasksIndirectEXT :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) +ProcCmdDrawMeshTasksIndirectNV :: #type proc "system" (commandBuffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, drawCount: u32, stride: u32) +ProcCmdDrawMeshTasksNV :: #type proc "system" (commandBuffer: CommandBuffer, taskCount: u32, firstTask: u32) +ProcCmdDrawMultiEXT :: #type proc "system" (commandBuffer: CommandBuffer, drawCount: u32, pVertexInfo: ^MultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32) +ProcCmdDrawMultiIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, drawCount: u32, pIndexInfo: ^MultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: ^i32) +ProcCmdEndConditionalRenderingEXT :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdEndDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdEndQuery :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32) +ProcCmdEndQueryIndexedEXT :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, query: u32, index: u32) +ProcCmdEndRenderPass :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdEndRenderPass2 :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo) +ProcCmdEndRenderPass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassEndInfo: ^SubpassEndInfo) +ProcCmdEndRendering :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdEndRenderingKHR :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdEndTransformFeedbackEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: [^]Buffer, pCounterBufferOffsets: [^]DeviceSize) +ProcCmdEndVideoCodingKHR :: #type proc "system" (commandBuffer: CommandBuffer, pEndCodingInfo: ^VideoEndCodingInfoKHR) +ProcCmdExecuteCommands :: #type proc "system" (commandBuffer: CommandBuffer, commandBufferCount: u32, pCommandBuffers: [^]CommandBuffer) +ProcCmdExecuteGeneratedCommandsNV :: #type proc "system" (commandBuffer: CommandBuffer, isPreprocessed: b32, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV) +ProcCmdFillBuffer :: #type proc "system" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, size: DeviceSize, data: u32) +ProcCmdInsertDebugUtilsLabelEXT :: #type proc "system" (commandBuffer: CommandBuffer, pLabelInfo: ^DebugUtilsLabelEXT) +ProcCmdNextSubpass :: #type proc "system" (commandBuffer: CommandBuffer, contents: SubpassContents) +ProcCmdNextSubpass2 :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo) +ProcCmdNextSubpass2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pSubpassBeginInfo: ^SubpassBeginInfo, pSubpassEndInfo: ^SubpassEndInfo) +ProcCmdOpticalFlowExecuteNV :: #type proc "system" (commandBuffer: CommandBuffer, session: OpticalFlowSessionNV, pExecuteInfo: ^OpticalFlowExecuteInfoNV) +ProcCmdPipelineBarrier :: #type proc "system" (commandBuffer: CommandBuffer, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, dependencyFlags: DependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: [^]MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [^]BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [^]ImageMemoryBarrier) +ProcCmdPipelineBarrier2 :: #type proc "system" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfo) +ProcCmdPipelineBarrier2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pDependencyInfo: ^DependencyInfo) +ProcCmdPreprocessGeneratedCommandsNV :: #type proc "system" (commandBuffer: CommandBuffer, pGeneratedCommandsInfo: ^GeneratedCommandsInfoNV) +ProcCmdPushConstants :: #type proc "system" (commandBuffer: CommandBuffer, layout: PipelineLayout, stageFlags: ShaderStageFlags, offset: u32, size: u32, pValues: rawptr) +ProcCmdPushDescriptorSetKHR :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: [^]WriteDescriptorSet) +ProcCmdPushDescriptorSetWithTemplateKHR :: #type proc "system" (commandBuffer: CommandBuffer, descriptorUpdateTemplate: DescriptorUpdateTemplate, layout: PipelineLayout, set: u32, pData: rawptr) +ProcCmdResetEvent :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) +ProcCmdResetEvent2 :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2) +ProcCmdResetEvent2KHR :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags2) +ProcCmdResetQueryPool :: #type proc "system" (commandBuffer: CommandBuffer, queryPool: QueryPool, firstQuery: u32, queryCount: u32) +ProcCmdResolveImage :: #type proc "system" (commandBuffer: CommandBuffer, srcImage: Image, srcImageLayout: ImageLayout, dstImage: Image, dstImageLayout: ImageLayout, regionCount: u32, pRegions: [^]ImageResolve) +ProcCmdResolveImage2 :: #type proc "system" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2) +ProcCmdResolveImage2KHR :: #type proc "system" (commandBuffer: CommandBuffer, pResolveImageInfo: ^ResolveImageInfo2) +ProcCmdSetAlphaToCoverageEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, alphaToCoverageEnable: b32) +ProcCmdSetAlphaToOneEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, alphaToOneEnable: b32) +ProcCmdSetAttachmentFeedbackLoopEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, aspectMask: ImageAspectFlags) +ProcCmdSetBlendConstants :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdSetCheckpointNV :: #type proc "system" (commandBuffer: CommandBuffer, pCheckpointMarker: rawptr) +ProcCmdSetCoarseSampleOrderNV :: #type proc "system" (commandBuffer: CommandBuffer, sampleOrderType: CoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: [^]CoarseSampleOrderCustomNV) +ProcCmdSetColorBlendAdvancedEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: ^ColorBlendAdvancedEXT) +ProcCmdSetColorBlendEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: [^]b32) +ProcCmdSetColorBlendEquationEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: [^]ColorBlendEquationEXT) +ProcCmdSetColorWriteMaskEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: [^]ColorComponentFlags) +ProcCmdSetConservativeRasterizationModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, conservativeRasterizationMode: ConservativeRasterizationModeEXT) +ProcCmdSetCoverageModulationModeNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageModulationMode: CoverageModulationModeNV) +ProcCmdSetCoverageModulationTableEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageModulationTableEnable: b32) +ProcCmdSetCoverageModulationTableNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: [^]f32) +ProcCmdSetCoverageReductionModeNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageReductionMode: CoverageReductionModeNV) +ProcCmdSetCoverageToColorEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageToColorEnable: b32) +ProcCmdSetCoverageToColorLocationNV :: #type proc "system" (commandBuffer: CommandBuffer, coverageToColorLocation: u32) +ProcCmdSetCullMode :: #type proc "system" (commandBuffer: CommandBuffer, cullMode: CullModeFlags) +ProcCmdSetCullModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, cullMode: CullModeFlags) +ProcCmdSetDepthBias :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32) +ProcCmdSetDepthBiasEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasEnable: b32) +ProcCmdSetDepthBiasEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthBiasEnable: b32) +ProcCmdSetDepthBounds :: #type proc "system" (commandBuffer: CommandBuffer, minDepthBounds: f32, maxDepthBounds: f32) +ProcCmdSetDepthBoundsTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32) +ProcCmdSetDepthBoundsTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthBoundsTestEnable: b32) +ProcCmdSetDepthClampEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthClampEnable: b32) +ProcCmdSetDepthClipEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthClipEnable: b32) +ProcCmdSetDepthClipNegativeOneToOneEXT :: #type proc "system" (commandBuffer: CommandBuffer, negativeOneToOne: b32) +ProcCmdSetDepthCompareOp :: #type proc "system" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp) +ProcCmdSetDepthCompareOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthCompareOp: CompareOp) +ProcCmdSetDepthTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthTestEnable: b32) +ProcCmdSetDepthTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthTestEnable: b32) +ProcCmdSetDepthWriteEnable :: #type proc "system" (commandBuffer: CommandBuffer, depthWriteEnable: b32) +ProcCmdSetDepthWriteEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, depthWriteEnable: b32) +ProcCmdSetDescriptorBufferOffsetsEXT :: #type proc "system" (commandBuffer: CommandBuffer, pipelineBindPoint: PipelineBindPoint, layout: PipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: [^]u32, pOffsets: [^]DeviceSize) +ProcCmdSetDeviceMask :: #type proc "system" (commandBuffer: CommandBuffer, deviceMask: u32) +ProcCmdSetDeviceMaskKHR :: #type proc "system" (commandBuffer: CommandBuffer, deviceMask: u32) +ProcCmdSetDiscardRectangleEXT :: #type proc "system" (commandBuffer: CommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: [^]Rect2D) +ProcCmdSetDiscardRectangleEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, discardRectangleEnable: b32) +ProcCmdSetDiscardRectangleModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, discardRectangleMode: DiscardRectangleModeEXT) +ProcCmdSetEvent :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, stageMask: PipelineStageFlags) +ProcCmdSetEvent2 :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfo) +ProcCmdSetEvent2KHR :: #type proc "system" (commandBuffer: CommandBuffer, event: Event, pDependencyInfo: ^DependencyInfo) +ProcCmdSetExclusiveScissorEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: [^]b32) +ProcCmdSetExclusiveScissorNV :: #type proc "system" (commandBuffer: CommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: [^]Rect2D) +ProcCmdSetExtraPrimitiveOverestimationSizeEXT :: #type proc "system" (commandBuffer: CommandBuffer, extraPrimitiveOverestimationSize: f32) +ProcCmdSetFragmentShadingRateEnumNV :: #type proc "system" (commandBuffer: CommandBuffer, shadingRate: FragmentShadingRateNV) +ProcCmdSetFragmentShadingRateKHR :: #type proc "system" (commandBuffer: CommandBuffer, pFragmentSize: ^Extent2D) +ProcCmdSetFrontFace :: #type proc "system" (commandBuffer: CommandBuffer, frontFace: FrontFace) +ProcCmdSetFrontFaceEXT :: #type proc "system" (commandBuffer: CommandBuffer, frontFace: FrontFace) +ProcCmdSetLineRasterizationModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, lineRasterizationMode: LineRasterizationModeEXT) +ProcCmdSetLineStippleEXT :: #type proc "system" (commandBuffer: CommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16) +ProcCmdSetLineStippleEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, stippledLineEnable: b32) +ProcCmdSetLineWidth :: #type proc "system" (commandBuffer: CommandBuffer, lineWidth: f32) +ProcCmdSetLogicOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, logicOp: LogicOp) +ProcCmdSetLogicOpEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, logicOpEnable: b32) +ProcCmdSetPatchControlPointsEXT :: #type proc "system" (commandBuffer: CommandBuffer, patchControlPoints: u32) +ProcCmdSetPerformanceMarkerINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceMarkerInfoINTEL) -> Result +ProcCmdSetPerformanceOverrideINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pOverrideInfo: ^PerformanceOverrideInfoINTEL) -> Result +ProcCmdSetPerformanceStreamMarkerINTEL :: #type proc "system" (commandBuffer: CommandBuffer, pMarkerInfo: ^PerformanceStreamMarkerInfoINTEL) -> Result +ProcCmdSetPolygonModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, polygonMode: PolygonMode) +ProcCmdSetPrimitiveRestartEnable :: #type proc "system" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32) +ProcCmdSetPrimitiveRestartEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, primitiveRestartEnable: b32) +ProcCmdSetPrimitiveTopology :: #type proc "system" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology) +ProcCmdSetPrimitiveTopologyEXT :: #type proc "system" (commandBuffer: CommandBuffer, primitiveTopology: PrimitiveTopology) +ProcCmdSetProvokingVertexModeEXT :: #type proc "system" (commandBuffer: CommandBuffer, provokingVertexMode: ProvokingVertexModeEXT) +ProcCmdSetRasterizationSamplesEXT :: #type proc "system" (commandBuffer: CommandBuffer, rasterizationSamples: SampleCountFlags) +ProcCmdSetRasterizationStreamEXT :: #type proc "system" (commandBuffer: CommandBuffer, rasterizationStream: u32) +ProcCmdSetRasterizerDiscardEnable :: #type proc "system" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32) +ProcCmdSetRasterizerDiscardEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, rasterizerDiscardEnable: b32) +ProcCmdSetRayTracingPipelineStackSizeKHR :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStackSize: u32) +ProcCmdSetRepresentativeFragmentTestEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, representativeFragmentTestEnable: b32) +ProcCmdSetSampleLocationsEXT :: #type proc "system" (commandBuffer: CommandBuffer, pSampleLocationsInfo: ^SampleLocationsInfoEXT) +ProcCmdSetSampleLocationsEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, sampleLocationsEnable: b32) +ProcCmdSetSampleMaskEXT :: #type proc "system" (commandBuffer: CommandBuffer, samples: SampleCountFlags, pSampleMask: ^SampleMask) +ProcCmdSetScissor :: #type proc "system" (commandBuffer: CommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: [^]Rect2D) +ProcCmdSetScissorWithCount :: #type proc "system" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: [^]Rect2D) +ProcCmdSetScissorWithCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, scissorCount: u32, pScissors: [^]Rect2D) +ProcCmdSetShadingRateImageEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, shadingRateImageEnable: b32) +ProcCmdSetStencilCompareMask :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, compareMask: u32) +ProcCmdSetStencilOp :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp) +ProcCmdSetStencilOpEXT :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, failOp: StencilOp, passOp: StencilOp, depthFailOp: StencilOp, compareOp: CompareOp) +ProcCmdSetStencilReference :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, reference: u32) +ProcCmdSetStencilTestEnable :: #type proc "system" (commandBuffer: CommandBuffer, stencilTestEnable: b32) +ProcCmdSetStencilTestEnableEXT :: #type proc "system" (commandBuffer: CommandBuffer, stencilTestEnable: b32) +ProcCmdSetStencilWriteMask :: #type proc "system" (commandBuffer: CommandBuffer, faceMask: StencilFaceFlags, writeMask: u32) +ProcCmdSetTessellationDomainOriginEXT :: #type proc "system" (commandBuffer: CommandBuffer, domainOrigin: TessellationDomainOrigin) +ProcCmdSetVertexInputEXT :: #type proc "system" (commandBuffer: CommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: [^]VertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: [^]VertexInputAttributeDescription2EXT) +ProcCmdSetViewport :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: [^]Viewport) +ProcCmdSetViewportShadingRatePaletteNV :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: [^]ShadingRatePaletteNV) +ProcCmdSetViewportSwizzleNV :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: [^]ViewportSwizzleNV) +ProcCmdSetViewportWScalingEnableNV :: #type proc "system" (commandBuffer: CommandBuffer, viewportWScalingEnable: b32) +ProcCmdSetViewportWScalingNV :: #type proc "system" (commandBuffer: CommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: [^]ViewportWScalingNV) +ProcCmdSetViewportWithCount :: #type proc "system" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: [^]Viewport) +ProcCmdSetViewportWithCountEXT :: #type proc "system" (commandBuffer: CommandBuffer, viewportCount: u32, pViewports: [^]Viewport) +ProcCmdSubpassShadingHUAWEI :: #type proc "system" (commandBuffer: CommandBuffer) +ProcCmdTraceRaysIndirect2KHR :: #type proc "system" (commandBuffer: CommandBuffer, indirectDeviceAddress: DeviceAddress) +ProcCmdTraceRaysIndirectKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pMissShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pHitShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: [^]StridedDeviceAddressRegionKHR, indirectDeviceAddress: DeviceAddress) +ProcCmdTraceRaysKHR :: #type proc "system" (commandBuffer: CommandBuffer, pRaygenShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pMissShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pHitShaderBindingTable: [^]StridedDeviceAddressRegionKHR, pCallableShaderBindingTable: [^]StridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32) +ProcCmdTraceRaysNV :: #type proc "system" (commandBuffer: CommandBuffer, raygenShaderBindingTableBuffer: Buffer, raygenShaderBindingOffset: DeviceSize, missShaderBindingTableBuffer: Buffer, missShaderBindingOffset: DeviceSize, missShaderBindingStride: DeviceSize, hitShaderBindingTableBuffer: Buffer, hitShaderBindingOffset: DeviceSize, hitShaderBindingStride: DeviceSize, callableShaderBindingTableBuffer: Buffer, callableShaderBindingOffset: DeviceSize, callableShaderBindingStride: DeviceSize, width: u32, height: u32, depth: u32) +ProcCmdUpdateBuffer :: #type proc "system" (commandBuffer: CommandBuffer, dstBuffer: Buffer, dstOffset: DeviceSize, dataSize: DeviceSize, pData: rawptr) +ProcCmdWaitEvents :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, srcStageMask: PipelineStageFlags, dstStageMask: PipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: [^]MemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: [^]BufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: [^]ImageMemoryBarrier) +ProcCmdWaitEvents2 :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, pDependencyInfos: [^]DependencyInfo) +ProcCmdWaitEvents2KHR :: #type proc "system" (commandBuffer: CommandBuffer, eventCount: u32, pEvents: [^]Event, pDependencyInfos: [^]DependencyInfo) +ProcCmdWriteAccelerationStructuresPropertiesKHR :: #type proc "system" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureKHR, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) +ProcCmdWriteAccelerationStructuresPropertiesNV :: #type proc "system" (commandBuffer: CommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureNV, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) +ProcCmdWriteBufferMarker2AMD :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32) +ProcCmdWriteBufferMarkerAMD :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, dstBuffer: Buffer, dstOffset: DeviceSize, marker: u32) +ProcCmdWriteMicromapsPropertiesEXT :: #type proc "system" (commandBuffer: CommandBuffer, micromapCount: u32, pMicromaps: [^]MicromapEXT, queryType: QueryType, queryPool: QueryPool, firstQuery: u32) +ProcCmdWriteTimestamp :: #type proc "system" (commandBuffer: CommandBuffer, pipelineStage: PipelineStageFlags, queryPool: QueryPool, query: u32) +ProcCmdWriteTimestamp2 :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32) +ProcCmdWriteTimestamp2KHR :: #type proc "system" (commandBuffer: CommandBuffer, stage: PipelineStageFlags2, queryPool: QueryPool, query: u32) +ProcCompileDeferredNV :: #type proc "system" (device: Device, pipeline: Pipeline, shader: u32) -> Result +ProcCopyAccelerationStructureKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureInfoKHR) -> Result +ProcCopyAccelerationStructureToMemoryKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyAccelerationStructureToMemoryInfoKHR) -> Result +ProcCopyMemoryToAccelerationStructureKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMemoryToAccelerationStructureInfoKHR) -> Result +ProcCopyMemoryToMicromapEXT :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMemoryToMicromapInfoEXT) -> Result +ProcCopyMicromapEXT :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMicromapInfoEXT) -> Result +ProcCopyMicromapToMemoryEXT :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pInfo: ^CopyMicromapToMemoryInfoEXT) -> Result +ProcCreateAccelerationStructureKHR :: #type proc "system" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoKHR, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureKHR) -> Result +ProcCreateAccelerationStructureNV :: #type proc "system" (device: Device, pCreateInfo: ^AccelerationStructureCreateInfoNV, pAllocator: ^AllocationCallbacks, pAccelerationStructure: ^AccelerationStructureNV) -> Result +ProcCreateBuffer :: #type proc "system" (device: Device, pCreateInfo: ^BufferCreateInfo, pAllocator: ^AllocationCallbacks, pBuffer: ^Buffer) -> Result +ProcCreateBufferView :: #type proc "system" (device: Device, pCreateInfo: ^BufferViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^BufferView) -> Result +ProcCreateCommandPool :: #type proc "system" (device: Device, pCreateInfo: ^CommandPoolCreateInfo, pAllocator: ^AllocationCallbacks, pCommandPool: ^CommandPool) -> Result +ProcCreateComputePipelines :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]ComputePipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result +ProcCreateCuFunctionNVX :: #type proc "system" (device: Device, pCreateInfo: ^CuFunctionCreateInfoNVX, pAllocator: ^AllocationCallbacks, pFunction: ^CuFunctionNVX) -> Result +ProcCreateCuModuleNVX :: #type proc "system" (device: Device, pCreateInfo: ^CuModuleCreateInfoNVX, pAllocator: ^AllocationCallbacks, pModule: ^CuModuleNVX) -> Result +ProcCreateDeferredOperationKHR :: #type proc "system" (device: Device, pAllocator: ^AllocationCallbacks, pDeferredOperation: ^DeferredOperationKHR) -> Result +ProcCreateDescriptorPool :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorPoolCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorPool: ^DescriptorPool) -> Result +ProcCreateDescriptorSetLayout :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pSetLayout: ^DescriptorSetLayout) -> Result +ProcCreateDescriptorUpdateTemplate :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result +ProcCreateDescriptorUpdateTemplateKHR :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorUpdateTemplateCreateInfo, pAllocator: ^AllocationCallbacks, pDescriptorUpdateTemplate: ^DescriptorUpdateTemplate) -> Result +ProcCreateEvent :: #type proc "system" (device: Device, pCreateInfo: ^EventCreateInfo, pAllocator: ^AllocationCallbacks, pEvent: ^Event) -> Result +ProcCreateFence :: #type proc "system" (device: Device, pCreateInfo: ^FenceCreateInfo, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result +ProcCreateFramebuffer :: #type proc "system" (device: Device, pCreateInfo: ^FramebufferCreateInfo, pAllocator: ^AllocationCallbacks, pFramebuffer: ^Framebuffer) -> Result +ProcCreateGraphicsPipelines :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]GraphicsPipelineCreateInfo, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result +ProcCreateImage :: #type proc "system" (device: Device, pCreateInfo: ^ImageCreateInfo, pAllocator: ^AllocationCallbacks, pImage: ^Image) -> Result +ProcCreateImageView :: #type proc "system" (device: Device, pCreateInfo: ^ImageViewCreateInfo, pAllocator: ^AllocationCallbacks, pView: ^ImageView) -> Result +ProcCreateIndirectCommandsLayoutNV :: #type proc "system" (device: Device, pCreateInfo: ^IndirectCommandsLayoutCreateInfoNV, pAllocator: ^AllocationCallbacks, pIndirectCommandsLayout: ^IndirectCommandsLayoutNV) -> Result +ProcCreateMicromapEXT :: #type proc "system" (device: Device, pCreateInfo: ^MicromapCreateInfoEXT, pAllocator: ^AllocationCallbacks, pMicromap: ^MicromapEXT) -> Result +ProcCreateOpticalFlowSessionNV :: #type proc "system" (device: Device, pCreateInfo: ^OpticalFlowSessionCreateInfoNV, pAllocator: ^AllocationCallbacks, pSession: ^OpticalFlowSessionNV) -> Result +ProcCreatePipelineCache :: #type proc "system" (device: Device, pCreateInfo: ^PipelineCacheCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineCache: ^PipelineCache) -> Result +ProcCreatePipelineLayout :: #type proc "system" (device: Device, pCreateInfo: ^PipelineLayoutCreateInfo, pAllocator: ^AllocationCallbacks, pPipelineLayout: ^PipelineLayout) -> Result +ProcCreatePrivateDataSlot :: #type proc "system" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfo, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlot) -> Result +ProcCreatePrivateDataSlotEXT :: #type proc "system" (device: Device, pCreateInfo: ^PrivateDataSlotCreateInfo, pAllocator: ^AllocationCallbacks, pPrivateDataSlot: ^PrivateDataSlot) -> Result +ProcCreateQueryPool :: #type proc "system" (device: Device, pCreateInfo: ^QueryPoolCreateInfo, pAllocator: ^AllocationCallbacks, pQueryPool: ^QueryPool) -> Result +ProcCreateRayTracingPipelinesKHR :: #type proc "system" (device: Device, deferredOperation: DeferredOperationKHR, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]RayTracingPipelineCreateInfoKHR, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result +ProcCreateRayTracingPipelinesNV :: #type proc "system" (device: Device, pipelineCache: PipelineCache, createInfoCount: u32, pCreateInfos: [^]RayTracingPipelineCreateInfoNV, pAllocator: ^AllocationCallbacks, pPipelines: [^]Pipeline) -> Result +ProcCreateRenderPass :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result +ProcCreateRenderPass2 :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result +ProcCreateRenderPass2KHR :: #type proc "system" (device: Device, pCreateInfo: ^RenderPassCreateInfo2, pAllocator: ^AllocationCallbacks, pRenderPass: [^]RenderPass) -> Result +ProcCreateSampler :: #type proc "system" (device: Device, pCreateInfo: ^SamplerCreateInfo, pAllocator: ^AllocationCallbacks, pSampler: ^Sampler) -> Result +ProcCreateSamplerYcbcrConversion :: #type proc "system" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result +ProcCreateSamplerYcbcrConversionKHR :: #type proc "system" (device: Device, pCreateInfo: ^SamplerYcbcrConversionCreateInfo, pAllocator: ^AllocationCallbacks, pYcbcrConversion: ^SamplerYcbcrConversion) -> Result +ProcCreateSemaphore :: #type proc "system" (device: Device, pCreateInfo: ^SemaphoreCreateInfo, pAllocator: ^AllocationCallbacks, pSemaphore: ^Semaphore) -> Result +ProcCreateShaderModule :: #type proc "system" (device: Device, pCreateInfo: ^ShaderModuleCreateInfo, pAllocator: ^AllocationCallbacks, pShaderModule: ^ShaderModule) -> Result +ProcCreateShadersEXT :: #type proc "system" (device: Device, createInfoCount: u32, pCreateInfos: [^]ShaderCreateInfoEXT, pAllocator: ^AllocationCallbacks, pShaders: [^]ShaderEXT) -> Result +ProcCreateSharedSwapchainsKHR :: #type proc "system" (device: Device, swapchainCount: u32, pCreateInfos: [^]SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchains: [^]SwapchainKHR) -> Result +ProcCreateSwapchainKHR :: #type proc "system" (device: Device, pCreateInfo: ^SwapchainCreateInfoKHR, pAllocator: ^AllocationCallbacks, pSwapchain: ^SwapchainKHR) -> Result +ProcCreateValidationCacheEXT :: #type proc "system" (device: Device, pCreateInfo: ^ValidationCacheCreateInfoEXT, pAllocator: ^AllocationCallbacks, pValidationCache: ^ValidationCacheEXT) -> Result +ProcCreateVideoSessionKHR :: #type proc "system" (device: Device, pCreateInfo: ^VideoSessionCreateInfoKHR, pAllocator: ^AllocationCallbacks, pVideoSession: ^VideoSessionKHR) -> Result +ProcCreateVideoSessionParametersKHR :: #type proc "system" (device: Device, pCreateInfo: ^VideoSessionParametersCreateInfoKHR, pAllocator: ^AllocationCallbacks, pVideoSessionParameters: [^]VideoSessionParametersKHR) -> Result +ProcDebugMarkerSetObjectNameEXT :: #type proc "system" (device: Device, pNameInfo: ^DebugMarkerObjectNameInfoEXT) -> Result +ProcDebugMarkerSetObjectTagEXT :: #type proc "system" (device: Device, pTagInfo: ^DebugMarkerObjectTagInfoEXT) -> Result +ProcDeferredOperationJoinKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> Result +ProcDestroyAccelerationStructureKHR :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureKHR, pAllocator: ^AllocationCallbacks) +ProcDestroyAccelerationStructureNV :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureNV, pAllocator: ^AllocationCallbacks) +ProcDestroyBuffer :: #type proc "system" (device: Device, buffer: Buffer, pAllocator: ^AllocationCallbacks) +ProcDestroyBufferView :: #type proc "system" (device: Device, bufferView: BufferView, pAllocator: ^AllocationCallbacks) +ProcDestroyCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, pAllocator: ^AllocationCallbacks) +ProcDestroyCuFunctionNVX :: #type proc "system" (device: Device, function: CuFunctionNVX, pAllocator: ^AllocationCallbacks) +ProcDestroyCuModuleNVX :: #type proc "system" (device: Device, module: CuModuleNVX, pAllocator: ^AllocationCallbacks) +ProcDestroyDeferredOperationKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR, pAllocator: ^AllocationCallbacks) +ProcDestroyDescriptorPool :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, pAllocator: ^AllocationCallbacks) +ProcDestroyDescriptorSetLayout :: #type proc "system" (device: Device, descriptorSetLayout: DescriptorSetLayout, pAllocator: ^AllocationCallbacks) +ProcDestroyDescriptorUpdateTemplate :: #type proc "system" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks) +ProcDestroyDescriptorUpdateTemplateKHR :: #type proc "system" (device: Device, descriptorUpdateTemplate: DescriptorUpdateTemplate, pAllocator: ^AllocationCallbacks) +ProcDestroyDevice :: #type proc "system" (device: Device, pAllocator: ^AllocationCallbacks) +ProcDestroyEvent :: #type proc "system" (device: Device, event: Event, pAllocator: ^AllocationCallbacks) +ProcDestroyFence :: #type proc "system" (device: Device, fence: Fence, pAllocator: ^AllocationCallbacks) +ProcDestroyFramebuffer :: #type proc "system" (device: Device, framebuffer: Framebuffer, pAllocator: ^AllocationCallbacks) +ProcDestroyImage :: #type proc "system" (device: Device, image: Image, pAllocator: ^AllocationCallbacks) +ProcDestroyImageView :: #type proc "system" (device: Device, imageView: ImageView, pAllocator: ^AllocationCallbacks) +ProcDestroyIndirectCommandsLayoutNV :: #type proc "system" (device: Device, indirectCommandsLayout: IndirectCommandsLayoutNV, pAllocator: ^AllocationCallbacks) +ProcDestroyMicromapEXT :: #type proc "system" (device: Device, micromap: MicromapEXT, pAllocator: ^AllocationCallbacks) +ProcDestroyOpticalFlowSessionNV :: #type proc "system" (device: Device, session: OpticalFlowSessionNV, pAllocator: ^AllocationCallbacks) +ProcDestroyPipeline :: #type proc "system" (device: Device, pipeline: Pipeline, pAllocator: ^AllocationCallbacks) +ProcDestroyPipelineCache :: #type proc "system" (device: Device, pipelineCache: PipelineCache, pAllocator: ^AllocationCallbacks) +ProcDestroyPipelineLayout :: #type proc "system" (device: Device, pipelineLayout: PipelineLayout, pAllocator: ^AllocationCallbacks) +ProcDestroyPrivateDataSlot :: #type proc "system" (device: Device, privateDataSlot: PrivateDataSlot, pAllocator: ^AllocationCallbacks) +ProcDestroyPrivateDataSlotEXT :: #type proc "system" (device: Device, privateDataSlot: PrivateDataSlot, pAllocator: ^AllocationCallbacks) +ProcDestroyQueryPool :: #type proc "system" (device: Device, queryPool: QueryPool, pAllocator: ^AllocationCallbacks) +ProcDestroyRenderPass :: #type proc "system" (device: Device, renderPass: RenderPass, pAllocator: ^AllocationCallbacks) +ProcDestroySampler :: #type proc "system" (device: Device, sampler: Sampler, pAllocator: ^AllocationCallbacks) +ProcDestroySamplerYcbcrConversion :: #type proc "system" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks) +ProcDestroySamplerYcbcrConversionKHR :: #type proc "system" (device: Device, ycbcrConversion: SamplerYcbcrConversion, pAllocator: ^AllocationCallbacks) +ProcDestroySemaphore :: #type proc "system" (device: Device, semaphore: Semaphore, pAllocator: ^AllocationCallbacks) +ProcDestroyShaderEXT :: #type proc "system" (device: Device, shader: ShaderEXT, pAllocator: ^AllocationCallbacks) +ProcDestroyShaderModule :: #type proc "system" (device: Device, shaderModule: ShaderModule, pAllocator: ^AllocationCallbacks) +ProcDestroySwapchainKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pAllocator: ^AllocationCallbacks) +ProcDestroyValidationCacheEXT :: #type proc "system" (device: Device, validationCache: ValidationCacheEXT, pAllocator: ^AllocationCallbacks) +ProcDestroyVideoSessionKHR :: #type proc "system" (device: Device, videoSession: VideoSessionKHR, pAllocator: ^AllocationCallbacks) +ProcDestroyVideoSessionParametersKHR :: #type proc "system" (device: Device, videoSessionParameters: VideoSessionParametersKHR, pAllocator: ^AllocationCallbacks) +ProcDeviceWaitIdle :: #type proc "system" (device: Device) -> Result +ProcDisplayPowerControlEXT :: #type proc "system" (device: Device, display: DisplayKHR, pDisplayPowerInfo: ^DisplayPowerInfoEXT) -> Result +ProcEndCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer) -> Result +ProcExportMetalObjectsEXT :: #type proc "system" (device: Device, pMetalObjectsInfo: ^ExportMetalObjectsInfoEXT) +ProcFlushMappedMemoryRanges :: #type proc "system" (device: Device, memoryRangeCount: u32, pMemoryRanges: [^]MappedMemoryRange) -> Result +ProcFreeCommandBuffers :: #type proc "system" (device: Device, commandPool: CommandPool, commandBufferCount: u32, pCommandBuffers: [^]CommandBuffer) +ProcFreeDescriptorSets :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, descriptorSetCount: u32, pDescriptorSets: [^]DescriptorSet) -> Result +ProcFreeMemory :: #type proc "system" (device: Device, memory: DeviceMemory, pAllocator: ^AllocationCallbacks) +ProcGetAccelerationStructureBuildSizesKHR :: #type proc "system" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^AccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: [^]u32, pSizeInfo: ^AccelerationStructureBuildSizesInfoKHR) +ProcGetAccelerationStructureDeviceAddressKHR :: #type proc "system" (device: Device, pInfo: ^AccelerationStructureDeviceAddressInfoKHR) -> DeviceAddress +ProcGetAccelerationStructureHandleNV :: #type proc "system" (device: Device, accelerationStructure: AccelerationStructureNV, dataSize: int, pData: rawptr) -> Result +ProcGetAccelerationStructureMemoryRequirementsNV :: #type proc "system" (device: Device, pInfo: ^AccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: [^]MemoryRequirements2KHR) +ProcGetAccelerationStructureOpaqueCaptureDescriptorDataEXT :: #type proc "system" (device: Device, pInfo: ^AccelerationStructureCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result +ProcGetBufferDeviceAddress :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress +ProcGetBufferDeviceAddressEXT :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress +ProcGetBufferDeviceAddressKHR :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> DeviceAddress +ProcGetBufferMemoryRequirements :: #type proc "system" (device: Device, buffer: Buffer, pMemoryRequirements: [^]MemoryRequirements) +ProcGetBufferMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetBufferMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^BufferMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetBufferOpaqueCaptureAddress :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64 +ProcGetBufferOpaqueCaptureAddressKHR :: #type proc "system" (device: Device, pInfo: ^BufferDeviceAddressInfo) -> u64 +ProcGetBufferOpaqueCaptureDescriptorDataEXT :: #type proc "system" (device: Device, pInfo: ^BufferCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result +ProcGetCalibratedTimestampsEXT :: #type proc "system" (device: Device, timestampCount: u32, pTimestampInfos: [^]CalibratedTimestampInfoEXT, pTimestamps: [^]u64, pMaxDeviation: ^u64) -> Result +ProcGetDeferredOperationMaxConcurrencyKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> u32 +ProcGetDeferredOperationResultKHR :: #type proc "system" (device: Device, operation: DeferredOperationKHR) -> Result +ProcGetDescriptorEXT :: #type proc "system" (device: Device, pDescriptorInfo: ^DescriptorGetInfoEXT, dataSize: int, pDescriptor: rawptr) +ProcGetDescriptorSetHostMappingVALVE :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, ppData: ^rawptr) +ProcGetDescriptorSetLayoutBindingOffsetEXT :: #type proc "system" (device: Device, layout: DescriptorSetLayout, binding: u32, pOffset: ^DeviceSize) +ProcGetDescriptorSetLayoutHostMappingInfoVALVE :: #type proc "system" (device: Device, pBindingReference: ^DescriptorSetBindingReferenceVALVE, pHostMapping: ^DescriptorSetLayoutHostMappingInfoVALVE) +ProcGetDescriptorSetLayoutSizeEXT :: #type proc "system" (device: Device, layout: DescriptorSetLayout, pLayoutSizeInBytes: [^]DeviceSize) +ProcGetDescriptorSetLayoutSupport :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport) +ProcGetDescriptorSetLayoutSupportKHR :: #type proc "system" (device: Device, pCreateInfo: ^DescriptorSetLayoutCreateInfo, pSupport: ^DescriptorSetLayoutSupport) +ProcGetDeviceAccelerationStructureCompatibilityKHR :: #type proc "system" (device: Device, pVersionInfo: ^AccelerationStructureVersionInfoKHR, pCompatibility: ^AccelerationStructureCompatibilityKHR) +ProcGetDeviceBufferMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceBufferMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetDeviceBufferMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceBufferMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetDeviceFaultInfoEXT :: #type proc "system" (device: Device, pFaultCounts: [^]DeviceFaultCountsEXT, pFaultInfo: ^DeviceFaultInfoEXT) -> Result +ProcGetDeviceGroupPeerMemoryFeatures :: #type proc "system" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [^]PeerMemoryFeatureFlags) +ProcGetDeviceGroupPeerMemoryFeaturesKHR :: #type proc "system" (device: Device, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: [^]PeerMemoryFeatureFlags) +ProcGetDeviceGroupPresentCapabilitiesKHR :: #type proc "system" (device: Device, pDeviceGroupPresentCapabilities: [^]DeviceGroupPresentCapabilitiesKHR) -> Result +ProcGetDeviceGroupSurfacePresentModes2EXT :: #type proc "system" (device: Device, pSurfaceInfo: ^PhysicalDeviceSurfaceInfo2KHR, pModes: [^]DeviceGroupPresentModeFlagsKHR) -> Result +ProcGetDeviceGroupSurfacePresentModesKHR :: #type proc "system" (device: Device, surface: SurfaceKHR, pModes: [^]DeviceGroupPresentModeFlagsKHR) -> Result +ProcGetDeviceImageMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetDeviceImageMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetDeviceImageSparseMemoryRequirements :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) +ProcGetDeviceImageSparseMemoryRequirementsKHR :: #type proc "system" (device: Device, pInfo: ^DeviceImageMemoryRequirements, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) +ProcGetDeviceMemoryCommitment :: #type proc "system" (device: Device, memory: DeviceMemory, pCommittedMemoryInBytes: [^]DeviceSize) +ProcGetDeviceMemoryOpaqueCaptureAddress :: #type proc "system" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64 +ProcGetDeviceMemoryOpaqueCaptureAddressKHR :: #type proc "system" (device: Device, pInfo: ^DeviceMemoryOpaqueCaptureAddressInfo) -> u64 +ProcGetDeviceMicromapCompatibilityEXT :: #type proc "system" (device: Device, pVersionInfo: ^MicromapVersionInfoEXT, pCompatibility: ^AccelerationStructureCompatibilityKHR) +ProcGetDeviceProcAddr :: #type proc "system" (device: Device, pName: cstring) -> ProcVoidFunction +ProcGetDeviceQueue :: #type proc "system" (device: Device, queueFamilyIndex: u32, queueIndex: u32, pQueue: ^Queue) +ProcGetDeviceQueue2 :: #type proc "system" (device: Device, pQueueInfo: ^DeviceQueueInfo2, pQueue: ^Queue) +ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI :: #type proc "system" (device: Device, renderpass: RenderPass, pMaxWorkgroupSize: ^Extent2D) -> Result +ProcGetDynamicRenderingTilePropertiesQCOM :: #type proc "system" (device: Device, pRenderingInfo: ^RenderingInfo, pProperties: [^]TilePropertiesQCOM) -> Result +ProcGetEventStatus :: #type proc "system" (device: Device, event: Event) -> Result +ProcGetFenceFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^FenceGetFdInfoKHR, pFd: ^c.int) -> Result +ProcGetFenceStatus :: #type proc "system" (device: Device, fence: Fence) -> Result +ProcGetFenceWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^FenceGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result +ProcGetFramebufferTilePropertiesQCOM :: #type proc "system" (device: Device, framebuffer: Framebuffer, pPropertiesCount: ^u32, pProperties: [^]TilePropertiesQCOM) -> Result +ProcGetGeneratedCommandsMemoryRequirementsNV :: #type proc "system" (device: Device, pInfo: ^GeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetImageDrmFormatModifierPropertiesEXT :: #type proc "system" (device: Device, image: Image, pProperties: [^]ImageDrmFormatModifierPropertiesEXT) -> Result +ProcGetImageMemoryRequirements :: #type proc "system" (device: Device, image: Image, pMemoryRequirements: [^]MemoryRequirements) +ProcGetImageMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetImageMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^ImageMemoryRequirementsInfo2, pMemoryRequirements: [^]MemoryRequirements2) +ProcGetImageOpaqueCaptureDescriptorDataEXT :: #type proc "system" (device: Device, pInfo: ^ImageCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result +ProcGetImageSparseMemoryRequirements :: #type proc "system" (device: Device, image: Image, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements) +ProcGetImageSparseMemoryRequirements2 :: #type proc "system" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) +ProcGetImageSparseMemoryRequirements2KHR :: #type proc "system" (device: Device, pInfo: ^ImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: ^u32, pSparseMemoryRequirements: [^]SparseImageMemoryRequirements2) +ProcGetImageSubresourceLayout :: #type proc "system" (device: Device, image: Image, pSubresource: ^ImageSubresource, pLayout: ^SubresourceLayout) +ProcGetImageSubresourceLayout2EXT :: #type proc "system" (device: Device, image: Image, pSubresource: ^ImageSubresource2EXT, pLayout: ^SubresourceLayout2EXT) +ProcGetImageViewAddressNVX :: #type proc "system" (device: Device, imageView: ImageView, pProperties: [^]ImageViewAddressPropertiesNVX) -> Result +ProcGetImageViewHandleNVX :: #type proc "system" (device: Device, pInfo: ^ImageViewHandleInfoNVX) -> u32 +ProcGetImageViewOpaqueCaptureDescriptorDataEXT :: #type proc "system" (device: Device, pInfo: ^ImageViewCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result +ProcGetMemoryFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^MemoryGetFdInfoKHR, pFd: ^c.int) -> Result +ProcGetMemoryFdPropertiesKHR :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, fd: c.int, pMemoryFdProperties: [^]MemoryFdPropertiesKHR) -> Result +ProcGetMemoryHostPointerPropertiesEXT :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, pHostPointer: rawptr, pMemoryHostPointerProperties: [^]MemoryHostPointerPropertiesEXT) -> Result +ProcGetMemoryRemoteAddressNV :: #type proc "system" (device: Device, pMemoryGetRemoteAddressInfo: ^MemoryGetRemoteAddressInfoNV, pAddress: [^]RemoteAddressNV) -> Result +ProcGetMemoryWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^MemoryGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result +ProcGetMemoryWin32HandleNV :: #type proc "system" (device: Device, memory: DeviceMemory, handleType: ExternalMemoryHandleTypeFlagsNV, pHandle: ^HANDLE) -> Result +ProcGetMemoryWin32HandlePropertiesKHR :: #type proc "system" (device: Device, handleType: ExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: [^]MemoryWin32HandlePropertiesKHR) -> Result +ProcGetMicromapBuildSizesEXT :: #type proc "system" (device: Device, buildType: AccelerationStructureBuildTypeKHR, pBuildInfo: ^MicromapBuildInfoEXT, pSizeInfo: ^MicromapBuildSizesInfoEXT) +ProcGetPastPresentationTimingGOOGLE :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pPresentationTimingCount: ^u32, pPresentationTimings: [^]PastPresentationTimingGOOGLE) -> Result +ProcGetPerformanceParameterINTEL :: #type proc "system" (device: Device, parameter: PerformanceParameterTypeINTEL, pValue: ^PerformanceValueINTEL) -> Result +ProcGetPipelineCacheData :: #type proc "system" (device: Device, pipelineCache: PipelineCache, pDataSize: ^int, pData: rawptr) -> Result +ProcGetPipelineExecutableInternalRepresentationsKHR :: #type proc "system" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pInternalRepresentationCount: ^u32, pInternalRepresentations: [^]PipelineExecutableInternalRepresentationKHR) -> Result +ProcGetPipelineExecutablePropertiesKHR :: #type proc "system" (device: Device, pPipelineInfo: ^PipelineInfoKHR, pExecutableCount: ^u32, pProperties: [^]PipelineExecutablePropertiesKHR) -> Result +ProcGetPipelineExecutableStatisticsKHR :: #type proc "system" (device: Device, pExecutableInfo: ^PipelineExecutableInfoKHR, pStatisticCount: ^u32, pStatistics: [^]PipelineExecutableStatisticKHR) -> Result +ProcGetPipelinePropertiesEXT :: #type proc "system" (device: Device, pPipelineInfo: ^PipelineInfoEXT, pPipelineProperties: [^]BaseOutStructure) -> Result +ProcGetPrivateData :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, pData: ^u64) +ProcGetPrivateDataEXT :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, pData: ^u64) +ProcGetQueryPoolResults :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32, dataSize: int, pData: rawptr, stride: DeviceSize, flags: QueryResultFlags) -> Result +ProcGetQueueCheckpointData2NV :: #type proc "system" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointData2NV) +ProcGetQueueCheckpointDataNV :: #type proc "system" (queue: Queue, pCheckpointDataCount: ^u32, pCheckpointData: ^CheckpointDataNV) +ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result +ProcGetRayTracingShaderGroupHandlesKHR :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result +ProcGetRayTracingShaderGroupHandlesNV :: #type proc "system" (device: Device, pipeline: Pipeline, firstGroup: u32, groupCount: u32, dataSize: int, pData: rawptr) -> Result +ProcGetRayTracingShaderGroupStackSizeKHR :: #type proc "system" (device: Device, pipeline: Pipeline, group: u32, groupShader: ShaderGroupShaderKHR) -> DeviceSize +ProcGetRefreshCycleDurationGOOGLE :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pDisplayTimingProperties: [^]RefreshCycleDurationGOOGLE) -> Result +ProcGetRenderAreaGranularity :: #type proc "system" (device: Device, renderPass: RenderPass, pGranularity: ^Extent2D) +ProcGetSamplerOpaqueCaptureDescriptorDataEXT :: #type proc "system" (device: Device, pInfo: ^SamplerCaptureDescriptorDataInfoEXT, pData: rawptr) -> Result +ProcGetSemaphoreCounterValue :: #type proc "system" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result +ProcGetSemaphoreCounterValueKHR :: #type proc "system" (device: Device, semaphore: Semaphore, pValue: ^u64) -> Result +ProcGetSemaphoreFdKHR :: #type proc "system" (device: Device, pGetFdInfo: ^SemaphoreGetFdInfoKHR, pFd: ^c.int) -> Result +ProcGetSemaphoreWin32HandleKHR :: #type proc "system" (device: Device, pGetWin32HandleInfo: ^SemaphoreGetWin32HandleInfoKHR, pHandle: ^HANDLE) -> Result +ProcGetShaderBinaryDataEXT :: #type proc "system" (device: Device, shader: ShaderEXT, pDataSize: ^int, pData: rawptr) -> Result +ProcGetShaderInfoAMD :: #type proc "system" (device: Device, pipeline: Pipeline, shaderStage: ShaderStageFlags, infoType: ShaderInfoTypeAMD, pInfoSize: ^int, pInfo: rawptr) -> Result +ProcGetShaderModuleCreateInfoIdentifierEXT :: #type proc "system" (device: Device, pCreateInfo: ^ShaderModuleCreateInfo, pIdentifier: ^ShaderModuleIdentifierEXT) +ProcGetShaderModuleIdentifierEXT :: #type proc "system" (device: Device, shaderModule: ShaderModule, pIdentifier: ^ShaderModuleIdentifierEXT) +ProcGetSwapchainCounterEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR, counter: SurfaceCounterFlagsEXT, pCounterValue: ^u64) -> Result +ProcGetSwapchainImagesKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, pSwapchainImageCount: ^u32, pSwapchainImages: [^]Image) -> Result +ProcGetSwapchainStatusKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result +ProcGetValidationCacheDataEXT :: #type proc "system" (device: Device, validationCache: ValidationCacheEXT, pDataSize: ^int, pData: rawptr) -> Result +ProcGetVideoSessionMemoryRequirementsKHR :: #type proc "system" (device: Device, videoSession: VideoSessionKHR, pMemoryRequirementsCount: ^u32, pMemoryRequirements: [^]VideoSessionMemoryRequirementsKHR) -> Result +ProcImportFenceFdKHR :: #type proc "system" (device: Device, pImportFenceFdInfo: ^ImportFenceFdInfoKHR) -> Result +ProcImportFenceWin32HandleKHR :: #type proc "system" (device: Device, pImportFenceWin32HandleInfo: ^ImportFenceWin32HandleInfoKHR) -> Result +ProcImportSemaphoreFdKHR :: #type proc "system" (device: Device, pImportSemaphoreFdInfo: ^ImportSemaphoreFdInfoKHR) -> Result +ProcImportSemaphoreWin32HandleKHR :: #type proc "system" (device: Device, pImportSemaphoreWin32HandleInfo: ^ImportSemaphoreWin32HandleInfoKHR) -> Result +ProcInitializePerformanceApiINTEL :: #type proc "system" (device: Device, pInitializeInfo: ^InitializePerformanceApiInfoINTEL) -> Result +ProcInvalidateMappedMemoryRanges :: #type proc "system" (device: Device, memoryRangeCount: u32, pMemoryRanges: [^]MappedMemoryRange) -> Result +ProcMapMemory :: #type proc "system" (device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, ppData: ^rawptr) -> Result +ProcMapMemory2KHR :: #type proc "system" (device: Device, pMemoryMapInfo: ^MemoryMapInfoKHR, ppData: ^rawptr) -> Result +ProcMergePipelineCaches :: #type proc "system" (device: Device, dstCache: PipelineCache, srcCacheCount: u32, pSrcCaches: [^]PipelineCache) -> Result +ProcMergeValidationCachesEXT :: #type proc "system" (device: Device, dstCache: ValidationCacheEXT, srcCacheCount: u32, pSrcCaches: [^]ValidationCacheEXT) -> Result +ProcQueueBeginDebugUtilsLabelEXT :: #type proc "system" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT) +ProcQueueBindSparse :: #type proc "system" (queue: Queue, bindInfoCount: u32, pBindInfo: ^BindSparseInfo, fence: Fence) -> Result +ProcQueueEndDebugUtilsLabelEXT :: #type proc "system" (queue: Queue) +ProcQueueInsertDebugUtilsLabelEXT :: #type proc "system" (queue: Queue, pLabelInfo: ^DebugUtilsLabelEXT) +ProcQueuePresentKHR :: #type proc "system" (queue: Queue, pPresentInfo: ^PresentInfoKHR) -> Result +ProcQueueSetPerformanceConfigurationINTEL :: #type proc "system" (queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result +ProcQueueSubmit :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo, fence: Fence) -> Result +ProcQueueSubmit2 :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo2, fence: Fence) -> Result +ProcQueueSubmit2KHR :: #type proc "system" (queue: Queue, submitCount: u32, pSubmits: [^]SubmitInfo2, fence: Fence) -> Result +ProcQueueWaitIdle :: #type proc "system" (queue: Queue) -> Result +ProcRegisterDeviceEventEXT :: #type proc "system" (device: Device, pDeviceEventInfo: ^DeviceEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result +ProcRegisterDisplayEventEXT :: #type proc "system" (device: Device, display: DisplayKHR, pDisplayEventInfo: ^DisplayEventInfoEXT, pAllocator: ^AllocationCallbacks, pFence: ^Fence) -> Result +ProcReleaseFullScreenExclusiveModeEXT :: #type proc "system" (device: Device, swapchain: SwapchainKHR) -> Result +ProcReleasePerformanceConfigurationINTEL :: #type proc "system" (device: Device, configuration: PerformanceConfigurationINTEL) -> Result +ProcReleaseProfilingLockKHR :: #type proc "system" (device: Device) +ProcReleaseSwapchainImagesEXT :: #type proc "system" (device: Device, pReleaseInfo: ^ReleaseSwapchainImagesInfoEXT) -> Result +ProcResetCommandBuffer :: #type proc "system" (commandBuffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result +ProcResetCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolResetFlags) -> Result +ProcResetDescriptorPool :: #type proc "system" (device: Device, descriptorPool: DescriptorPool, flags: DescriptorPoolResetFlags) -> Result +ProcResetEvent :: #type proc "system" (device: Device, event: Event) -> Result +ProcResetFences :: #type proc "system" (device: Device, fenceCount: u32, pFences: [^]Fence) -> Result +ProcResetQueryPool :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) +ProcResetQueryPoolEXT :: #type proc "system" (device: Device, queryPool: QueryPool, firstQuery: u32, queryCount: u32) +ProcSetDebugUtilsObjectNameEXT :: #type proc "system" (device: Device, pNameInfo: ^DebugUtilsObjectNameInfoEXT) -> Result +ProcSetDebugUtilsObjectTagEXT :: #type proc "system" (device: Device, pTagInfo: ^DebugUtilsObjectTagInfoEXT) -> Result +ProcSetDeviceMemoryPriorityEXT :: #type proc "system" (device: Device, memory: DeviceMemory, priority: f32) +ProcSetEvent :: #type proc "system" (device: Device, event: Event) -> Result +ProcSetHdrMetadataEXT :: #type proc "system" (device: Device, swapchainCount: u32, pSwapchains: [^]SwapchainKHR, pMetadata: ^HdrMetadataEXT) +ProcSetLocalDimmingAMD :: #type proc "system" (device: Device, swapChain: SwapchainKHR, localDimmingEnable: b32) +ProcSetPrivateData :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, data: u64) -> Result +ProcSetPrivateDataEXT :: #type proc "system" (device: Device, objectType: ObjectType, objectHandle: u64, privateDataSlot: PrivateDataSlot, data: u64) -> Result +ProcSignalSemaphore :: #type proc "system" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result +ProcSignalSemaphoreKHR :: #type proc "system" (device: Device, pSignalInfo: ^SemaphoreSignalInfo) -> Result +ProcTrimCommandPool :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) +ProcTrimCommandPoolKHR :: #type proc "system" (device: Device, commandPool: CommandPool, flags: CommandPoolTrimFlags) +ProcUninitializePerformanceApiINTEL :: #type proc "system" (device: Device) +ProcUnmapMemory :: #type proc "system" (device: Device, memory: DeviceMemory) +ProcUnmapMemory2KHR :: #type proc "system" (device: Device, pMemoryUnmapInfo: ^MemoryUnmapInfoKHR) -> Result +ProcUpdateDescriptorSetWithTemplate :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr) +ProcUpdateDescriptorSetWithTemplateKHR :: #type proc "system" (device: Device, descriptorSet: DescriptorSet, descriptorUpdateTemplate: DescriptorUpdateTemplate, pData: rawptr) +ProcUpdateDescriptorSets :: #type proc "system" (device: Device, descriptorWriteCount: u32, pDescriptorWrites: [^]WriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: [^]CopyDescriptorSet) +ProcUpdateVideoSessionParametersKHR :: #type proc "system" (device: Device, videoSessionParameters: VideoSessionParametersKHR, pUpdateInfo: ^VideoSessionParametersUpdateInfoKHR) -> Result +ProcWaitForFences :: #type proc "system" (device: Device, fenceCount: u32, pFences: [^]Fence, waitAll: b32, timeout: u64) -> Result +ProcWaitForPresentKHR :: #type proc "system" (device: Device, swapchain: SwapchainKHR, presentId: u64, timeout: u64) -> Result +ProcWaitSemaphores :: #type proc "system" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result +ProcWaitSemaphoresKHR :: #type proc "system" (device: Device, pWaitInfo: ^SemaphoreWaitInfo, timeout: u64) -> Result +ProcWriteAccelerationStructuresPropertiesKHR :: #type proc "system" (device: Device, accelerationStructureCount: u32, pAccelerationStructures: [^]AccelerationStructureKHR, queryType: QueryType, dataSize: int, pData: rawptr, stride: int) -> Result +ProcWriteMicromapsPropertiesEXT :: #type proc "system" (device: Device, micromapCount: u32, pMicromaps: [^]MicromapEXT, queryType: QueryType, dataSize: int, pData: rawptr, stride: int) -> Result // Loader Procedures @@ -568,6 +672,7 @@ GetDisplayPlaneCapabilities2KHR: ProcGetDisplayP GetDisplayPlaneCapabilitiesKHR: ProcGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneSupportedDisplaysKHR: ProcGetDisplayPlaneSupportedDisplaysKHR GetDrmDisplayEXT: ProcGetDrmDisplayEXT +GetInstanceProcAddrLUNARG: ProcGetInstanceProcAddrLUNARG GetPhysicalDeviceCalibrateableTimeDomainsEXT: ProcGetPhysicalDeviceCalibrateableTimeDomainsEXT GetPhysicalDeviceCooperativeMatrixPropertiesNV: ProcGetPhysicalDeviceCooperativeMatrixPropertiesNV GetPhysicalDeviceDisplayPlaneProperties2KHR: ProcGetPhysicalDeviceDisplayPlaneProperties2KHR @@ -595,6 +700,7 @@ GetPhysicalDeviceMemoryProperties: ProcGetPhysical GetPhysicalDeviceMemoryProperties2: ProcGetPhysicalDeviceMemoryProperties2 GetPhysicalDeviceMemoryProperties2KHR: ProcGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMultisamplePropertiesEXT: ProcGetPhysicalDeviceMultisamplePropertiesEXT +GetPhysicalDeviceOpticalFlowImageFormatsNV: ProcGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDevicePresentRectanglesKHR: ProcGetPhysicalDevicePresentRectanglesKHR GetPhysicalDeviceProperties: ProcGetPhysicalDeviceProperties GetPhysicalDeviceProperties2: ProcGetPhysicalDeviceProperties2 @@ -617,6 +723,8 @@ GetPhysicalDeviceSurfacePresentModesKHR: ProcGetPhysical GetPhysicalDeviceSurfaceSupportKHR: ProcGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceToolProperties: ProcGetPhysicalDeviceToolProperties GetPhysicalDeviceToolPropertiesEXT: ProcGetPhysicalDeviceToolPropertiesEXT +GetPhysicalDeviceVideoCapabilitiesKHR: ProcGetPhysicalDeviceVideoCapabilitiesKHR +GetPhysicalDeviceVideoFormatPropertiesKHR: ProcGetPhysicalDeviceVideoFormatPropertiesKHR GetPhysicalDeviceWaylandPresentationSupportKHR: ProcGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR: ProcGetPhysicalDeviceWin32PresentationSupportKHR GetWinrtDisplayNV: ProcGetWinrtDisplayNV @@ -624,422 +732,522 @@ ReleaseDisplayEXT: ProcReleaseDisp SubmitDebugUtilsMessageEXT: ProcSubmitDebugUtilsMessageEXT // Device Procedures -AcquireFullScreenExclusiveModeEXT: ProcAcquireFullScreenExclusiveModeEXT -AcquireNextImage2KHR: ProcAcquireNextImage2KHR -AcquireNextImageKHR: ProcAcquireNextImageKHR -AcquirePerformanceConfigurationINTEL: ProcAcquirePerformanceConfigurationINTEL -AcquireProfilingLockKHR: ProcAcquireProfilingLockKHR -AllocateCommandBuffers: ProcAllocateCommandBuffers -AllocateDescriptorSets: ProcAllocateDescriptorSets -AllocateMemory: ProcAllocateMemory -BeginCommandBuffer: ProcBeginCommandBuffer -BindAccelerationStructureMemoryNV: ProcBindAccelerationStructureMemoryNV -BindBufferMemory: ProcBindBufferMemory -BindBufferMemory2: ProcBindBufferMemory2 -BindBufferMemory2KHR: ProcBindBufferMemory2KHR -BindImageMemory: ProcBindImageMemory -BindImageMemory2: ProcBindImageMemory2 -BindImageMemory2KHR: ProcBindImageMemory2KHR -BuildAccelerationStructuresKHR: ProcBuildAccelerationStructuresKHR -CmdBeginConditionalRenderingEXT: ProcCmdBeginConditionalRenderingEXT -CmdBeginDebugUtilsLabelEXT: ProcCmdBeginDebugUtilsLabelEXT -CmdBeginQuery: ProcCmdBeginQuery -CmdBeginQueryIndexedEXT: ProcCmdBeginQueryIndexedEXT -CmdBeginRenderPass: ProcCmdBeginRenderPass -CmdBeginRenderPass2: ProcCmdBeginRenderPass2 -CmdBeginRenderPass2KHR: ProcCmdBeginRenderPass2KHR -CmdBeginRendering: ProcCmdBeginRendering -CmdBeginRenderingKHR: ProcCmdBeginRenderingKHR -CmdBeginTransformFeedbackEXT: ProcCmdBeginTransformFeedbackEXT -CmdBindDescriptorSets: ProcCmdBindDescriptorSets -CmdBindIndexBuffer: ProcCmdBindIndexBuffer -CmdBindInvocationMaskHUAWEI: ProcCmdBindInvocationMaskHUAWEI -CmdBindPipeline: ProcCmdBindPipeline -CmdBindPipelineShaderGroupNV: ProcCmdBindPipelineShaderGroupNV -CmdBindShadingRateImageNV: ProcCmdBindShadingRateImageNV -CmdBindTransformFeedbackBuffersEXT: ProcCmdBindTransformFeedbackBuffersEXT -CmdBindVertexBuffers: ProcCmdBindVertexBuffers -CmdBindVertexBuffers2: ProcCmdBindVertexBuffers2 -CmdBindVertexBuffers2EXT: ProcCmdBindVertexBuffers2EXT -CmdBlitImage: ProcCmdBlitImage -CmdBlitImage2: ProcCmdBlitImage2 -CmdBlitImage2KHR: ProcCmdBlitImage2KHR -CmdBuildAccelerationStructureNV: ProcCmdBuildAccelerationStructureNV -CmdBuildAccelerationStructuresIndirectKHR: ProcCmdBuildAccelerationStructuresIndirectKHR -CmdBuildAccelerationStructuresKHR: ProcCmdBuildAccelerationStructuresKHR -CmdClearAttachments: ProcCmdClearAttachments -CmdClearColorImage: ProcCmdClearColorImage -CmdClearDepthStencilImage: ProcCmdClearDepthStencilImage -CmdCopyAccelerationStructureKHR: ProcCmdCopyAccelerationStructureKHR -CmdCopyAccelerationStructureNV: ProcCmdCopyAccelerationStructureNV -CmdCopyAccelerationStructureToMemoryKHR: ProcCmdCopyAccelerationStructureToMemoryKHR -CmdCopyBuffer: ProcCmdCopyBuffer -CmdCopyBuffer2: ProcCmdCopyBuffer2 -CmdCopyBuffer2KHR: ProcCmdCopyBuffer2KHR -CmdCopyBufferToImage: ProcCmdCopyBufferToImage -CmdCopyBufferToImage2: ProcCmdCopyBufferToImage2 -CmdCopyBufferToImage2KHR: ProcCmdCopyBufferToImage2KHR -CmdCopyImage: ProcCmdCopyImage -CmdCopyImage2: ProcCmdCopyImage2 -CmdCopyImage2KHR: ProcCmdCopyImage2KHR -CmdCopyImageToBuffer: ProcCmdCopyImageToBuffer -CmdCopyImageToBuffer2: ProcCmdCopyImageToBuffer2 -CmdCopyImageToBuffer2KHR: ProcCmdCopyImageToBuffer2KHR -CmdCopyMemoryToAccelerationStructureKHR: ProcCmdCopyMemoryToAccelerationStructureKHR -CmdCopyQueryPoolResults: ProcCmdCopyQueryPoolResults -CmdCuLaunchKernelNVX: ProcCmdCuLaunchKernelNVX -CmdDebugMarkerBeginEXT: ProcCmdDebugMarkerBeginEXT -CmdDebugMarkerEndEXT: ProcCmdDebugMarkerEndEXT -CmdDebugMarkerInsertEXT: ProcCmdDebugMarkerInsertEXT -CmdDispatch: ProcCmdDispatch -CmdDispatchBase: ProcCmdDispatchBase -CmdDispatchBaseKHR: ProcCmdDispatchBaseKHR -CmdDispatchIndirect: ProcCmdDispatchIndirect -CmdDraw: ProcCmdDraw -CmdDrawIndexed: ProcCmdDrawIndexed -CmdDrawIndexedIndirect: ProcCmdDrawIndexedIndirect -CmdDrawIndexedIndirectCount: ProcCmdDrawIndexedIndirectCount -CmdDrawIndexedIndirectCountAMD: ProcCmdDrawIndexedIndirectCountAMD -CmdDrawIndexedIndirectCountKHR: ProcCmdDrawIndexedIndirectCountKHR -CmdDrawIndirect: ProcCmdDrawIndirect -CmdDrawIndirectByteCountEXT: ProcCmdDrawIndirectByteCountEXT -CmdDrawIndirectCount: ProcCmdDrawIndirectCount -CmdDrawIndirectCountAMD: ProcCmdDrawIndirectCountAMD -CmdDrawIndirectCountKHR: ProcCmdDrawIndirectCountKHR -CmdDrawMeshTasksIndirectCountNV: ProcCmdDrawMeshTasksIndirectCountNV -CmdDrawMeshTasksIndirectNV: ProcCmdDrawMeshTasksIndirectNV -CmdDrawMeshTasksNV: ProcCmdDrawMeshTasksNV -CmdDrawMultiEXT: ProcCmdDrawMultiEXT -CmdDrawMultiIndexedEXT: ProcCmdDrawMultiIndexedEXT -CmdEndConditionalRenderingEXT: ProcCmdEndConditionalRenderingEXT -CmdEndDebugUtilsLabelEXT: ProcCmdEndDebugUtilsLabelEXT -CmdEndQuery: ProcCmdEndQuery -CmdEndQueryIndexedEXT: ProcCmdEndQueryIndexedEXT -CmdEndRenderPass: ProcCmdEndRenderPass -CmdEndRenderPass2: ProcCmdEndRenderPass2 -CmdEndRenderPass2KHR: ProcCmdEndRenderPass2KHR -CmdEndRendering: ProcCmdEndRendering -CmdEndRenderingKHR: ProcCmdEndRenderingKHR -CmdEndTransformFeedbackEXT: ProcCmdEndTransformFeedbackEXT -CmdExecuteCommands: ProcCmdExecuteCommands -CmdExecuteGeneratedCommandsNV: ProcCmdExecuteGeneratedCommandsNV -CmdFillBuffer: ProcCmdFillBuffer -CmdInsertDebugUtilsLabelEXT: ProcCmdInsertDebugUtilsLabelEXT -CmdNextSubpass: ProcCmdNextSubpass -CmdNextSubpass2: ProcCmdNextSubpass2 -CmdNextSubpass2KHR: ProcCmdNextSubpass2KHR -CmdPipelineBarrier: ProcCmdPipelineBarrier -CmdPipelineBarrier2: ProcCmdPipelineBarrier2 -CmdPipelineBarrier2KHR: ProcCmdPipelineBarrier2KHR -CmdPreprocessGeneratedCommandsNV: ProcCmdPreprocessGeneratedCommandsNV -CmdPushConstants: ProcCmdPushConstants -CmdPushDescriptorSetKHR: ProcCmdPushDescriptorSetKHR -CmdPushDescriptorSetWithTemplateKHR: ProcCmdPushDescriptorSetWithTemplateKHR -CmdResetEvent: ProcCmdResetEvent -CmdResetEvent2: ProcCmdResetEvent2 -CmdResetEvent2KHR: ProcCmdResetEvent2KHR -CmdResetQueryPool: ProcCmdResetQueryPool -CmdResolveImage: ProcCmdResolveImage -CmdResolveImage2: ProcCmdResolveImage2 -CmdResolveImage2KHR: ProcCmdResolveImage2KHR -CmdSetBlendConstants: ProcCmdSetBlendConstants -CmdSetCheckpointNV: ProcCmdSetCheckpointNV -CmdSetCoarseSampleOrderNV: ProcCmdSetCoarseSampleOrderNV -CmdSetCullMode: ProcCmdSetCullMode -CmdSetCullModeEXT: ProcCmdSetCullModeEXT -CmdSetDepthBias: ProcCmdSetDepthBias -CmdSetDepthBiasEnable: ProcCmdSetDepthBiasEnable -CmdSetDepthBiasEnableEXT: ProcCmdSetDepthBiasEnableEXT -CmdSetDepthBounds: ProcCmdSetDepthBounds -CmdSetDepthBoundsTestEnable: ProcCmdSetDepthBoundsTestEnable -CmdSetDepthBoundsTestEnableEXT: ProcCmdSetDepthBoundsTestEnableEXT -CmdSetDepthCompareOp: ProcCmdSetDepthCompareOp -CmdSetDepthCompareOpEXT: ProcCmdSetDepthCompareOpEXT -CmdSetDepthTestEnable: ProcCmdSetDepthTestEnable -CmdSetDepthTestEnableEXT: ProcCmdSetDepthTestEnableEXT -CmdSetDepthWriteEnable: ProcCmdSetDepthWriteEnable -CmdSetDepthWriteEnableEXT: ProcCmdSetDepthWriteEnableEXT -CmdSetDeviceMask: ProcCmdSetDeviceMask -CmdSetDeviceMaskKHR: ProcCmdSetDeviceMaskKHR -CmdSetDiscardRectangleEXT: ProcCmdSetDiscardRectangleEXT -CmdSetEvent: ProcCmdSetEvent -CmdSetEvent2: ProcCmdSetEvent2 -CmdSetEvent2KHR: ProcCmdSetEvent2KHR -CmdSetExclusiveScissorNV: ProcCmdSetExclusiveScissorNV -CmdSetFragmentShadingRateEnumNV: ProcCmdSetFragmentShadingRateEnumNV -CmdSetFragmentShadingRateKHR: ProcCmdSetFragmentShadingRateKHR -CmdSetFrontFace: ProcCmdSetFrontFace -CmdSetFrontFaceEXT: ProcCmdSetFrontFaceEXT -CmdSetLineStippleEXT: ProcCmdSetLineStippleEXT -CmdSetLineWidth: ProcCmdSetLineWidth -CmdSetLogicOpEXT: ProcCmdSetLogicOpEXT -CmdSetPatchControlPointsEXT: ProcCmdSetPatchControlPointsEXT -CmdSetPerformanceMarkerINTEL: ProcCmdSetPerformanceMarkerINTEL -CmdSetPerformanceOverrideINTEL: ProcCmdSetPerformanceOverrideINTEL -CmdSetPerformanceStreamMarkerINTEL: ProcCmdSetPerformanceStreamMarkerINTEL -CmdSetPrimitiveRestartEnable: ProcCmdSetPrimitiveRestartEnable -CmdSetPrimitiveRestartEnableEXT: ProcCmdSetPrimitiveRestartEnableEXT -CmdSetPrimitiveTopology: ProcCmdSetPrimitiveTopology -CmdSetPrimitiveTopologyEXT: ProcCmdSetPrimitiveTopologyEXT -CmdSetRasterizerDiscardEnable: ProcCmdSetRasterizerDiscardEnable -CmdSetRasterizerDiscardEnableEXT: ProcCmdSetRasterizerDiscardEnableEXT -CmdSetRayTracingPipelineStackSizeKHR: ProcCmdSetRayTracingPipelineStackSizeKHR -CmdSetSampleLocationsEXT: ProcCmdSetSampleLocationsEXT -CmdSetScissor: ProcCmdSetScissor -CmdSetScissorWithCount: ProcCmdSetScissorWithCount -CmdSetScissorWithCountEXT: ProcCmdSetScissorWithCountEXT -CmdSetStencilCompareMask: ProcCmdSetStencilCompareMask -CmdSetStencilOp: ProcCmdSetStencilOp -CmdSetStencilOpEXT: ProcCmdSetStencilOpEXT -CmdSetStencilReference: ProcCmdSetStencilReference -CmdSetStencilTestEnable: ProcCmdSetStencilTestEnable -CmdSetStencilTestEnableEXT: ProcCmdSetStencilTestEnableEXT -CmdSetStencilWriteMask: ProcCmdSetStencilWriteMask -CmdSetVertexInputEXT: ProcCmdSetVertexInputEXT -CmdSetViewport: ProcCmdSetViewport -CmdSetViewportShadingRatePaletteNV: ProcCmdSetViewportShadingRatePaletteNV -CmdSetViewportWScalingNV: ProcCmdSetViewportWScalingNV -CmdSetViewportWithCount: ProcCmdSetViewportWithCount -CmdSetViewportWithCountEXT: ProcCmdSetViewportWithCountEXT -CmdSubpassShadingHUAWEI: ProcCmdSubpassShadingHUAWEI -CmdTraceRaysIndirectKHR: ProcCmdTraceRaysIndirectKHR -CmdTraceRaysKHR: ProcCmdTraceRaysKHR -CmdTraceRaysNV: ProcCmdTraceRaysNV -CmdUpdateBuffer: ProcCmdUpdateBuffer -CmdWaitEvents: ProcCmdWaitEvents -CmdWaitEvents2: ProcCmdWaitEvents2 -CmdWaitEvents2KHR: ProcCmdWaitEvents2KHR -CmdWriteAccelerationStructuresPropertiesKHR: ProcCmdWriteAccelerationStructuresPropertiesKHR -CmdWriteAccelerationStructuresPropertiesNV: ProcCmdWriteAccelerationStructuresPropertiesNV -CmdWriteBufferMarker2AMD: ProcCmdWriteBufferMarker2AMD -CmdWriteBufferMarkerAMD: ProcCmdWriteBufferMarkerAMD -CmdWriteTimestamp: ProcCmdWriteTimestamp -CmdWriteTimestamp2: ProcCmdWriteTimestamp2 -CmdWriteTimestamp2KHR: ProcCmdWriteTimestamp2KHR -CompileDeferredNV: ProcCompileDeferredNV -CopyAccelerationStructureKHR: ProcCopyAccelerationStructureKHR -CopyAccelerationStructureToMemoryKHR: ProcCopyAccelerationStructureToMemoryKHR -CopyMemoryToAccelerationStructureKHR: ProcCopyMemoryToAccelerationStructureKHR -CreateAccelerationStructureKHR: ProcCreateAccelerationStructureKHR -CreateAccelerationStructureNV: ProcCreateAccelerationStructureNV -CreateBuffer: ProcCreateBuffer -CreateBufferView: ProcCreateBufferView -CreateCommandPool: ProcCreateCommandPool -CreateComputePipelines: ProcCreateComputePipelines -CreateCuFunctionNVX: ProcCreateCuFunctionNVX -CreateCuModuleNVX: ProcCreateCuModuleNVX -CreateDeferredOperationKHR: ProcCreateDeferredOperationKHR -CreateDescriptorPool: ProcCreateDescriptorPool -CreateDescriptorSetLayout: ProcCreateDescriptorSetLayout -CreateDescriptorUpdateTemplate: ProcCreateDescriptorUpdateTemplate -CreateDescriptorUpdateTemplateKHR: ProcCreateDescriptorUpdateTemplateKHR -CreateEvent: ProcCreateEvent -CreateFence: ProcCreateFence -CreateFramebuffer: ProcCreateFramebuffer -CreateGraphicsPipelines: ProcCreateGraphicsPipelines -CreateImage: ProcCreateImage -CreateImageView: ProcCreateImageView -CreateIndirectCommandsLayoutNV: ProcCreateIndirectCommandsLayoutNV -CreatePipelineCache: ProcCreatePipelineCache -CreatePipelineLayout: ProcCreatePipelineLayout -CreatePrivateDataSlot: ProcCreatePrivateDataSlot -CreatePrivateDataSlotEXT: ProcCreatePrivateDataSlotEXT -CreateQueryPool: ProcCreateQueryPool -CreateRayTracingPipelinesKHR: ProcCreateRayTracingPipelinesKHR -CreateRayTracingPipelinesNV: ProcCreateRayTracingPipelinesNV -CreateRenderPass: ProcCreateRenderPass -CreateRenderPass2: ProcCreateRenderPass2 -CreateRenderPass2KHR: ProcCreateRenderPass2KHR -CreateSampler: ProcCreateSampler -CreateSamplerYcbcrConversion: ProcCreateSamplerYcbcrConversion -CreateSamplerYcbcrConversionKHR: ProcCreateSamplerYcbcrConversionKHR -CreateSemaphore: ProcCreateSemaphore -CreateShaderModule: ProcCreateShaderModule -CreateSharedSwapchainsKHR: ProcCreateSharedSwapchainsKHR -CreateSwapchainKHR: ProcCreateSwapchainKHR -CreateValidationCacheEXT: ProcCreateValidationCacheEXT -DebugMarkerSetObjectNameEXT: ProcDebugMarkerSetObjectNameEXT -DebugMarkerSetObjectTagEXT: ProcDebugMarkerSetObjectTagEXT -DeferredOperationJoinKHR: ProcDeferredOperationJoinKHR -DestroyAccelerationStructureKHR: ProcDestroyAccelerationStructureKHR -DestroyAccelerationStructureNV: ProcDestroyAccelerationStructureNV -DestroyBuffer: ProcDestroyBuffer -DestroyBufferView: ProcDestroyBufferView -DestroyCommandPool: ProcDestroyCommandPool -DestroyCuFunctionNVX: ProcDestroyCuFunctionNVX -DestroyCuModuleNVX: ProcDestroyCuModuleNVX -DestroyDeferredOperationKHR: ProcDestroyDeferredOperationKHR -DestroyDescriptorPool: ProcDestroyDescriptorPool -DestroyDescriptorSetLayout: ProcDestroyDescriptorSetLayout -DestroyDescriptorUpdateTemplate: ProcDestroyDescriptorUpdateTemplate -DestroyDescriptorUpdateTemplateKHR: ProcDestroyDescriptorUpdateTemplateKHR -DestroyDevice: ProcDestroyDevice -DestroyEvent: ProcDestroyEvent -DestroyFence: ProcDestroyFence -DestroyFramebuffer: ProcDestroyFramebuffer -DestroyImage: ProcDestroyImage -DestroyImageView: ProcDestroyImageView -DestroyIndirectCommandsLayoutNV: ProcDestroyIndirectCommandsLayoutNV -DestroyPipeline: ProcDestroyPipeline -DestroyPipelineCache: ProcDestroyPipelineCache -DestroyPipelineLayout: ProcDestroyPipelineLayout -DestroyPrivateDataSlot: ProcDestroyPrivateDataSlot -DestroyPrivateDataSlotEXT: ProcDestroyPrivateDataSlotEXT -DestroyQueryPool: ProcDestroyQueryPool -DestroyRenderPass: ProcDestroyRenderPass -DestroySampler: ProcDestroySampler -DestroySamplerYcbcrConversion: ProcDestroySamplerYcbcrConversion -DestroySamplerYcbcrConversionKHR: ProcDestroySamplerYcbcrConversionKHR -DestroySemaphore: ProcDestroySemaphore -DestroyShaderModule: ProcDestroyShaderModule -DestroySwapchainKHR: ProcDestroySwapchainKHR -DestroyValidationCacheEXT: ProcDestroyValidationCacheEXT -DeviceWaitIdle: ProcDeviceWaitIdle -DisplayPowerControlEXT: ProcDisplayPowerControlEXT -EndCommandBuffer: ProcEndCommandBuffer -FlushMappedMemoryRanges: ProcFlushMappedMemoryRanges -FreeCommandBuffers: ProcFreeCommandBuffers -FreeDescriptorSets: ProcFreeDescriptorSets -FreeMemory: ProcFreeMemory -GetAccelerationStructureBuildSizesKHR: ProcGetAccelerationStructureBuildSizesKHR -GetAccelerationStructureDeviceAddressKHR: ProcGetAccelerationStructureDeviceAddressKHR -GetAccelerationStructureHandleNV: ProcGetAccelerationStructureHandleNV -GetAccelerationStructureMemoryRequirementsNV: ProcGetAccelerationStructureMemoryRequirementsNV -GetBufferDeviceAddress: ProcGetBufferDeviceAddress -GetBufferDeviceAddressEXT: ProcGetBufferDeviceAddressEXT -GetBufferDeviceAddressKHR: ProcGetBufferDeviceAddressKHR -GetBufferMemoryRequirements: ProcGetBufferMemoryRequirements -GetBufferMemoryRequirements2: ProcGetBufferMemoryRequirements2 -GetBufferMemoryRequirements2KHR: ProcGetBufferMemoryRequirements2KHR -GetBufferOpaqueCaptureAddress: ProcGetBufferOpaqueCaptureAddress -GetBufferOpaqueCaptureAddressKHR: ProcGetBufferOpaqueCaptureAddressKHR -GetCalibratedTimestampsEXT: ProcGetCalibratedTimestampsEXT -GetDeferredOperationMaxConcurrencyKHR: ProcGetDeferredOperationMaxConcurrencyKHR -GetDeferredOperationResultKHR: ProcGetDeferredOperationResultKHR -GetDescriptorSetHostMappingVALVE: ProcGetDescriptorSetHostMappingVALVE -GetDescriptorSetLayoutHostMappingInfoVALVE: ProcGetDescriptorSetLayoutHostMappingInfoVALVE -GetDescriptorSetLayoutSupport: ProcGetDescriptorSetLayoutSupport -GetDescriptorSetLayoutSupportKHR: ProcGetDescriptorSetLayoutSupportKHR -GetDeviceAccelerationStructureCompatibilityKHR: ProcGetDeviceAccelerationStructureCompatibilityKHR -GetDeviceBufferMemoryRequirements: ProcGetDeviceBufferMemoryRequirements -GetDeviceBufferMemoryRequirementsKHR: ProcGetDeviceBufferMemoryRequirementsKHR -GetDeviceGroupPeerMemoryFeatures: ProcGetDeviceGroupPeerMemoryFeatures -GetDeviceGroupPeerMemoryFeaturesKHR: ProcGetDeviceGroupPeerMemoryFeaturesKHR -GetDeviceGroupPresentCapabilitiesKHR: ProcGetDeviceGroupPresentCapabilitiesKHR -GetDeviceGroupSurfacePresentModes2EXT: ProcGetDeviceGroupSurfacePresentModes2EXT -GetDeviceGroupSurfacePresentModesKHR: ProcGetDeviceGroupSurfacePresentModesKHR -GetDeviceImageMemoryRequirements: ProcGetDeviceImageMemoryRequirements -GetDeviceImageMemoryRequirementsKHR: ProcGetDeviceImageMemoryRequirementsKHR -GetDeviceImageSparseMemoryRequirements: ProcGetDeviceImageSparseMemoryRequirements -GetDeviceImageSparseMemoryRequirementsKHR: ProcGetDeviceImageSparseMemoryRequirementsKHR -GetDeviceMemoryCommitment: ProcGetDeviceMemoryCommitment -GetDeviceMemoryOpaqueCaptureAddress: ProcGetDeviceMemoryOpaqueCaptureAddress -GetDeviceMemoryOpaqueCaptureAddressKHR: ProcGetDeviceMemoryOpaqueCaptureAddressKHR -GetDeviceProcAddr: ProcGetDeviceProcAddr -GetDeviceQueue: ProcGetDeviceQueue -GetDeviceQueue2: ProcGetDeviceQueue2 -GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI -GetEventStatus: ProcGetEventStatus -GetFenceFdKHR: ProcGetFenceFdKHR -GetFenceStatus: ProcGetFenceStatus -GetFenceWin32HandleKHR: ProcGetFenceWin32HandleKHR -GetGeneratedCommandsMemoryRequirementsNV: ProcGetGeneratedCommandsMemoryRequirementsNV -GetImageDrmFormatModifierPropertiesEXT: ProcGetImageDrmFormatModifierPropertiesEXT -GetImageMemoryRequirements: ProcGetImageMemoryRequirements -GetImageMemoryRequirements2: ProcGetImageMemoryRequirements2 -GetImageMemoryRequirements2KHR: ProcGetImageMemoryRequirements2KHR -GetImageSparseMemoryRequirements: ProcGetImageSparseMemoryRequirements -GetImageSparseMemoryRequirements2: ProcGetImageSparseMemoryRequirements2 -GetImageSparseMemoryRequirements2KHR: ProcGetImageSparseMemoryRequirements2KHR -GetImageSubresourceLayout: ProcGetImageSubresourceLayout -GetImageViewAddressNVX: ProcGetImageViewAddressNVX -GetImageViewHandleNVX: ProcGetImageViewHandleNVX -GetMemoryFdKHR: ProcGetMemoryFdKHR -GetMemoryFdPropertiesKHR: ProcGetMemoryFdPropertiesKHR -GetMemoryHostPointerPropertiesEXT: ProcGetMemoryHostPointerPropertiesEXT -GetMemoryRemoteAddressNV: ProcGetMemoryRemoteAddressNV -GetMemoryWin32HandleKHR: ProcGetMemoryWin32HandleKHR -GetMemoryWin32HandleNV: ProcGetMemoryWin32HandleNV -GetMemoryWin32HandlePropertiesKHR: ProcGetMemoryWin32HandlePropertiesKHR -GetPastPresentationTimingGOOGLE: ProcGetPastPresentationTimingGOOGLE -GetPerformanceParameterINTEL: ProcGetPerformanceParameterINTEL -GetPipelineCacheData: ProcGetPipelineCacheData -GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR -GetPipelineExecutablePropertiesKHR: ProcGetPipelineExecutablePropertiesKHR -GetPipelineExecutableStatisticsKHR: ProcGetPipelineExecutableStatisticsKHR -GetPrivateData: ProcGetPrivateData -GetPrivateDataEXT: ProcGetPrivateDataEXT -GetQueryPoolResults: ProcGetQueryPoolResults -GetQueueCheckpointData2NV: ProcGetQueueCheckpointData2NV -GetQueueCheckpointDataNV: ProcGetQueueCheckpointDataNV -GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR -GetRayTracingShaderGroupHandlesKHR: ProcGetRayTracingShaderGroupHandlesKHR -GetRayTracingShaderGroupHandlesNV: ProcGetRayTracingShaderGroupHandlesNV -GetRayTracingShaderGroupStackSizeKHR: ProcGetRayTracingShaderGroupStackSizeKHR -GetRefreshCycleDurationGOOGLE: ProcGetRefreshCycleDurationGOOGLE -GetRenderAreaGranularity: ProcGetRenderAreaGranularity -GetSemaphoreCounterValue: ProcGetSemaphoreCounterValue -GetSemaphoreCounterValueKHR: ProcGetSemaphoreCounterValueKHR -GetSemaphoreFdKHR: ProcGetSemaphoreFdKHR -GetSemaphoreWin32HandleKHR: ProcGetSemaphoreWin32HandleKHR -GetShaderInfoAMD: ProcGetShaderInfoAMD -GetSwapchainCounterEXT: ProcGetSwapchainCounterEXT -GetSwapchainImagesKHR: ProcGetSwapchainImagesKHR -GetSwapchainStatusKHR: ProcGetSwapchainStatusKHR -GetValidationCacheDataEXT: ProcGetValidationCacheDataEXT -ImportFenceFdKHR: ProcImportFenceFdKHR -ImportFenceWin32HandleKHR: ProcImportFenceWin32HandleKHR -ImportSemaphoreFdKHR: ProcImportSemaphoreFdKHR -ImportSemaphoreWin32HandleKHR: ProcImportSemaphoreWin32HandleKHR -InitializePerformanceApiINTEL: ProcInitializePerformanceApiINTEL -InvalidateMappedMemoryRanges: ProcInvalidateMappedMemoryRanges -MapMemory: ProcMapMemory -MergePipelineCaches: ProcMergePipelineCaches -MergeValidationCachesEXT: ProcMergeValidationCachesEXT -QueueBeginDebugUtilsLabelEXT: ProcQueueBeginDebugUtilsLabelEXT -QueueBindSparse: ProcQueueBindSparse -QueueEndDebugUtilsLabelEXT: ProcQueueEndDebugUtilsLabelEXT -QueueInsertDebugUtilsLabelEXT: ProcQueueInsertDebugUtilsLabelEXT -QueuePresentKHR: ProcQueuePresentKHR -QueueSetPerformanceConfigurationINTEL: ProcQueueSetPerformanceConfigurationINTEL -QueueSubmit: ProcQueueSubmit -QueueSubmit2: ProcQueueSubmit2 -QueueSubmit2KHR: ProcQueueSubmit2KHR -QueueWaitIdle: ProcQueueWaitIdle -RegisterDeviceEventEXT: ProcRegisterDeviceEventEXT -RegisterDisplayEventEXT: ProcRegisterDisplayEventEXT -ReleaseFullScreenExclusiveModeEXT: ProcReleaseFullScreenExclusiveModeEXT -ReleasePerformanceConfigurationINTEL: ProcReleasePerformanceConfigurationINTEL -ReleaseProfilingLockKHR: ProcReleaseProfilingLockKHR -ResetCommandBuffer: ProcResetCommandBuffer -ResetCommandPool: ProcResetCommandPool -ResetDescriptorPool: ProcResetDescriptorPool -ResetEvent: ProcResetEvent -ResetFences: ProcResetFences -ResetQueryPool: ProcResetQueryPool -ResetQueryPoolEXT: ProcResetQueryPoolEXT -SetDebugUtilsObjectNameEXT: ProcSetDebugUtilsObjectNameEXT -SetDebugUtilsObjectTagEXT: ProcSetDebugUtilsObjectTagEXT -SetDeviceMemoryPriorityEXT: ProcSetDeviceMemoryPriorityEXT -SetEvent: ProcSetEvent -SetHdrMetadataEXT: ProcSetHdrMetadataEXT -SetLocalDimmingAMD: ProcSetLocalDimmingAMD -SetPrivateData: ProcSetPrivateData -SetPrivateDataEXT: ProcSetPrivateDataEXT -SignalSemaphore: ProcSignalSemaphore -SignalSemaphoreKHR: ProcSignalSemaphoreKHR -TrimCommandPool: ProcTrimCommandPool -TrimCommandPoolKHR: ProcTrimCommandPoolKHR -UninitializePerformanceApiINTEL: ProcUninitializePerformanceApiINTEL -UnmapMemory: ProcUnmapMemory -UpdateDescriptorSetWithTemplate: ProcUpdateDescriptorSetWithTemplate -UpdateDescriptorSetWithTemplateKHR: ProcUpdateDescriptorSetWithTemplateKHR -UpdateDescriptorSets: ProcUpdateDescriptorSets -WaitForFences: ProcWaitForFences -WaitForPresentKHR: ProcWaitForPresentKHR -WaitSemaphores: ProcWaitSemaphores -WaitSemaphoresKHR: ProcWaitSemaphoresKHR -WriteAccelerationStructuresPropertiesKHR: ProcWriteAccelerationStructuresPropertiesKHR +AcquireFullScreenExclusiveModeEXT: ProcAcquireFullScreenExclusiveModeEXT +AcquireNextImage2KHR: ProcAcquireNextImage2KHR +AcquireNextImageKHR: ProcAcquireNextImageKHR +AcquirePerformanceConfigurationINTEL: ProcAcquirePerformanceConfigurationINTEL +AcquireProfilingLockKHR: ProcAcquireProfilingLockKHR +AllocateCommandBuffers: ProcAllocateCommandBuffers +AllocateDescriptorSets: ProcAllocateDescriptorSets +AllocateMemory: ProcAllocateMemory +BeginCommandBuffer: ProcBeginCommandBuffer +BindAccelerationStructureMemoryNV: ProcBindAccelerationStructureMemoryNV +BindBufferMemory: ProcBindBufferMemory +BindBufferMemory2: ProcBindBufferMemory2 +BindBufferMemory2KHR: ProcBindBufferMemory2KHR +BindImageMemory: ProcBindImageMemory +BindImageMemory2: ProcBindImageMemory2 +BindImageMemory2KHR: ProcBindImageMemory2KHR +BindOpticalFlowSessionImageNV: ProcBindOpticalFlowSessionImageNV +BindVideoSessionMemoryKHR: ProcBindVideoSessionMemoryKHR +BuildAccelerationStructuresKHR: ProcBuildAccelerationStructuresKHR +BuildMicromapsEXT: ProcBuildMicromapsEXT +CmdBeginConditionalRenderingEXT: ProcCmdBeginConditionalRenderingEXT +CmdBeginDebugUtilsLabelEXT: ProcCmdBeginDebugUtilsLabelEXT +CmdBeginQuery: ProcCmdBeginQuery +CmdBeginQueryIndexedEXT: ProcCmdBeginQueryIndexedEXT +CmdBeginRenderPass: ProcCmdBeginRenderPass +CmdBeginRenderPass2: ProcCmdBeginRenderPass2 +CmdBeginRenderPass2KHR: ProcCmdBeginRenderPass2KHR +CmdBeginRendering: ProcCmdBeginRendering +CmdBeginRenderingKHR: ProcCmdBeginRenderingKHR +CmdBeginTransformFeedbackEXT: ProcCmdBeginTransformFeedbackEXT +CmdBeginVideoCodingKHR: ProcCmdBeginVideoCodingKHR +CmdBindDescriptorBufferEmbeddedSamplersEXT: ProcCmdBindDescriptorBufferEmbeddedSamplersEXT +CmdBindDescriptorBuffersEXT: ProcCmdBindDescriptorBuffersEXT +CmdBindDescriptorSets: ProcCmdBindDescriptorSets +CmdBindIndexBuffer: ProcCmdBindIndexBuffer +CmdBindInvocationMaskHUAWEI: ProcCmdBindInvocationMaskHUAWEI +CmdBindPipeline: ProcCmdBindPipeline +CmdBindPipelineShaderGroupNV: ProcCmdBindPipelineShaderGroupNV +CmdBindShadersEXT: ProcCmdBindShadersEXT +CmdBindShadingRateImageNV: ProcCmdBindShadingRateImageNV +CmdBindTransformFeedbackBuffersEXT: ProcCmdBindTransformFeedbackBuffersEXT +CmdBindVertexBuffers: ProcCmdBindVertexBuffers +CmdBindVertexBuffers2: ProcCmdBindVertexBuffers2 +CmdBindVertexBuffers2EXT: ProcCmdBindVertexBuffers2EXT +CmdBlitImage: ProcCmdBlitImage +CmdBlitImage2: ProcCmdBlitImage2 +CmdBlitImage2KHR: ProcCmdBlitImage2KHR +CmdBuildAccelerationStructureNV: ProcCmdBuildAccelerationStructureNV +CmdBuildAccelerationStructuresIndirectKHR: ProcCmdBuildAccelerationStructuresIndirectKHR +CmdBuildAccelerationStructuresKHR: ProcCmdBuildAccelerationStructuresKHR +CmdBuildMicromapsEXT: ProcCmdBuildMicromapsEXT +CmdClearAttachments: ProcCmdClearAttachments +CmdClearColorImage: ProcCmdClearColorImage +CmdClearDepthStencilImage: ProcCmdClearDepthStencilImage +CmdControlVideoCodingKHR: ProcCmdControlVideoCodingKHR +CmdCopyAccelerationStructureKHR: ProcCmdCopyAccelerationStructureKHR +CmdCopyAccelerationStructureNV: ProcCmdCopyAccelerationStructureNV +CmdCopyAccelerationStructureToMemoryKHR: ProcCmdCopyAccelerationStructureToMemoryKHR +CmdCopyBuffer: ProcCmdCopyBuffer +CmdCopyBuffer2: ProcCmdCopyBuffer2 +CmdCopyBuffer2KHR: ProcCmdCopyBuffer2KHR +CmdCopyBufferToImage: ProcCmdCopyBufferToImage +CmdCopyBufferToImage2: ProcCmdCopyBufferToImage2 +CmdCopyBufferToImage2KHR: ProcCmdCopyBufferToImage2KHR +CmdCopyImage: ProcCmdCopyImage +CmdCopyImage2: ProcCmdCopyImage2 +CmdCopyImage2KHR: ProcCmdCopyImage2KHR +CmdCopyImageToBuffer: ProcCmdCopyImageToBuffer +CmdCopyImageToBuffer2: ProcCmdCopyImageToBuffer2 +CmdCopyImageToBuffer2KHR: ProcCmdCopyImageToBuffer2KHR +CmdCopyMemoryIndirectNV: ProcCmdCopyMemoryIndirectNV +CmdCopyMemoryToAccelerationStructureKHR: ProcCmdCopyMemoryToAccelerationStructureKHR +CmdCopyMemoryToImageIndirectNV: ProcCmdCopyMemoryToImageIndirectNV +CmdCopyMemoryToMicromapEXT: ProcCmdCopyMemoryToMicromapEXT +CmdCopyMicromapEXT: ProcCmdCopyMicromapEXT +CmdCopyMicromapToMemoryEXT: ProcCmdCopyMicromapToMemoryEXT +CmdCopyQueryPoolResults: ProcCmdCopyQueryPoolResults +CmdCuLaunchKernelNVX: ProcCmdCuLaunchKernelNVX +CmdDebugMarkerBeginEXT: ProcCmdDebugMarkerBeginEXT +CmdDebugMarkerEndEXT: ProcCmdDebugMarkerEndEXT +CmdDebugMarkerInsertEXT: ProcCmdDebugMarkerInsertEXT +CmdDecodeVideoKHR: ProcCmdDecodeVideoKHR +CmdDecompressMemoryIndirectCountNV: ProcCmdDecompressMemoryIndirectCountNV +CmdDecompressMemoryNV: ProcCmdDecompressMemoryNV +CmdDispatch: ProcCmdDispatch +CmdDispatchBase: ProcCmdDispatchBase +CmdDispatchBaseKHR: ProcCmdDispatchBaseKHR +CmdDispatchIndirect: ProcCmdDispatchIndirect +CmdDraw: ProcCmdDraw +CmdDrawClusterHUAWEI: ProcCmdDrawClusterHUAWEI +CmdDrawClusterIndirectHUAWEI: ProcCmdDrawClusterIndirectHUAWEI +CmdDrawIndexed: ProcCmdDrawIndexed +CmdDrawIndexedIndirect: ProcCmdDrawIndexedIndirect +CmdDrawIndexedIndirectCount: ProcCmdDrawIndexedIndirectCount +CmdDrawIndexedIndirectCountAMD: ProcCmdDrawIndexedIndirectCountAMD +CmdDrawIndexedIndirectCountKHR: ProcCmdDrawIndexedIndirectCountKHR +CmdDrawIndirect: ProcCmdDrawIndirect +CmdDrawIndirectByteCountEXT: ProcCmdDrawIndirectByteCountEXT +CmdDrawIndirectCount: ProcCmdDrawIndirectCount +CmdDrawIndirectCountAMD: ProcCmdDrawIndirectCountAMD +CmdDrawIndirectCountKHR: ProcCmdDrawIndirectCountKHR +CmdDrawMeshTasksEXT: ProcCmdDrawMeshTasksEXT +CmdDrawMeshTasksIndirectCountEXT: ProcCmdDrawMeshTasksIndirectCountEXT +CmdDrawMeshTasksIndirectCountNV: ProcCmdDrawMeshTasksIndirectCountNV +CmdDrawMeshTasksIndirectEXT: ProcCmdDrawMeshTasksIndirectEXT +CmdDrawMeshTasksIndirectNV: ProcCmdDrawMeshTasksIndirectNV +CmdDrawMeshTasksNV: ProcCmdDrawMeshTasksNV +CmdDrawMultiEXT: ProcCmdDrawMultiEXT +CmdDrawMultiIndexedEXT: ProcCmdDrawMultiIndexedEXT +CmdEndConditionalRenderingEXT: ProcCmdEndConditionalRenderingEXT +CmdEndDebugUtilsLabelEXT: ProcCmdEndDebugUtilsLabelEXT +CmdEndQuery: ProcCmdEndQuery +CmdEndQueryIndexedEXT: ProcCmdEndQueryIndexedEXT +CmdEndRenderPass: ProcCmdEndRenderPass +CmdEndRenderPass2: ProcCmdEndRenderPass2 +CmdEndRenderPass2KHR: ProcCmdEndRenderPass2KHR +CmdEndRendering: ProcCmdEndRendering +CmdEndRenderingKHR: ProcCmdEndRenderingKHR +CmdEndTransformFeedbackEXT: ProcCmdEndTransformFeedbackEXT +CmdEndVideoCodingKHR: ProcCmdEndVideoCodingKHR +CmdExecuteCommands: ProcCmdExecuteCommands +CmdExecuteGeneratedCommandsNV: ProcCmdExecuteGeneratedCommandsNV +CmdFillBuffer: ProcCmdFillBuffer +CmdInsertDebugUtilsLabelEXT: ProcCmdInsertDebugUtilsLabelEXT +CmdNextSubpass: ProcCmdNextSubpass +CmdNextSubpass2: ProcCmdNextSubpass2 +CmdNextSubpass2KHR: ProcCmdNextSubpass2KHR +CmdOpticalFlowExecuteNV: ProcCmdOpticalFlowExecuteNV +CmdPipelineBarrier: ProcCmdPipelineBarrier +CmdPipelineBarrier2: ProcCmdPipelineBarrier2 +CmdPipelineBarrier2KHR: ProcCmdPipelineBarrier2KHR +CmdPreprocessGeneratedCommandsNV: ProcCmdPreprocessGeneratedCommandsNV +CmdPushConstants: ProcCmdPushConstants +CmdPushDescriptorSetKHR: ProcCmdPushDescriptorSetKHR +CmdPushDescriptorSetWithTemplateKHR: ProcCmdPushDescriptorSetWithTemplateKHR +CmdResetEvent: ProcCmdResetEvent +CmdResetEvent2: ProcCmdResetEvent2 +CmdResetEvent2KHR: ProcCmdResetEvent2KHR +CmdResetQueryPool: ProcCmdResetQueryPool +CmdResolveImage: ProcCmdResolveImage +CmdResolveImage2: ProcCmdResolveImage2 +CmdResolveImage2KHR: ProcCmdResolveImage2KHR +CmdSetAlphaToCoverageEnableEXT: ProcCmdSetAlphaToCoverageEnableEXT +CmdSetAlphaToOneEnableEXT: ProcCmdSetAlphaToOneEnableEXT +CmdSetAttachmentFeedbackLoopEnableEXT: ProcCmdSetAttachmentFeedbackLoopEnableEXT +CmdSetBlendConstants: ProcCmdSetBlendConstants +CmdSetCheckpointNV: ProcCmdSetCheckpointNV +CmdSetCoarseSampleOrderNV: ProcCmdSetCoarseSampleOrderNV +CmdSetColorBlendAdvancedEXT: ProcCmdSetColorBlendAdvancedEXT +CmdSetColorBlendEnableEXT: ProcCmdSetColorBlendEnableEXT +CmdSetColorBlendEquationEXT: ProcCmdSetColorBlendEquationEXT +CmdSetColorWriteMaskEXT: ProcCmdSetColorWriteMaskEXT +CmdSetConservativeRasterizationModeEXT: ProcCmdSetConservativeRasterizationModeEXT +CmdSetCoverageModulationModeNV: ProcCmdSetCoverageModulationModeNV +CmdSetCoverageModulationTableEnableNV: ProcCmdSetCoverageModulationTableEnableNV +CmdSetCoverageModulationTableNV: ProcCmdSetCoverageModulationTableNV +CmdSetCoverageReductionModeNV: ProcCmdSetCoverageReductionModeNV +CmdSetCoverageToColorEnableNV: ProcCmdSetCoverageToColorEnableNV +CmdSetCoverageToColorLocationNV: ProcCmdSetCoverageToColorLocationNV +CmdSetCullMode: ProcCmdSetCullMode +CmdSetCullModeEXT: ProcCmdSetCullModeEXT +CmdSetDepthBias: ProcCmdSetDepthBias +CmdSetDepthBiasEnable: ProcCmdSetDepthBiasEnable +CmdSetDepthBiasEnableEXT: ProcCmdSetDepthBiasEnableEXT +CmdSetDepthBounds: ProcCmdSetDepthBounds +CmdSetDepthBoundsTestEnable: ProcCmdSetDepthBoundsTestEnable +CmdSetDepthBoundsTestEnableEXT: ProcCmdSetDepthBoundsTestEnableEXT +CmdSetDepthClampEnableEXT: ProcCmdSetDepthClampEnableEXT +CmdSetDepthClipEnableEXT: ProcCmdSetDepthClipEnableEXT +CmdSetDepthClipNegativeOneToOneEXT: ProcCmdSetDepthClipNegativeOneToOneEXT +CmdSetDepthCompareOp: ProcCmdSetDepthCompareOp +CmdSetDepthCompareOpEXT: ProcCmdSetDepthCompareOpEXT +CmdSetDepthTestEnable: ProcCmdSetDepthTestEnable +CmdSetDepthTestEnableEXT: ProcCmdSetDepthTestEnableEXT +CmdSetDepthWriteEnable: ProcCmdSetDepthWriteEnable +CmdSetDepthWriteEnableEXT: ProcCmdSetDepthWriteEnableEXT +CmdSetDescriptorBufferOffsetsEXT: ProcCmdSetDescriptorBufferOffsetsEXT +CmdSetDeviceMask: ProcCmdSetDeviceMask +CmdSetDeviceMaskKHR: ProcCmdSetDeviceMaskKHR +CmdSetDiscardRectangleEXT: ProcCmdSetDiscardRectangleEXT +CmdSetDiscardRectangleEnableEXT: ProcCmdSetDiscardRectangleEnableEXT +CmdSetDiscardRectangleModeEXT: ProcCmdSetDiscardRectangleModeEXT +CmdSetEvent: ProcCmdSetEvent +CmdSetEvent2: ProcCmdSetEvent2 +CmdSetEvent2KHR: ProcCmdSetEvent2KHR +CmdSetExclusiveScissorEnableNV: ProcCmdSetExclusiveScissorEnableNV +CmdSetExclusiveScissorNV: ProcCmdSetExclusiveScissorNV +CmdSetExtraPrimitiveOverestimationSizeEXT: ProcCmdSetExtraPrimitiveOverestimationSizeEXT +CmdSetFragmentShadingRateEnumNV: ProcCmdSetFragmentShadingRateEnumNV +CmdSetFragmentShadingRateKHR: ProcCmdSetFragmentShadingRateKHR +CmdSetFrontFace: ProcCmdSetFrontFace +CmdSetFrontFaceEXT: ProcCmdSetFrontFaceEXT +CmdSetLineRasterizationModeEXT: ProcCmdSetLineRasterizationModeEXT +CmdSetLineStippleEXT: ProcCmdSetLineStippleEXT +CmdSetLineStippleEnableEXT: ProcCmdSetLineStippleEnableEXT +CmdSetLineWidth: ProcCmdSetLineWidth +CmdSetLogicOpEXT: ProcCmdSetLogicOpEXT +CmdSetLogicOpEnableEXT: ProcCmdSetLogicOpEnableEXT +CmdSetPatchControlPointsEXT: ProcCmdSetPatchControlPointsEXT +CmdSetPerformanceMarkerINTEL: ProcCmdSetPerformanceMarkerINTEL +CmdSetPerformanceOverrideINTEL: ProcCmdSetPerformanceOverrideINTEL +CmdSetPerformanceStreamMarkerINTEL: ProcCmdSetPerformanceStreamMarkerINTEL +CmdSetPolygonModeEXT: ProcCmdSetPolygonModeEXT +CmdSetPrimitiveRestartEnable: ProcCmdSetPrimitiveRestartEnable +CmdSetPrimitiveRestartEnableEXT: ProcCmdSetPrimitiveRestartEnableEXT +CmdSetPrimitiveTopology: ProcCmdSetPrimitiveTopology +CmdSetPrimitiveTopologyEXT: ProcCmdSetPrimitiveTopologyEXT +CmdSetProvokingVertexModeEXT: ProcCmdSetProvokingVertexModeEXT +CmdSetRasterizationSamplesEXT: ProcCmdSetRasterizationSamplesEXT +CmdSetRasterizationStreamEXT: ProcCmdSetRasterizationStreamEXT +CmdSetRasterizerDiscardEnable: ProcCmdSetRasterizerDiscardEnable +CmdSetRasterizerDiscardEnableEXT: ProcCmdSetRasterizerDiscardEnableEXT +CmdSetRayTracingPipelineStackSizeKHR: ProcCmdSetRayTracingPipelineStackSizeKHR +CmdSetRepresentativeFragmentTestEnableNV: ProcCmdSetRepresentativeFragmentTestEnableNV +CmdSetSampleLocationsEXT: ProcCmdSetSampleLocationsEXT +CmdSetSampleLocationsEnableEXT: ProcCmdSetSampleLocationsEnableEXT +CmdSetSampleMaskEXT: ProcCmdSetSampleMaskEXT +CmdSetScissor: ProcCmdSetScissor +CmdSetScissorWithCount: ProcCmdSetScissorWithCount +CmdSetScissorWithCountEXT: ProcCmdSetScissorWithCountEXT +CmdSetShadingRateImageEnableNV: ProcCmdSetShadingRateImageEnableNV +CmdSetStencilCompareMask: ProcCmdSetStencilCompareMask +CmdSetStencilOp: ProcCmdSetStencilOp +CmdSetStencilOpEXT: ProcCmdSetStencilOpEXT +CmdSetStencilReference: ProcCmdSetStencilReference +CmdSetStencilTestEnable: ProcCmdSetStencilTestEnable +CmdSetStencilTestEnableEXT: ProcCmdSetStencilTestEnableEXT +CmdSetStencilWriteMask: ProcCmdSetStencilWriteMask +CmdSetTessellationDomainOriginEXT: ProcCmdSetTessellationDomainOriginEXT +CmdSetVertexInputEXT: ProcCmdSetVertexInputEXT +CmdSetViewport: ProcCmdSetViewport +CmdSetViewportShadingRatePaletteNV: ProcCmdSetViewportShadingRatePaletteNV +CmdSetViewportSwizzleNV: ProcCmdSetViewportSwizzleNV +CmdSetViewportWScalingEnableNV: ProcCmdSetViewportWScalingEnableNV +CmdSetViewportWScalingNV: ProcCmdSetViewportWScalingNV +CmdSetViewportWithCount: ProcCmdSetViewportWithCount +CmdSetViewportWithCountEXT: ProcCmdSetViewportWithCountEXT +CmdSubpassShadingHUAWEI: ProcCmdSubpassShadingHUAWEI +CmdTraceRaysIndirect2KHR: ProcCmdTraceRaysIndirect2KHR +CmdTraceRaysIndirectKHR: ProcCmdTraceRaysIndirectKHR +CmdTraceRaysKHR: ProcCmdTraceRaysKHR +CmdTraceRaysNV: ProcCmdTraceRaysNV +CmdUpdateBuffer: ProcCmdUpdateBuffer +CmdWaitEvents: ProcCmdWaitEvents +CmdWaitEvents2: ProcCmdWaitEvents2 +CmdWaitEvents2KHR: ProcCmdWaitEvents2KHR +CmdWriteAccelerationStructuresPropertiesKHR: ProcCmdWriteAccelerationStructuresPropertiesKHR +CmdWriteAccelerationStructuresPropertiesNV: ProcCmdWriteAccelerationStructuresPropertiesNV +CmdWriteBufferMarker2AMD: ProcCmdWriteBufferMarker2AMD +CmdWriteBufferMarkerAMD: ProcCmdWriteBufferMarkerAMD +CmdWriteMicromapsPropertiesEXT: ProcCmdWriteMicromapsPropertiesEXT +CmdWriteTimestamp: ProcCmdWriteTimestamp +CmdWriteTimestamp2: ProcCmdWriteTimestamp2 +CmdWriteTimestamp2KHR: ProcCmdWriteTimestamp2KHR +CompileDeferredNV: ProcCompileDeferredNV +CopyAccelerationStructureKHR: ProcCopyAccelerationStructureKHR +CopyAccelerationStructureToMemoryKHR: ProcCopyAccelerationStructureToMemoryKHR +CopyMemoryToAccelerationStructureKHR: ProcCopyMemoryToAccelerationStructureKHR +CopyMemoryToMicromapEXT: ProcCopyMemoryToMicromapEXT +CopyMicromapEXT: ProcCopyMicromapEXT +CopyMicromapToMemoryEXT: ProcCopyMicromapToMemoryEXT +CreateAccelerationStructureKHR: ProcCreateAccelerationStructureKHR +CreateAccelerationStructureNV: ProcCreateAccelerationStructureNV +CreateBuffer: ProcCreateBuffer +CreateBufferView: ProcCreateBufferView +CreateCommandPool: ProcCreateCommandPool +CreateComputePipelines: ProcCreateComputePipelines +CreateCuFunctionNVX: ProcCreateCuFunctionNVX +CreateCuModuleNVX: ProcCreateCuModuleNVX +CreateDeferredOperationKHR: ProcCreateDeferredOperationKHR +CreateDescriptorPool: ProcCreateDescriptorPool +CreateDescriptorSetLayout: ProcCreateDescriptorSetLayout +CreateDescriptorUpdateTemplate: ProcCreateDescriptorUpdateTemplate +CreateDescriptorUpdateTemplateKHR: ProcCreateDescriptorUpdateTemplateKHR +CreateEvent: ProcCreateEvent +CreateFence: ProcCreateFence +CreateFramebuffer: ProcCreateFramebuffer +CreateGraphicsPipelines: ProcCreateGraphicsPipelines +CreateImage: ProcCreateImage +CreateImageView: ProcCreateImageView +CreateIndirectCommandsLayoutNV: ProcCreateIndirectCommandsLayoutNV +CreateMicromapEXT: ProcCreateMicromapEXT +CreateOpticalFlowSessionNV: ProcCreateOpticalFlowSessionNV +CreatePipelineCache: ProcCreatePipelineCache +CreatePipelineLayout: ProcCreatePipelineLayout +CreatePrivateDataSlot: ProcCreatePrivateDataSlot +CreatePrivateDataSlotEXT: ProcCreatePrivateDataSlotEXT +CreateQueryPool: ProcCreateQueryPool +CreateRayTracingPipelinesKHR: ProcCreateRayTracingPipelinesKHR +CreateRayTracingPipelinesNV: ProcCreateRayTracingPipelinesNV +CreateRenderPass: ProcCreateRenderPass +CreateRenderPass2: ProcCreateRenderPass2 +CreateRenderPass2KHR: ProcCreateRenderPass2KHR +CreateSampler: ProcCreateSampler +CreateSamplerYcbcrConversion: ProcCreateSamplerYcbcrConversion +CreateSamplerYcbcrConversionKHR: ProcCreateSamplerYcbcrConversionKHR +CreateSemaphore: ProcCreateSemaphore +CreateShaderModule: ProcCreateShaderModule +CreateShadersEXT: ProcCreateShadersEXT +CreateSharedSwapchainsKHR: ProcCreateSharedSwapchainsKHR +CreateSwapchainKHR: ProcCreateSwapchainKHR +CreateValidationCacheEXT: ProcCreateValidationCacheEXT +CreateVideoSessionKHR: ProcCreateVideoSessionKHR +CreateVideoSessionParametersKHR: ProcCreateVideoSessionParametersKHR +DebugMarkerSetObjectNameEXT: ProcDebugMarkerSetObjectNameEXT +DebugMarkerSetObjectTagEXT: ProcDebugMarkerSetObjectTagEXT +DeferredOperationJoinKHR: ProcDeferredOperationJoinKHR +DestroyAccelerationStructureKHR: ProcDestroyAccelerationStructureKHR +DestroyAccelerationStructureNV: ProcDestroyAccelerationStructureNV +DestroyBuffer: ProcDestroyBuffer +DestroyBufferView: ProcDestroyBufferView +DestroyCommandPool: ProcDestroyCommandPool +DestroyCuFunctionNVX: ProcDestroyCuFunctionNVX +DestroyCuModuleNVX: ProcDestroyCuModuleNVX +DestroyDeferredOperationKHR: ProcDestroyDeferredOperationKHR +DestroyDescriptorPool: ProcDestroyDescriptorPool +DestroyDescriptorSetLayout: ProcDestroyDescriptorSetLayout +DestroyDescriptorUpdateTemplate: ProcDestroyDescriptorUpdateTemplate +DestroyDescriptorUpdateTemplateKHR: ProcDestroyDescriptorUpdateTemplateKHR +DestroyDevice: ProcDestroyDevice +DestroyEvent: ProcDestroyEvent +DestroyFence: ProcDestroyFence +DestroyFramebuffer: ProcDestroyFramebuffer +DestroyImage: ProcDestroyImage +DestroyImageView: ProcDestroyImageView +DestroyIndirectCommandsLayoutNV: ProcDestroyIndirectCommandsLayoutNV +DestroyMicromapEXT: ProcDestroyMicromapEXT +DestroyOpticalFlowSessionNV: ProcDestroyOpticalFlowSessionNV +DestroyPipeline: ProcDestroyPipeline +DestroyPipelineCache: ProcDestroyPipelineCache +DestroyPipelineLayout: ProcDestroyPipelineLayout +DestroyPrivateDataSlot: ProcDestroyPrivateDataSlot +DestroyPrivateDataSlotEXT: ProcDestroyPrivateDataSlotEXT +DestroyQueryPool: ProcDestroyQueryPool +DestroyRenderPass: ProcDestroyRenderPass +DestroySampler: ProcDestroySampler +DestroySamplerYcbcrConversion: ProcDestroySamplerYcbcrConversion +DestroySamplerYcbcrConversionKHR: ProcDestroySamplerYcbcrConversionKHR +DestroySemaphore: ProcDestroySemaphore +DestroyShaderEXT: ProcDestroyShaderEXT +DestroyShaderModule: ProcDestroyShaderModule +DestroySwapchainKHR: ProcDestroySwapchainKHR +DestroyValidationCacheEXT: ProcDestroyValidationCacheEXT +DestroyVideoSessionKHR: ProcDestroyVideoSessionKHR +DestroyVideoSessionParametersKHR: ProcDestroyVideoSessionParametersKHR +DeviceWaitIdle: ProcDeviceWaitIdle +DisplayPowerControlEXT: ProcDisplayPowerControlEXT +EndCommandBuffer: ProcEndCommandBuffer +ExportMetalObjectsEXT: ProcExportMetalObjectsEXT +FlushMappedMemoryRanges: ProcFlushMappedMemoryRanges +FreeCommandBuffers: ProcFreeCommandBuffers +FreeDescriptorSets: ProcFreeDescriptorSets +FreeMemory: ProcFreeMemory +GetAccelerationStructureBuildSizesKHR: ProcGetAccelerationStructureBuildSizesKHR +GetAccelerationStructureDeviceAddressKHR: ProcGetAccelerationStructureDeviceAddressKHR +GetAccelerationStructureHandleNV: ProcGetAccelerationStructureHandleNV +GetAccelerationStructureMemoryRequirementsNV: ProcGetAccelerationStructureMemoryRequirementsNV +GetAccelerationStructureOpaqueCaptureDescriptorDataEXT: ProcGetAccelerationStructureOpaqueCaptureDescriptorDataEXT +GetBufferDeviceAddress: ProcGetBufferDeviceAddress +GetBufferDeviceAddressEXT: ProcGetBufferDeviceAddressEXT +GetBufferDeviceAddressKHR: ProcGetBufferDeviceAddressKHR +GetBufferMemoryRequirements: ProcGetBufferMemoryRequirements +GetBufferMemoryRequirements2: ProcGetBufferMemoryRequirements2 +GetBufferMemoryRequirements2KHR: ProcGetBufferMemoryRequirements2KHR +GetBufferOpaqueCaptureAddress: ProcGetBufferOpaqueCaptureAddress +GetBufferOpaqueCaptureAddressKHR: ProcGetBufferOpaqueCaptureAddressKHR +GetBufferOpaqueCaptureDescriptorDataEXT: ProcGetBufferOpaqueCaptureDescriptorDataEXT +GetCalibratedTimestampsEXT: ProcGetCalibratedTimestampsEXT +GetDeferredOperationMaxConcurrencyKHR: ProcGetDeferredOperationMaxConcurrencyKHR +GetDeferredOperationResultKHR: ProcGetDeferredOperationResultKHR +GetDescriptorEXT: ProcGetDescriptorEXT +GetDescriptorSetHostMappingVALVE: ProcGetDescriptorSetHostMappingVALVE +GetDescriptorSetLayoutBindingOffsetEXT: ProcGetDescriptorSetLayoutBindingOffsetEXT +GetDescriptorSetLayoutHostMappingInfoVALVE: ProcGetDescriptorSetLayoutHostMappingInfoVALVE +GetDescriptorSetLayoutSizeEXT: ProcGetDescriptorSetLayoutSizeEXT +GetDescriptorSetLayoutSupport: ProcGetDescriptorSetLayoutSupport +GetDescriptorSetLayoutSupportKHR: ProcGetDescriptorSetLayoutSupportKHR +GetDeviceAccelerationStructureCompatibilityKHR: ProcGetDeviceAccelerationStructureCompatibilityKHR +GetDeviceBufferMemoryRequirements: ProcGetDeviceBufferMemoryRequirements +GetDeviceBufferMemoryRequirementsKHR: ProcGetDeviceBufferMemoryRequirementsKHR +GetDeviceFaultInfoEXT: ProcGetDeviceFaultInfoEXT +GetDeviceGroupPeerMemoryFeatures: ProcGetDeviceGroupPeerMemoryFeatures +GetDeviceGroupPeerMemoryFeaturesKHR: ProcGetDeviceGroupPeerMemoryFeaturesKHR +GetDeviceGroupPresentCapabilitiesKHR: ProcGetDeviceGroupPresentCapabilitiesKHR +GetDeviceGroupSurfacePresentModes2EXT: ProcGetDeviceGroupSurfacePresentModes2EXT +GetDeviceGroupSurfacePresentModesKHR: ProcGetDeviceGroupSurfacePresentModesKHR +GetDeviceImageMemoryRequirements: ProcGetDeviceImageMemoryRequirements +GetDeviceImageMemoryRequirementsKHR: ProcGetDeviceImageMemoryRequirementsKHR +GetDeviceImageSparseMemoryRequirements: ProcGetDeviceImageSparseMemoryRequirements +GetDeviceImageSparseMemoryRequirementsKHR: ProcGetDeviceImageSparseMemoryRequirementsKHR +GetDeviceMemoryCommitment: ProcGetDeviceMemoryCommitment +GetDeviceMemoryOpaqueCaptureAddress: ProcGetDeviceMemoryOpaqueCaptureAddress +GetDeviceMemoryOpaqueCaptureAddressKHR: ProcGetDeviceMemoryOpaqueCaptureAddressKHR +GetDeviceMicromapCompatibilityEXT: ProcGetDeviceMicromapCompatibilityEXT +GetDeviceProcAddr: ProcGetDeviceProcAddr +GetDeviceQueue: ProcGetDeviceQueue +GetDeviceQueue2: ProcGetDeviceQueue2 +GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI +GetDynamicRenderingTilePropertiesQCOM: ProcGetDynamicRenderingTilePropertiesQCOM +GetEventStatus: ProcGetEventStatus +GetFenceFdKHR: ProcGetFenceFdKHR +GetFenceStatus: ProcGetFenceStatus +GetFenceWin32HandleKHR: ProcGetFenceWin32HandleKHR +GetFramebufferTilePropertiesQCOM: ProcGetFramebufferTilePropertiesQCOM +GetGeneratedCommandsMemoryRequirementsNV: ProcGetGeneratedCommandsMemoryRequirementsNV +GetImageDrmFormatModifierPropertiesEXT: ProcGetImageDrmFormatModifierPropertiesEXT +GetImageMemoryRequirements: ProcGetImageMemoryRequirements +GetImageMemoryRequirements2: ProcGetImageMemoryRequirements2 +GetImageMemoryRequirements2KHR: ProcGetImageMemoryRequirements2KHR +GetImageOpaqueCaptureDescriptorDataEXT: ProcGetImageOpaqueCaptureDescriptorDataEXT +GetImageSparseMemoryRequirements: ProcGetImageSparseMemoryRequirements +GetImageSparseMemoryRequirements2: ProcGetImageSparseMemoryRequirements2 +GetImageSparseMemoryRequirements2KHR: ProcGetImageSparseMemoryRequirements2KHR +GetImageSubresourceLayout: ProcGetImageSubresourceLayout +GetImageSubresourceLayout2EXT: ProcGetImageSubresourceLayout2EXT +GetImageViewAddressNVX: ProcGetImageViewAddressNVX +GetImageViewHandleNVX: ProcGetImageViewHandleNVX +GetImageViewOpaqueCaptureDescriptorDataEXT: ProcGetImageViewOpaqueCaptureDescriptorDataEXT +GetMemoryFdKHR: ProcGetMemoryFdKHR +GetMemoryFdPropertiesKHR: ProcGetMemoryFdPropertiesKHR +GetMemoryHostPointerPropertiesEXT: ProcGetMemoryHostPointerPropertiesEXT +GetMemoryRemoteAddressNV: ProcGetMemoryRemoteAddressNV +GetMemoryWin32HandleKHR: ProcGetMemoryWin32HandleKHR +GetMemoryWin32HandleNV: ProcGetMemoryWin32HandleNV +GetMemoryWin32HandlePropertiesKHR: ProcGetMemoryWin32HandlePropertiesKHR +GetMicromapBuildSizesEXT: ProcGetMicromapBuildSizesEXT +GetPastPresentationTimingGOOGLE: ProcGetPastPresentationTimingGOOGLE +GetPerformanceParameterINTEL: ProcGetPerformanceParameterINTEL +GetPipelineCacheData: ProcGetPipelineCacheData +GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR +GetPipelineExecutablePropertiesKHR: ProcGetPipelineExecutablePropertiesKHR +GetPipelineExecutableStatisticsKHR: ProcGetPipelineExecutableStatisticsKHR +GetPipelinePropertiesEXT: ProcGetPipelinePropertiesEXT +GetPrivateData: ProcGetPrivateData +GetPrivateDataEXT: ProcGetPrivateDataEXT +GetQueryPoolResults: ProcGetQueryPoolResults +GetQueueCheckpointData2NV: ProcGetQueueCheckpointData2NV +GetQueueCheckpointDataNV: ProcGetQueueCheckpointDataNV +GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR +GetRayTracingShaderGroupHandlesKHR: ProcGetRayTracingShaderGroupHandlesKHR +GetRayTracingShaderGroupHandlesNV: ProcGetRayTracingShaderGroupHandlesNV +GetRayTracingShaderGroupStackSizeKHR: ProcGetRayTracingShaderGroupStackSizeKHR +GetRefreshCycleDurationGOOGLE: ProcGetRefreshCycleDurationGOOGLE +GetRenderAreaGranularity: ProcGetRenderAreaGranularity +GetSamplerOpaqueCaptureDescriptorDataEXT: ProcGetSamplerOpaqueCaptureDescriptorDataEXT +GetSemaphoreCounterValue: ProcGetSemaphoreCounterValue +GetSemaphoreCounterValueKHR: ProcGetSemaphoreCounterValueKHR +GetSemaphoreFdKHR: ProcGetSemaphoreFdKHR +GetSemaphoreWin32HandleKHR: ProcGetSemaphoreWin32HandleKHR +GetShaderBinaryDataEXT: ProcGetShaderBinaryDataEXT +GetShaderInfoAMD: ProcGetShaderInfoAMD +GetShaderModuleCreateInfoIdentifierEXT: ProcGetShaderModuleCreateInfoIdentifierEXT +GetShaderModuleIdentifierEXT: ProcGetShaderModuleIdentifierEXT +GetSwapchainCounterEXT: ProcGetSwapchainCounterEXT +GetSwapchainImagesKHR: ProcGetSwapchainImagesKHR +GetSwapchainStatusKHR: ProcGetSwapchainStatusKHR +GetValidationCacheDataEXT: ProcGetValidationCacheDataEXT +GetVideoSessionMemoryRequirementsKHR: ProcGetVideoSessionMemoryRequirementsKHR +ImportFenceFdKHR: ProcImportFenceFdKHR +ImportFenceWin32HandleKHR: ProcImportFenceWin32HandleKHR +ImportSemaphoreFdKHR: ProcImportSemaphoreFdKHR +ImportSemaphoreWin32HandleKHR: ProcImportSemaphoreWin32HandleKHR +InitializePerformanceApiINTEL: ProcInitializePerformanceApiINTEL +InvalidateMappedMemoryRanges: ProcInvalidateMappedMemoryRanges +MapMemory: ProcMapMemory +MapMemory2KHR: ProcMapMemory2KHR +MergePipelineCaches: ProcMergePipelineCaches +MergeValidationCachesEXT: ProcMergeValidationCachesEXT +QueueBeginDebugUtilsLabelEXT: ProcQueueBeginDebugUtilsLabelEXT +QueueBindSparse: ProcQueueBindSparse +QueueEndDebugUtilsLabelEXT: ProcQueueEndDebugUtilsLabelEXT +QueueInsertDebugUtilsLabelEXT: ProcQueueInsertDebugUtilsLabelEXT +QueuePresentKHR: ProcQueuePresentKHR +QueueSetPerformanceConfigurationINTEL: ProcQueueSetPerformanceConfigurationINTEL +QueueSubmit: ProcQueueSubmit +QueueSubmit2: ProcQueueSubmit2 +QueueSubmit2KHR: ProcQueueSubmit2KHR +QueueWaitIdle: ProcQueueWaitIdle +RegisterDeviceEventEXT: ProcRegisterDeviceEventEXT +RegisterDisplayEventEXT: ProcRegisterDisplayEventEXT +ReleaseFullScreenExclusiveModeEXT: ProcReleaseFullScreenExclusiveModeEXT +ReleasePerformanceConfigurationINTEL: ProcReleasePerformanceConfigurationINTEL +ReleaseProfilingLockKHR: ProcReleaseProfilingLockKHR +ReleaseSwapchainImagesEXT: ProcReleaseSwapchainImagesEXT +ResetCommandBuffer: ProcResetCommandBuffer +ResetCommandPool: ProcResetCommandPool +ResetDescriptorPool: ProcResetDescriptorPool +ResetEvent: ProcResetEvent +ResetFences: ProcResetFences +ResetQueryPool: ProcResetQueryPool +ResetQueryPoolEXT: ProcResetQueryPoolEXT +SetDebugUtilsObjectNameEXT: ProcSetDebugUtilsObjectNameEXT +SetDebugUtilsObjectTagEXT: ProcSetDebugUtilsObjectTagEXT +SetDeviceMemoryPriorityEXT: ProcSetDeviceMemoryPriorityEXT +SetEvent: ProcSetEvent +SetHdrMetadataEXT: ProcSetHdrMetadataEXT +SetLocalDimmingAMD: ProcSetLocalDimmingAMD +SetPrivateData: ProcSetPrivateData +SetPrivateDataEXT: ProcSetPrivateDataEXT +SignalSemaphore: ProcSignalSemaphore +SignalSemaphoreKHR: ProcSignalSemaphoreKHR +TrimCommandPool: ProcTrimCommandPool +TrimCommandPoolKHR: ProcTrimCommandPoolKHR +UninitializePerformanceApiINTEL: ProcUninitializePerformanceApiINTEL +UnmapMemory: ProcUnmapMemory +UnmapMemory2KHR: ProcUnmapMemory2KHR +UpdateDescriptorSetWithTemplate: ProcUpdateDescriptorSetWithTemplate +UpdateDescriptorSetWithTemplateKHR: ProcUpdateDescriptorSetWithTemplateKHR +UpdateDescriptorSets: ProcUpdateDescriptorSets +UpdateVideoSessionParametersKHR: ProcUpdateVideoSessionParametersKHR +WaitForFences: ProcWaitForFences +WaitForPresentKHR: ProcWaitForPresentKHR +WaitSemaphores: ProcWaitSemaphores +WaitSemaphoresKHR: ProcWaitSemaphoresKHR +WriteAccelerationStructuresPropertiesKHR: ProcWriteAccelerationStructuresPropertiesKHR +WriteMicromapsPropertiesEXT: ProcWriteMicromapsPropertiesEXT load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) { // Loader Procedures @@ -1082,6 +1290,7 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) { set_proc_address(&GetDisplayPlaneCapabilitiesKHR, "vkGetDisplayPlaneCapabilitiesKHR") set_proc_address(&GetDisplayPlaneSupportedDisplaysKHR, "vkGetDisplayPlaneSupportedDisplaysKHR") set_proc_address(&GetDrmDisplayEXT, "vkGetDrmDisplayEXT") + set_proc_address(&GetInstanceProcAddrLUNARG, "vkGetInstanceProcAddrLUNARG") set_proc_address(&GetPhysicalDeviceCalibrateableTimeDomainsEXT, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT") set_proc_address(&GetPhysicalDeviceCooperativeMatrixPropertiesNV, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV") set_proc_address(&GetPhysicalDeviceDisplayPlaneProperties2KHR, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") @@ -1109,6 +1318,7 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) { set_proc_address(&GetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2") set_proc_address(&GetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR") set_proc_address(&GetPhysicalDeviceMultisamplePropertiesEXT, "vkGetPhysicalDeviceMultisamplePropertiesEXT") + set_proc_address(&GetPhysicalDeviceOpticalFlowImageFormatsNV, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV") set_proc_address(&GetPhysicalDevicePresentRectanglesKHR, "vkGetPhysicalDevicePresentRectanglesKHR") set_proc_address(&GetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties") set_proc_address(&GetPhysicalDeviceProperties2, "vkGetPhysicalDeviceProperties2") @@ -1131,6 +1341,8 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) { set_proc_address(&GetPhysicalDeviceSurfaceSupportKHR, "vkGetPhysicalDeviceSurfaceSupportKHR") set_proc_address(&GetPhysicalDeviceToolProperties, "vkGetPhysicalDeviceToolProperties") set_proc_address(&GetPhysicalDeviceToolPropertiesEXT, "vkGetPhysicalDeviceToolPropertiesEXT") + set_proc_address(&GetPhysicalDeviceVideoCapabilitiesKHR, "vkGetPhysicalDeviceVideoCapabilitiesKHR") + set_proc_address(&GetPhysicalDeviceVideoFormatPropertiesKHR, "vkGetPhysicalDeviceVideoFormatPropertiesKHR") set_proc_address(&GetPhysicalDeviceWaylandPresentationSupportKHR, "vkGetPhysicalDeviceWaylandPresentationSupportKHR") set_proc_address(&GetPhysicalDeviceWin32PresentationSupportKHR, "vkGetPhysicalDeviceWin32PresentationSupportKHR") set_proc_address(&GetWinrtDisplayNV, "vkGetWinrtDisplayNV") @@ -1138,1681 +1350,2081 @@ load_proc_addresses_custom :: proc(set_proc_address: SetProcAddressType) { set_proc_address(&SubmitDebugUtilsMessageEXT, "vkSubmitDebugUtilsMessageEXT") // Device Procedures - set_proc_address(&AcquireFullScreenExclusiveModeEXT, "vkAcquireFullScreenExclusiveModeEXT") - set_proc_address(&AcquireNextImage2KHR, "vkAcquireNextImage2KHR") - set_proc_address(&AcquireNextImageKHR, "vkAcquireNextImageKHR") - set_proc_address(&AcquirePerformanceConfigurationINTEL, "vkAcquirePerformanceConfigurationINTEL") - set_proc_address(&AcquireProfilingLockKHR, "vkAcquireProfilingLockKHR") - set_proc_address(&AllocateCommandBuffers, "vkAllocateCommandBuffers") - set_proc_address(&AllocateDescriptorSets, "vkAllocateDescriptorSets") - set_proc_address(&AllocateMemory, "vkAllocateMemory") - set_proc_address(&BeginCommandBuffer, "vkBeginCommandBuffer") - set_proc_address(&BindAccelerationStructureMemoryNV, "vkBindAccelerationStructureMemoryNV") - set_proc_address(&BindBufferMemory, "vkBindBufferMemory") - set_proc_address(&BindBufferMemory2, "vkBindBufferMemory2") - set_proc_address(&BindBufferMemory2KHR, "vkBindBufferMemory2KHR") - set_proc_address(&BindImageMemory, "vkBindImageMemory") - set_proc_address(&BindImageMemory2, "vkBindImageMemory2") - set_proc_address(&BindImageMemory2KHR, "vkBindImageMemory2KHR") - set_proc_address(&BuildAccelerationStructuresKHR, "vkBuildAccelerationStructuresKHR") - set_proc_address(&CmdBeginConditionalRenderingEXT, "vkCmdBeginConditionalRenderingEXT") - set_proc_address(&CmdBeginDebugUtilsLabelEXT, "vkCmdBeginDebugUtilsLabelEXT") - set_proc_address(&CmdBeginQuery, "vkCmdBeginQuery") - set_proc_address(&CmdBeginQueryIndexedEXT, "vkCmdBeginQueryIndexedEXT") - set_proc_address(&CmdBeginRenderPass, "vkCmdBeginRenderPass") - set_proc_address(&CmdBeginRenderPass2, "vkCmdBeginRenderPass2") - set_proc_address(&CmdBeginRenderPass2KHR, "vkCmdBeginRenderPass2KHR") - set_proc_address(&CmdBeginRendering, "vkCmdBeginRendering") - set_proc_address(&CmdBeginRenderingKHR, "vkCmdBeginRenderingKHR") - set_proc_address(&CmdBeginTransformFeedbackEXT, "vkCmdBeginTransformFeedbackEXT") - set_proc_address(&CmdBindDescriptorSets, "vkCmdBindDescriptorSets") - set_proc_address(&CmdBindIndexBuffer, "vkCmdBindIndexBuffer") - set_proc_address(&CmdBindInvocationMaskHUAWEI, "vkCmdBindInvocationMaskHUAWEI") - set_proc_address(&CmdBindPipeline, "vkCmdBindPipeline") - set_proc_address(&CmdBindPipelineShaderGroupNV, "vkCmdBindPipelineShaderGroupNV") - set_proc_address(&CmdBindShadingRateImageNV, "vkCmdBindShadingRateImageNV") - set_proc_address(&CmdBindTransformFeedbackBuffersEXT, "vkCmdBindTransformFeedbackBuffersEXT") - set_proc_address(&CmdBindVertexBuffers, "vkCmdBindVertexBuffers") - set_proc_address(&CmdBindVertexBuffers2, "vkCmdBindVertexBuffers2") - set_proc_address(&CmdBindVertexBuffers2EXT, "vkCmdBindVertexBuffers2EXT") - set_proc_address(&CmdBlitImage, "vkCmdBlitImage") - set_proc_address(&CmdBlitImage2, "vkCmdBlitImage2") - set_proc_address(&CmdBlitImage2KHR, "vkCmdBlitImage2KHR") - set_proc_address(&CmdBuildAccelerationStructureNV, "vkCmdBuildAccelerationStructureNV") - set_proc_address(&CmdBuildAccelerationStructuresIndirectKHR, "vkCmdBuildAccelerationStructuresIndirectKHR") - set_proc_address(&CmdBuildAccelerationStructuresKHR, "vkCmdBuildAccelerationStructuresKHR") - set_proc_address(&CmdClearAttachments, "vkCmdClearAttachments") - set_proc_address(&CmdClearColorImage, "vkCmdClearColorImage") - set_proc_address(&CmdClearDepthStencilImage, "vkCmdClearDepthStencilImage") - set_proc_address(&CmdCopyAccelerationStructureKHR, "vkCmdCopyAccelerationStructureKHR") - set_proc_address(&CmdCopyAccelerationStructureNV, "vkCmdCopyAccelerationStructureNV") - set_proc_address(&CmdCopyAccelerationStructureToMemoryKHR, "vkCmdCopyAccelerationStructureToMemoryKHR") - set_proc_address(&CmdCopyBuffer, "vkCmdCopyBuffer") - set_proc_address(&CmdCopyBuffer2, "vkCmdCopyBuffer2") - set_proc_address(&CmdCopyBuffer2KHR, "vkCmdCopyBuffer2KHR") - set_proc_address(&CmdCopyBufferToImage, "vkCmdCopyBufferToImage") - set_proc_address(&CmdCopyBufferToImage2, "vkCmdCopyBufferToImage2") - set_proc_address(&CmdCopyBufferToImage2KHR, "vkCmdCopyBufferToImage2KHR") - set_proc_address(&CmdCopyImage, "vkCmdCopyImage") - set_proc_address(&CmdCopyImage2, "vkCmdCopyImage2") - set_proc_address(&CmdCopyImage2KHR, "vkCmdCopyImage2KHR") - set_proc_address(&CmdCopyImageToBuffer, "vkCmdCopyImageToBuffer") - set_proc_address(&CmdCopyImageToBuffer2, "vkCmdCopyImageToBuffer2") - set_proc_address(&CmdCopyImageToBuffer2KHR, "vkCmdCopyImageToBuffer2KHR") - set_proc_address(&CmdCopyMemoryToAccelerationStructureKHR, "vkCmdCopyMemoryToAccelerationStructureKHR") - set_proc_address(&CmdCopyQueryPoolResults, "vkCmdCopyQueryPoolResults") - set_proc_address(&CmdCuLaunchKernelNVX, "vkCmdCuLaunchKernelNVX") - set_proc_address(&CmdDebugMarkerBeginEXT, "vkCmdDebugMarkerBeginEXT") - set_proc_address(&CmdDebugMarkerEndEXT, "vkCmdDebugMarkerEndEXT") - set_proc_address(&CmdDebugMarkerInsertEXT, "vkCmdDebugMarkerInsertEXT") - set_proc_address(&CmdDispatch, "vkCmdDispatch") - set_proc_address(&CmdDispatchBase, "vkCmdDispatchBase") - set_proc_address(&CmdDispatchBaseKHR, "vkCmdDispatchBaseKHR") - set_proc_address(&CmdDispatchIndirect, "vkCmdDispatchIndirect") - set_proc_address(&CmdDraw, "vkCmdDraw") - set_proc_address(&CmdDrawIndexed, "vkCmdDrawIndexed") - set_proc_address(&CmdDrawIndexedIndirect, "vkCmdDrawIndexedIndirect") - set_proc_address(&CmdDrawIndexedIndirectCount, "vkCmdDrawIndexedIndirectCount") - set_proc_address(&CmdDrawIndexedIndirectCountAMD, "vkCmdDrawIndexedIndirectCountAMD") - set_proc_address(&CmdDrawIndexedIndirectCountKHR, "vkCmdDrawIndexedIndirectCountKHR") - set_proc_address(&CmdDrawIndirect, "vkCmdDrawIndirect") - set_proc_address(&CmdDrawIndirectByteCountEXT, "vkCmdDrawIndirectByteCountEXT") - set_proc_address(&CmdDrawIndirectCount, "vkCmdDrawIndirectCount") - set_proc_address(&CmdDrawIndirectCountAMD, "vkCmdDrawIndirectCountAMD") - set_proc_address(&CmdDrawIndirectCountKHR, "vkCmdDrawIndirectCountKHR") - set_proc_address(&CmdDrawMeshTasksIndirectCountNV, "vkCmdDrawMeshTasksIndirectCountNV") - set_proc_address(&CmdDrawMeshTasksIndirectNV, "vkCmdDrawMeshTasksIndirectNV") - set_proc_address(&CmdDrawMeshTasksNV, "vkCmdDrawMeshTasksNV") - set_proc_address(&CmdDrawMultiEXT, "vkCmdDrawMultiEXT") - set_proc_address(&CmdDrawMultiIndexedEXT, "vkCmdDrawMultiIndexedEXT") - set_proc_address(&CmdEndConditionalRenderingEXT, "vkCmdEndConditionalRenderingEXT") - set_proc_address(&CmdEndDebugUtilsLabelEXT, "vkCmdEndDebugUtilsLabelEXT") - set_proc_address(&CmdEndQuery, "vkCmdEndQuery") - set_proc_address(&CmdEndQueryIndexedEXT, "vkCmdEndQueryIndexedEXT") - set_proc_address(&CmdEndRenderPass, "vkCmdEndRenderPass") - set_proc_address(&CmdEndRenderPass2, "vkCmdEndRenderPass2") - set_proc_address(&CmdEndRenderPass2KHR, "vkCmdEndRenderPass2KHR") - set_proc_address(&CmdEndRendering, "vkCmdEndRendering") - set_proc_address(&CmdEndRenderingKHR, "vkCmdEndRenderingKHR") - set_proc_address(&CmdEndTransformFeedbackEXT, "vkCmdEndTransformFeedbackEXT") - set_proc_address(&CmdExecuteCommands, "vkCmdExecuteCommands") - set_proc_address(&CmdExecuteGeneratedCommandsNV, "vkCmdExecuteGeneratedCommandsNV") - set_proc_address(&CmdFillBuffer, "vkCmdFillBuffer") - set_proc_address(&CmdInsertDebugUtilsLabelEXT, "vkCmdInsertDebugUtilsLabelEXT") - set_proc_address(&CmdNextSubpass, "vkCmdNextSubpass") - set_proc_address(&CmdNextSubpass2, "vkCmdNextSubpass2") - set_proc_address(&CmdNextSubpass2KHR, "vkCmdNextSubpass2KHR") - set_proc_address(&CmdPipelineBarrier, "vkCmdPipelineBarrier") - set_proc_address(&CmdPipelineBarrier2, "vkCmdPipelineBarrier2") - set_proc_address(&CmdPipelineBarrier2KHR, "vkCmdPipelineBarrier2KHR") - set_proc_address(&CmdPreprocessGeneratedCommandsNV, "vkCmdPreprocessGeneratedCommandsNV") - set_proc_address(&CmdPushConstants, "vkCmdPushConstants") - set_proc_address(&CmdPushDescriptorSetKHR, "vkCmdPushDescriptorSetKHR") - set_proc_address(&CmdPushDescriptorSetWithTemplateKHR, "vkCmdPushDescriptorSetWithTemplateKHR") - set_proc_address(&CmdResetEvent, "vkCmdResetEvent") - set_proc_address(&CmdResetEvent2, "vkCmdResetEvent2") - set_proc_address(&CmdResetEvent2KHR, "vkCmdResetEvent2KHR") - set_proc_address(&CmdResetQueryPool, "vkCmdResetQueryPool") - set_proc_address(&CmdResolveImage, "vkCmdResolveImage") - set_proc_address(&CmdResolveImage2, "vkCmdResolveImage2") - set_proc_address(&CmdResolveImage2KHR, "vkCmdResolveImage2KHR") - set_proc_address(&CmdSetBlendConstants, "vkCmdSetBlendConstants") - set_proc_address(&CmdSetCheckpointNV, "vkCmdSetCheckpointNV") - set_proc_address(&CmdSetCoarseSampleOrderNV, "vkCmdSetCoarseSampleOrderNV") - set_proc_address(&CmdSetCullMode, "vkCmdSetCullMode") - set_proc_address(&CmdSetCullModeEXT, "vkCmdSetCullModeEXT") - set_proc_address(&CmdSetDepthBias, "vkCmdSetDepthBias") - set_proc_address(&CmdSetDepthBiasEnable, "vkCmdSetDepthBiasEnable") - set_proc_address(&CmdSetDepthBiasEnableEXT, "vkCmdSetDepthBiasEnableEXT") - set_proc_address(&CmdSetDepthBounds, "vkCmdSetDepthBounds") - set_proc_address(&CmdSetDepthBoundsTestEnable, "vkCmdSetDepthBoundsTestEnable") - set_proc_address(&CmdSetDepthBoundsTestEnableEXT, "vkCmdSetDepthBoundsTestEnableEXT") - set_proc_address(&CmdSetDepthCompareOp, "vkCmdSetDepthCompareOp") - set_proc_address(&CmdSetDepthCompareOpEXT, "vkCmdSetDepthCompareOpEXT") - set_proc_address(&CmdSetDepthTestEnable, "vkCmdSetDepthTestEnable") - set_proc_address(&CmdSetDepthTestEnableEXT, "vkCmdSetDepthTestEnableEXT") - set_proc_address(&CmdSetDepthWriteEnable, "vkCmdSetDepthWriteEnable") - set_proc_address(&CmdSetDepthWriteEnableEXT, "vkCmdSetDepthWriteEnableEXT") - set_proc_address(&CmdSetDeviceMask, "vkCmdSetDeviceMask") - set_proc_address(&CmdSetDeviceMaskKHR, "vkCmdSetDeviceMaskKHR") - set_proc_address(&CmdSetDiscardRectangleEXT, "vkCmdSetDiscardRectangleEXT") - set_proc_address(&CmdSetEvent, "vkCmdSetEvent") - set_proc_address(&CmdSetEvent2, "vkCmdSetEvent2") - set_proc_address(&CmdSetEvent2KHR, "vkCmdSetEvent2KHR") - set_proc_address(&CmdSetExclusiveScissorNV, "vkCmdSetExclusiveScissorNV") - set_proc_address(&CmdSetFragmentShadingRateEnumNV, "vkCmdSetFragmentShadingRateEnumNV") - set_proc_address(&CmdSetFragmentShadingRateKHR, "vkCmdSetFragmentShadingRateKHR") - set_proc_address(&CmdSetFrontFace, "vkCmdSetFrontFace") - set_proc_address(&CmdSetFrontFaceEXT, "vkCmdSetFrontFaceEXT") - set_proc_address(&CmdSetLineStippleEXT, "vkCmdSetLineStippleEXT") - set_proc_address(&CmdSetLineWidth, "vkCmdSetLineWidth") - set_proc_address(&CmdSetLogicOpEXT, "vkCmdSetLogicOpEXT") - set_proc_address(&CmdSetPatchControlPointsEXT, "vkCmdSetPatchControlPointsEXT") - set_proc_address(&CmdSetPerformanceMarkerINTEL, "vkCmdSetPerformanceMarkerINTEL") - set_proc_address(&CmdSetPerformanceOverrideINTEL, "vkCmdSetPerformanceOverrideINTEL") - set_proc_address(&CmdSetPerformanceStreamMarkerINTEL, "vkCmdSetPerformanceStreamMarkerINTEL") - set_proc_address(&CmdSetPrimitiveRestartEnable, "vkCmdSetPrimitiveRestartEnable") - set_proc_address(&CmdSetPrimitiveRestartEnableEXT, "vkCmdSetPrimitiveRestartEnableEXT") - set_proc_address(&CmdSetPrimitiveTopology, "vkCmdSetPrimitiveTopology") - set_proc_address(&CmdSetPrimitiveTopologyEXT, "vkCmdSetPrimitiveTopologyEXT") - set_proc_address(&CmdSetRasterizerDiscardEnable, "vkCmdSetRasterizerDiscardEnable") - set_proc_address(&CmdSetRasterizerDiscardEnableEXT, "vkCmdSetRasterizerDiscardEnableEXT") - set_proc_address(&CmdSetRayTracingPipelineStackSizeKHR, "vkCmdSetRayTracingPipelineStackSizeKHR") - set_proc_address(&CmdSetSampleLocationsEXT, "vkCmdSetSampleLocationsEXT") - set_proc_address(&CmdSetScissor, "vkCmdSetScissor") - set_proc_address(&CmdSetScissorWithCount, "vkCmdSetScissorWithCount") - set_proc_address(&CmdSetScissorWithCountEXT, "vkCmdSetScissorWithCountEXT") - set_proc_address(&CmdSetStencilCompareMask, "vkCmdSetStencilCompareMask") - set_proc_address(&CmdSetStencilOp, "vkCmdSetStencilOp") - set_proc_address(&CmdSetStencilOpEXT, "vkCmdSetStencilOpEXT") - set_proc_address(&CmdSetStencilReference, "vkCmdSetStencilReference") - set_proc_address(&CmdSetStencilTestEnable, "vkCmdSetStencilTestEnable") - set_proc_address(&CmdSetStencilTestEnableEXT, "vkCmdSetStencilTestEnableEXT") - set_proc_address(&CmdSetStencilWriteMask, "vkCmdSetStencilWriteMask") - set_proc_address(&CmdSetVertexInputEXT, "vkCmdSetVertexInputEXT") - set_proc_address(&CmdSetViewport, "vkCmdSetViewport") - set_proc_address(&CmdSetViewportShadingRatePaletteNV, "vkCmdSetViewportShadingRatePaletteNV") - set_proc_address(&CmdSetViewportWScalingNV, "vkCmdSetViewportWScalingNV") - set_proc_address(&CmdSetViewportWithCount, "vkCmdSetViewportWithCount") - set_proc_address(&CmdSetViewportWithCountEXT, "vkCmdSetViewportWithCountEXT") - set_proc_address(&CmdSubpassShadingHUAWEI, "vkCmdSubpassShadingHUAWEI") - set_proc_address(&CmdTraceRaysIndirectKHR, "vkCmdTraceRaysIndirectKHR") - set_proc_address(&CmdTraceRaysKHR, "vkCmdTraceRaysKHR") - set_proc_address(&CmdTraceRaysNV, "vkCmdTraceRaysNV") - set_proc_address(&CmdUpdateBuffer, "vkCmdUpdateBuffer") - set_proc_address(&CmdWaitEvents, "vkCmdWaitEvents") - set_proc_address(&CmdWaitEvents2, "vkCmdWaitEvents2") - set_proc_address(&CmdWaitEvents2KHR, "vkCmdWaitEvents2KHR") - set_proc_address(&CmdWriteAccelerationStructuresPropertiesKHR, "vkCmdWriteAccelerationStructuresPropertiesKHR") - set_proc_address(&CmdWriteAccelerationStructuresPropertiesNV, "vkCmdWriteAccelerationStructuresPropertiesNV") - set_proc_address(&CmdWriteBufferMarker2AMD, "vkCmdWriteBufferMarker2AMD") - set_proc_address(&CmdWriteBufferMarkerAMD, "vkCmdWriteBufferMarkerAMD") - set_proc_address(&CmdWriteTimestamp, "vkCmdWriteTimestamp") - set_proc_address(&CmdWriteTimestamp2, "vkCmdWriteTimestamp2") - set_proc_address(&CmdWriteTimestamp2KHR, "vkCmdWriteTimestamp2KHR") - set_proc_address(&CompileDeferredNV, "vkCompileDeferredNV") - set_proc_address(&CopyAccelerationStructureKHR, "vkCopyAccelerationStructureKHR") - set_proc_address(&CopyAccelerationStructureToMemoryKHR, "vkCopyAccelerationStructureToMemoryKHR") - set_proc_address(&CopyMemoryToAccelerationStructureKHR, "vkCopyMemoryToAccelerationStructureKHR") - set_proc_address(&CreateAccelerationStructureKHR, "vkCreateAccelerationStructureKHR") - set_proc_address(&CreateAccelerationStructureNV, "vkCreateAccelerationStructureNV") - set_proc_address(&CreateBuffer, "vkCreateBuffer") - set_proc_address(&CreateBufferView, "vkCreateBufferView") - set_proc_address(&CreateCommandPool, "vkCreateCommandPool") - set_proc_address(&CreateComputePipelines, "vkCreateComputePipelines") - set_proc_address(&CreateCuFunctionNVX, "vkCreateCuFunctionNVX") - set_proc_address(&CreateCuModuleNVX, "vkCreateCuModuleNVX") - set_proc_address(&CreateDeferredOperationKHR, "vkCreateDeferredOperationKHR") - set_proc_address(&CreateDescriptorPool, "vkCreateDescriptorPool") - set_proc_address(&CreateDescriptorSetLayout, "vkCreateDescriptorSetLayout") - set_proc_address(&CreateDescriptorUpdateTemplate, "vkCreateDescriptorUpdateTemplate") - set_proc_address(&CreateDescriptorUpdateTemplateKHR, "vkCreateDescriptorUpdateTemplateKHR") - set_proc_address(&CreateEvent, "vkCreateEvent") - set_proc_address(&CreateFence, "vkCreateFence") - set_proc_address(&CreateFramebuffer, "vkCreateFramebuffer") - set_proc_address(&CreateGraphicsPipelines, "vkCreateGraphicsPipelines") - set_proc_address(&CreateImage, "vkCreateImage") - set_proc_address(&CreateImageView, "vkCreateImageView") - set_proc_address(&CreateIndirectCommandsLayoutNV, "vkCreateIndirectCommandsLayoutNV") - set_proc_address(&CreatePipelineCache, "vkCreatePipelineCache") - set_proc_address(&CreatePipelineLayout, "vkCreatePipelineLayout") - set_proc_address(&CreatePrivateDataSlot, "vkCreatePrivateDataSlot") - set_proc_address(&CreatePrivateDataSlotEXT, "vkCreatePrivateDataSlotEXT") - set_proc_address(&CreateQueryPool, "vkCreateQueryPool") - set_proc_address(&CreateRayTracingPipelinesKHR, "vkCreateRayTracingPipelinesKHR") - set_proc_address(&CreateRayTracingPipelinesNV, "vkCreateRayTracingPipelinesNV") - set_proc_address(&CreateRenderPass, "vkCreateRenderPass") - set_proc_address(&CreateRenderPass2, "vkCreateRenderPass2") - set_proc_address(&CreateRenderPass2KHR, "vkCreateRenderPass2KHR") - set_proc_address(&CreateSampler, "vkCreateSampler") - set_proc_address(&CreateSamplerYcbcrConversion, "vkCreateSamplerYcbcrConversion") - set_proc_address(&CreateSamplerYcbcrConversionKHR, "vkCreateSamplerYcbcrConversionKHR") - set_proc_address(&CreateSemaphore, "vkCreateSemaphore") - set_proc_address(&CreateShaderModule, "vkCreateShaderModule") - set_proc_address(&CreateSharedSwapchainsKHR, "vkCreateSharedSwapchainsKHR") - set_proc_address(&CreateSwapchainKHR, "vkCreateSwapchainKHR") - set_proc_address(&CreateValidationCacheEXT, "vkCreateValidationCacheEXT") - set_proc_address(&DebugMarkerSetObjectNameEXT, "vkDebugMarkerSetObjectNameEXT") - set_proc_address(&DebugMarkerSetObjectTagEXT, "vkDebugMarkerSetObjectTagEXT") - set_proc_address(&DeferredOperationJoinKHR, "vkDeferredOperationJoinKHR") - set_proc_address(&DestroyAccelerationStructureKHR, "vkDestroyAccelerationStructureKHR") - set_proc_address(&DestroyAccelerationStructureNV, "vkDestroyAccelerationStructureNV") - set_proc_address(&DestroyBuffer, "vkDestroyBuffer") - set_proc_address(&DestroyBufferView, "vkDestroyBufferView") - set_proc_address(&DestroyCommandPool, "vkDestroyCommandPool") - set_proc_address(&DestroyCuFunctionNVX, "vkDestroyCuFunctionNVX") - set_proc_address(&DestroyCuModuleNVX, "vkDestroyCuModuleNVX") - set_proc_address(&DestroyDeferredOperationKHR, "vkDestroyDeferredOperationKHR") - set_proc_address(&DestroyDescriptorPool, "vkDestroyDescriptorPool") - set_proc_address(&DestroyDescriptorSetLayout, "vkDestroyDescriptorSetLayout") - set_proc_address(&DestroyDescriptorUpdateTemplate, "vkDestroyDescriptorUpdateTemplate") - set_proc_address(&DestroyDescriptorUpdateTemplateKHR, "vkDestroyDescriptorUpdateTemplateKHR") - set_proc_address(&DestroyDevice, "vkDestroyDevice") - set_proc_address(&DestroyEvent, "vkDestroyEvent") - set_proc_address(&DestroyFence, "vkDestroyFence") - set_proc_address(&DestroyFramebuffer, "vkDestroyFramebuffer") - set_proc_address(&DestroyImage, "vkDestroyImage") - set_proc_address(&DestroyImageView, "vkDestroyImageView") - set_proc_address(&DestroyIndirectCommandsLayoutNV, "vkDestroyIndirectCommandsLayoutNV") - set_proc_address(&DestroyPipeline, "vkDestroyPipeline") - set_proc_address(&DestroyPipelineCache, "vkDestroyPipelineCache") - set_proc_address(&DestroyPipelineLayout, "vkDestroyPipelineLayout") - set_proc_address(&DestroyPrivateDataSlot, "vkDestroyPrivateDataSlot") - set_proc_address(&DestroyPrivateDataSlotEXT, "vkDestroyPrivateDataSlotEXT") - set_proc_address(&DestroyQueryPool, "vkDestroyQueryPool") - set_proc_address(&DestroyRenderPass, "vkDestroyRenderPass") - set_proc_address(&DestroySampler, "vkDestroySampler") - set_proc_address(&DestroySamplerYcbcrConversion, "vkDestroySamplerYcbcrConversion") - set_proc_address(&DestroySamplerYcbcrConversionKHR, "vkDestroySamplerYcbcrConversionKHR") - set_proc_address(&DestroySemaphore, "vkDestroySemaphore") - set_proc_address(&DestroyShaderModule, "vkDestroyShaderModule") - set_proc_address(&DestroySwapchainKHR, "vkDestroySwapchainKHR") - set_proc_address(&DestroyValidationCacheEXT, "vkDestroyValidationCacheEXT") - set_proc_address(&DeviceWaitIdle, "vkDeviceWaitIdle") - set_proc_address(&DisplayPowerControlEXT, "vkDisplayPowerControlEXT") - set_proc_address(&EndCommandBuffer, "vkEndCommandBuffer") - set_proc_address(&FlushMappedMemoryRanges, "vkFlushMappedMemoryRanges") - set_proc_address(&FreeCommandBuffers, "vkFreeCommandBuffers") - set_proc_address(&FreeDescriptorSets, "vkFreeDescriptorSets") - set_proc_address(&FreeMemory, "vkFreeMemory") - set_proc_address(&GetAccelerationStructureBuildSizesKHR, "vkGetAccelerationStructureBuildSizesKHR") - set_proc_address(&GetAccelerationStructureDeviceAddressKHR, "vkGetAccelerationStructureDeviceAddressKHR") - set_proc_address(&GetAccelerationStructureHandleNV, "vkGetAccelerationStructureHandleNV") - set_proc_address(&GetAccelerationStructureMemoryRequirementsNV, "vkGetAccelerationStructureMemoryRequirementsNV") - set_proc_address(&GetBufferDeviceAddress, "vkGetBufferDeviceAddress") - set_proc_address(&GetBufferDeviceAddressEXT, "vkGetBufferDeviceAddressEXT") - set_proc_address(&GetBufferDeviceAddressKHR, "vkGetBufferDeviceAddressKHR") - set_proc_address(&GetBufferMemoryRequirements, "vkGetBufferMemoryRequirements") - set_proc_address(&GetBufferMemoryRequirements2, "vkGetBufferMemoryRequirements2") - set_proc_address(&GetBufferMemoryRequirements2KHR, "vkGetBufferMemoryRequirements2KHR") - set_proc_address(&GetBufferOpaqueCaptureAddress, "vkGetBufferOpaqueCaptureAddress") - set_proc_address(&GetBufferOpaqueCaptureAddressKHR, "vkGetBufferOpaqueCaptureAddressKHR") - set_proc_address(&GetCalibratedTimestampsEXT, "vkGetCalibratedTimestampsEXT") - set_proc_address(&GetDeferredOperationMaxConcurrencyKHR, "vkGetDeferredOperationMaxConcurrencyKHR") - set_proc_address(&GetDeferredOperationResultKHR, "vkGetDeferredOperationResultKHR") - set_proc_address(&GetDescriptorSetHostMappingVALVE, "vkGetDescriptorSetHostMappingVALVE") - set_proc_address(&GetDescriptorSetLayoutHostMappingInfoVALVE, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") - set_proc_address(&GetDescriptorSetLayoutSupport, "vkGetDescriptorSetLayoutSupport") - set_proc_address(&GetDescriptorSetLayoutSupportKHR, "vkGetDescriptorSetLayoutSupportKHR") - set_proc_address(&GetDeviceAccelerationStructureCompatibilityKHR, "vkGetDeviceAccelerationStructureCompatibilityKHR") - set_proc_address(&GetDeviceBufferMemoryRequirements, "vkGetDeviceBufferMemoryRequirements") - set_proc_address(&GetDeviceBufferMemoryRequirementsKHR, "vkGetDeviceBufferMemoryRequirementsKHR") - set_proc_address(&GetDeviceGroupPeerMemoryFeatures, "vkGetDeviceGroupPeerMemoryFeatures") - set_proc_address(&GetDeviceGroupPeerMemoryFeaturesKHR, "vkGetDeviceGroupPeerMemoryFeaturesKHR") - set_proc_address(&GetDeviceGroupPresentCapabilitiesKHR, "vkGetDeviceGroupPresentCapabilitiesKHR") - set_proc_address(&GetDeviceGroupSurfacePresentModes2EXT, "vkGetDeviceGroupSurfacePresentModes2EXT") - set_proc_address(&GetDeviceGroupSurfacePresentModesKHR, "vkGetDeviceGroupSurfacePresentModesKHR") - set_proc_address(&GetDeviceImageMemoryRequirements, "vkGetDeviceImageMemoryRequirements") - set_proc_address(&GetDeviceImageMemoryRequirementsKHR, "vkGetDeviceImageMemoryRequirementsKHR") - set_proc_address(&GetDeviceImageSparseMemoryRequirements, "vkGetDeviceImageSparseMemoryRequirements") - set_proc_address(&GetDeviceImageSparseMemoryRequirementsKHR, "vkGetDeviceImageSparseMemoryRequirementsKHR") - set_proc_address(&GetDeviceMemoryCommitment, "vkGetDeviceMemoryCommitment") - set_proc_address(&GetDeviceMemoryOpaqueCaptureAddress, "vkGetDeviceMemoryOpaqueCaptureAddress") - set_proc_address(&GetDeviceMemoryOpaqueCaptureAddressKHR, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") - set_proc_address(&GetDeviceProcAddr, "vkGetDeviceProcAddr") - set_proc_address(&GetDeviceQueue, "vkGetDeviceQueue") - set_proc_address(&GetDeviceQueue2, "vkGetDeviceQueue2") - set_proc_address(&GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") - set_proc_address(&GetEventStatus, "vkGetEventStatus") - set_proc_address(&GetFenceFdKHR, "vkGetFenceFdKHR") - set_proc_address(&GetFenceStatus, "vkGetFenceStatus") - set_proc_address(&GetFenceWin32HandleKHR, "vkGetFenceWin32HandleKHR") - set_proc_address(&GetGeneratedCommandsMemoryRequirementsNV, "vkGetGeneratedCommandsMemoryRequirementsNV") - set_proc_address(&GetImageDrmFormatModifierPropertiesEXT, "vkGetImageDrmFormatModifierPropertiesEXT") - set_proc_address(&GetImageMemoryRequirements, "vkGetImageMemoryRequirements") - set_proc_address(&GetImageMemoryRequirements2, "vkGetImageMemoryRequirements2") - set_proc_address(&GetImageMemoryRequirements2KHR, "vkGetImageMemoryRequirements2KHR") - set_proc_address(&GetImageSparseMemoryRequirements, "vkGetImageSparseMemoryRequirements") - set_proc_address(&GetImageSparseMemoryRequirements2, "vkGetImageSparseMemoryRequirements2") - set_proc_address(&GetImageSparseMemoryRequirements2KHR, "vkGetImageSparseMemoryRequirements2KHR") - set_proc_address(&GetImageSubresourceLayout, "vkGetImageSubresourceLayout") - set_proc_address(&GetImageViewAddressNVX, "vkGetImageViewAddressNVX") - set_proc_address(&GetImageViewHandleNVX, "vkGetImageViewHandleNVX") - set_proc_address(&GetMemoryFdKHR, "vkGetMemoryFdKHR") - set_proc_address(&GetMemoryFdPropertiesKHR, "vkGetMemoryFdPropertiesKHR") - set_proc_address(&GetMemoryHostPointerPropertiesEXT, "vkGetMemoryHostPointerPropertiesEXT") - set_proc_address(&GetMemoryRemoteAddressNV, "vkGetMemoryRemoteAddressNV") - set_proc_address(&GetMemoryWin32HandleKHR, "vkGetMemoryWin32HandleKHR") - set_proc_address(&GetMemoryWin32HandleNV, "vkGetMemoryWin32HandleNV") - set_proc_address(&GetMemoryWin32HandlePropertiesKHR, "vkGetMemoryWin32HandlePropertiesKHR") - set_proc_address(&GetPastPresentationTimingGOOGLE, "vkGetPastPresentationTimingGOOGLE") - set_proc_address(&GetPerformanceParameterINTEL, "vkGetPerformanceParameterINTEL") - set_proc_address(&GetPipelineCacheData, "vkGetPipelineCacheData") - set_proc_address(&GetPipelineExecutableInternalRepresentationsKHR, "vkGetPipelineExecutableInternalRepresentationsKHR") - set_proc_address(&GetPipelineExecutablePropertiesKHR, "vkGetPipelineExecutablePropertiesKHR") - set_proc_address(&GetPipelineExecutableStatisticsKHR, "vkGetPipelineExecutableStatisticsKHR") - set_proc_address(&GetPrivateData, "vkGetPrivateData") - set_proc_address(&GetPrivateDataEXT, "vkGetPrivateDataEXT") - set_proc_address(&GetQueryPoolResults, "vkGetQueryPoolResults") - set_proc_address(&GetQueueCheckpointData2NV, "vkGetQueueCheckpointData2NV") - set_proc_address(&GetQueueCheckpointDataNV, "vkGetQueueCheckpointDataNV") - set_proc_address(&GetRayTracingCaptureReplayShaderGroupHandlesKHR, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") - set_proc_address(&GetRayTracingShaderGroupHandlesKHR, "vkGetRayTracingShaderGroupHandlesKHR") - set_proc_address(&GetRayTracingShaderGroupHandlesNV, "vkGetRayTracingShaderGroupHandlesNV") - set_proc_address(&GetRayTracingShaderGroupStackSizeKHR, "vkGetRayTracingShaderGroupStackSizeKHR") - set_proc_address(&GetRefreshCycleDurationGOOGLE, "vkGetRefreshCycleDurationGOOGLE") - set_proc_address(&GetRenderAreaGranularity, "vkGetRenderAreaGranularity") - set_proc_address(&GetSemaphoreCounterValue, "vkGetSemaphoreCounterValue") - set_proc_address(&GetSemaphoreCounterValueKHR, "vkGetSemaphoreCounterValueKHR") - set_proc_address(&GetSemaphoreFdKHR, "vkGetSemaphoreFdKHR") - set_proc_address(&GetSemaphoreWin32HandleKHR, "vkGetSemaphoreWin32HandleKHR") - set_proc_address(&GetShaderInfoAMD, "vkGetShaderInfoAMD") - set_proc_address(&GetSwapchainCounterEXT, "vkGetSwapchainCounterEXT") - set_proc_address(&GetSwapchainImagesKHR, "vkGetSwapchainImagesKHR") - set_proc_address(&GetSwapchainStatusKHR, "vkGetSwapchainStatusKHR") - set_proc_address(&GetValidationCacheDataEXT, "vkGetValidationCacheDataEXT") - set_proc_address(&ImportFenceFdKHR, "vkImportFenceFdKHR") - set_proc_address(&ImportFenceWin32HandleKHR, "vkImportFenceWin32HandleKHR") - set_proc_address(&ImportSemaphoreFdKHR, "vkImportSemaphoreFdKHR") - set_proc_address(&ImportSemaphoreWin32HandleKHR, "vkImportSemaphoreWin32HandleKHR") - set_proc_address(&InitializePerformanceApiINTEL, "vkInitializePerformanceApiINTEL") - set_proc_address(&InvalidateMappedMemoryRanges, "vkInvalidateMappedMemoryRanges") - set_proc_address(&MapMemory, "vkMapMemory") - set_proc_address(&MergePipelineCaches, "vkMergePipelineCaches") - set_proc_address(&MergeValidationCachesEXT, "vkMergeValidationCachesEXT") - set_proc_address(&QueueBeginDebugUtilsLabelEXT, "vkQueueBeginDebugUtilsLabelEXT") - set_proc_address(&QueueBindSparse, "vkQueueBindSparse") - set_proc_address(&QueueEndDebugUtilsLabelEXT, "vkQueueEndDebugUtilsLabelEXT") - set_proc_address(&QueueInsertDebugUtilsLabelEXT, "vkQueueInsertDebugUtilsLabelEXT") - set_proc_address(&QueuePresentKHR, "vkQueuePresentKHR") - set_proc_address(&QueueSetPerformanceConfigurationINTEL, "vkQueueSetPerformanceConfigurationINTEL") - set_proc_address(&QueueSubmit, "vkQueueSubmit") - set_proc_address(&QueueSubmit2, "vkQueueSubmit2") - set_proc_address(&QueueSubmit2KHR, "vkQueueSubmit2KHR") - set_proc_address(&QueueWaitIdle, "vkQueueWaitIdle") - set_proc_address(&RegisterDeviceEventEXT, "vkRegisterDeviceEventEXT") - set_proc_address(&RegisterDisplayEventEXT, "vkRegisterDisplayEventEXT") - set_proc_address(&ReleaseFullScreenExclusiveModeEXT, "vkReleaseFullScreenExclusiveModeEXT") - set_proc_address(&ReleasePerformanceConfigurationINTEL, "vkReleasePerformanceConfigurationINTEL") - set_proc_address(&ReleaseProfilingLockKHR, "vkReleaseProfilingLockKHR") - set_proc_address(&ResetCommandBuffer, "vkResetCommandBuffer") - set_proc_address(&ResetCommandPool, "vkResetCommandPool") - set_proc_address(&ResetDescriptorPool, "vkResetDescriptorPool") - set_proc_address(&ResetEvent, "vkResetEvent") - set_proc_address(&ResetFences, "vkResetFences") - set_proc_address(&ResetQueryPool, "vkResetQueryPool") - set_proc_address(&ResetQueryPoolEXT, "vkResetQueryPoolEXT") - set_proc_address(&SetDebugUtilsObjectNameEXT, "vkSetDebugUtilsObjectNameEXT") - set_proc_address(&SetDebugUtilsObjectTagEXT, "vkSetDebugUtilsObjectTagEXT") - set_proc_address(&SetDeviceMemoryPriorityEXT, "vkSetDeviceMemoryPriorityEXT") - set_proc_address(&SetEvent, "vkSetEvent") - set_proc_address(&SetHdrMetadataEXT, "vkSetHdrMetadataEXT") - set_proc_address(&SetLocalDimmingAMD, "vkSetLocalDimmingAMD") - set_proc_address(&SetPrivateData, "vkSetPrivateData") - set_proc_address(&SetPrivateDataEXT, "vkSetPrivateDataEXT") - set_proc_address(&SignalSemaphore, "vkSignalSemaphore") - set_proc_address(&SignalSemaphoreKHR, "vkSignalSemaphoreKHR") - set_proc_address(&TrimCommandPool, "vkTrimCommandPool") - set_proc_address(&TrimCommandPoolKHR, "vkTrimCommandPoolKHR") - set_proc_address(&UninitializePerformanceApiINTEL, "vkUninitializePerformanceApiINTEL") - set_proc_address(&UnmapMemory, "vkUnmapMemory") - set_proc_address(&UpdateDescriptorSetWithTemplate, "vkUpdateDescriptorSetWithTemplate") - set_proc_address(&UpdateDescriptorSetWithTemplateKHR, "vkUpdateDescriptorSetWithTemplateKHR") - set_proc_address(&UpdateDescriptorSets, "vkUpdateDescriptorSets") - set_proc_address(&WaitForFences, "vkWaitForFences") - set_proc_address(&WaitForPresentKHR, "vkWaitForPresentKHR") - set_proc_address(&WaitSemaphores, "vkWaitSemaphores") - set_proc_address(&WaitSemaphoresKHR, "vkWaitSemaphoresKHR") - set_proc_address(&WriteAccelerationStructuresPropertiesKHR, "vkWriteAccelerationStructuresPropertiesKHR") + set_proc_address(&AcquireFullScreenExclusiveModeEXT, "vkAcquireFullScreenExclusiveModeEXT") + set_proc_address(&AcquireNextImage2KHR, "vkAcquireNextImage2KHR") + set_proc_address(&AcquireNextImageKHR, "vkAcquireNextImageKHR") + set_proc_address(&AcquirePerformanceConfigurationINTEL, "vkAcquirePerformanceConfigurationINTEL") + set_proc_address(&AcquireProfilingLockKHR, "vkAcquireProfilingLockKHR") + set_proc_address(&AllocateCommandBuffers, "vkAllocateCommandBuffers") + set_proc_address(&AllocateDescriptorSets, "vkAllocateDescriptorSets") + set_proc_address(&AllocateMemory, "vkAllocateMemory") + set_proc_address(&BeginCommandBuffer, "vkBeginCommandBuffer") + set_proc_address(&BindAccelerationStructureMemoryNV, "vkBindAccelerationStructureMemoryNV") + set_proc_address(&BindBufferMemory, "vkBindBufferMemory") + set_proc_address(&BindBufferMemory2, "vkBindBufferMemory2") + set_proc_address(&BindBufferMemory2KHR, "vkBindBufferMemory2KHR") + set_proc_address(&BindImageMemory, "vkBindImageMemory") + set_proc_address(&BindImageMemory2, "vkBindImageMemory2") + set_proc_address(&BindImageMemory2KHR, "vkBindImageMemory2KHR") + set_proc_address(&BindOpticalFlowSessionImageNV, "vkBindOpticalFlowSessionImageNV") + set_proc_address(&BindVideoSessionMemoryKHR, "vkBindVideoSessionMemoryKHR") + set_proc_address(&BuildAccelerationStructuresKHR, "vkBuildAccelerationStructuresKHR") + set_proc_address(&BuildMicromapsEXT, "vkBuildMicromapsEXT") + set_proc_address(&CmdBeginConditionalRenderingEXT, "vkCmdBeginConditionalRenderingEXT") + set_proc_address(&CmdBeginDebugUtilsLabelEXT, "vkCmdBeginDebugUtilsLabelEXT") + set_proc_address(&CmdBeginQuery, "vkCmdBeginQuery") + set_proc_address(&CmdBeginQueryIndexedEXT, "vkCmdBeginQueryIndexedEXT") + set_proc_address(&CmdBeginRenderPass, "vkCmdBeginRenderPass") + set_proc_address(&CmdBeginRenderPass2, "vkCmdBeginRenderPass2") + set_proc_address(&CmdBeginRenderPass2KHR, "vkCmdBeginRenderPass2KHR") + set_proc_address(&CmdBeginRendering, "vkCmdBeginRendering") + set_proc_address(&CmdBeginRenderingKHR, "vkCmdBeginRenderingKHR") + set_proc_address(&CmdBeginTransformFeedbackEXT, "vkCmdBeginTransformFeedbackEXT") + set_proc_address(&CmdBeginVideoCodingKHR, "vkCmdBeginVideoCodingKHR") + set_proc_address(&CmdBindDescriptorBufferEmbeddedSamplersEXT, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") + set_proc_address(&CmdBindDescriptorBuffersEXT, "vkCmdBindDescriptorBuffersEXT") + set_proc_address(&CmdBindDescriptorSets, "vkCmdBindDescriptorSets") + set_proc_address(&CmdBindIndexBuffer, "vkCmdBindIndexBuffer") + set_proc_address(&CmdBindInvocationMaskHUAWEI, "vkCmdBindInvocationMaskHUAWEI") + set_proc_address(&CmdBindPipeline, "vkCmdBindPipeline") + set_proc_address(&CmdBindPipelineShaderGroupNV, "vkCmdBindPipelineShaderGroupNV") + set_proc_address(&CmdBindShadersEXT, "vkCmdBindShadersEXT") + set_proc_address(&CmdBindShadingRateImageNV, "vkCmdBindShadingRateImageNV") + set_proc_address(&CmdBindTransformFeedbackBuffersEXT, "vkCmdBindTransformFeedbackBuffersEXT") + set_proc_address(&CmdBindVertexBuffers, "vkCmdBindVertexBuffers") + set_proc_address(&CmdBindVertexBuffers2, "vkCmdBindVertexBuffers2") + set_proc_address(&CmdBindVertexBuffers2EXT, "vkCmdBindVertexBuffers2EXT") + set_proc_address(&CmdBlitImage, "vkCmdBlitImage") + set_proc_address(&CmdBlitImage2, "vkCmdBlitImage2") + set_proc_address(&CmdBlitImage2KHR, "vkCmdBlitImage2KHR") + set_proc_address(&CmdBuildAccelerationStructureNV, "vkCmdBuildAccelerationStructureNV") + set_proc_address(&CmdBuildAccelerationStructuresIndirectKHR, "vkCmdBuildAccelerationStructuresIndirectKHR") + set_proc_address(&CmdBuildAccelerationStructuresKHR, "vkCmdBuildAccelerationStructuresKHR") + set_proc_address(&CmdBuildMicromapsEXT, "vkCmdBuildMicromapsEXT") + set_proc_address(&CmdClearAttachments, "vkCmdClearAttachments") + set_proc_address(&CmdClearColorImage, "vkCmdClearColorImage") + set_proc_address(&CmdClearDepthStencilImage, "vkCmdClearDepthStencilImage") + set_proc_address(&CmdControlVideoCodingKHR, "vkCmdControlVideoCodingKHR") + set_proc_address(&CmdCopyAccelerationStructureKHR, "vkCmdCopyAccelerationStructureKHR") + set_proc_address(&CmdCopyAccelerationStructureNV, "vkCmdCopyAccelerationStructureNV") + set_proc_address(&CmdCopyAccelerationStructureToMemoryKHR, "vkCmdCopyAccelerationStructureToMemoryKHR") + set_proc_address(&CmdCopyBuffer, "vkCmdCopyBuffer") + set_proc_address(&CmdCopyBuffer2, "vkCmdCopyBuffer2") + set_proc_address(&CmdCopyBuffer2KHR, "vkCmdCopyBuffer2KHR") + set_proc_address(&CmdCopyBufferToImage, "vkCmdCopyBufferToImage") + set_proc_address(&CmdCopyBufferToImage2, "vkCmdCopyBufferToImage2") + set_proc_address(&CmdCopyBufferToImage2KHR, "vkCmdCopyBufferToImage2KHR") + set_proc_address(&CmdCopyImage, "vkCmdCopyImage") + set_proc_address(&CmdCopyImage2, "vkCmdCopyImage2") + set_proc_address(&CmdCopyImage2KHR, "vkCmdCopyImage2KHR") + set_proc_address(&CmdCopyImageToBuffer, "vkCmdCopyImageToBuffer") + set_proc_address(&CmdCopyImageToBuffer2, "vkCmdCopyImageToBuffer2") + set_proc_address(&CmdCopyImageToBuffer2KHR, "vkCmdCopyImageToBuffer2KHR") + set_proc_address(&CmdCopyMemoryIndirectNV, "vkCmdCopyMemoryIndirectNV") + set_proc_address(&CmdCopyMemoryToAccelerationStructureKHR, "vkCmdCopyMemoryToAccelerationStructureKHR") + set_proc_address(&CmdCopyMemoryToImageIndirectNV, "vkCmdCopyMemoryToImageIndirectNV") + set_proc_address(&CmdCopyMemoryToMicromapEXT, "vkCmdCopyMemoryToMicromapEXT") + set_proc_address(&CmdCopyMicromapEXT, "vkCmdCopyMicromapEXT") + set_proc_address(&CmdCopyMicromapToMemoryEXT, "vkCmdCopyMicromapToMemoryEXT") + set_proc_address(&CmdCopyQueryPoolResults, "vkCmdCopyQueryPoolResults") + set_proc_address(&CmdCuLaunchKernelNVX, "vkCmdCuLaunchKernelNVX") + set_proc_address(&CmdDebugMarkerBeginEXT, "vkCmdDebugMarkerBeginEXT") + set_proc_address(&CmdDebugMarkerEndEXT, "vkCmdDebugMarkerEndEXT") + set_proc_address(&CmdDebugMarkerInsertEXT, "vkCmdDebugMarkerInsertEXT") + set_proc_address(&CmdDecodeVideoKHR, "vkCmdDecodeVideoKHR") + set_proc_address(&CmdDecompressMemoryIndirectCountNV, "vkCmdDecompressMemoryIndirectCountNV") + set_proc_address(&CmdDecompressMemoryNV, "vkCmdDecompressMemoryNV") + set_proc_address(&CmdDispatch, "vkCmdDispatch") + set_proc_address(&CmdDispatchBase, "vkCmdDispatchBase") + set_proc_address(&CmdDispatchBaseKHR, "vkCmdDispatchBaseKHR") + set_proc_address(&CmdDispatchIndirect, "vkCmdDispatchIndirect") + set_proc_address(&CmdDraw, "vkCmdDraw") + set_proc_address(&CmdDrawClusterHUAWEI, "vkCmdDrawClusterHUAWEI") + set_proc_address(&CmdDrawClusterIndirectHUAWEI, "vkCmdDrawClusterIndirectHUAWEI") + set_proc_address(&CmdDrawIndexed, "vkCmdDrawIndexed") + set_proc_address(&CmdDrawIndexedIndirect, "vkCmdDrawIndexedIndirect") + set_proc_address(&CmdDrawIndexedIndirectCount, "vkCmdDrawIndexedIndirectCount") + set_proc_address(&CmdDrawIndexedIndirectCountAMD, "vkCmdDrawIndexedIndirectCountAMD") + set_proc_address(&CmdDrawIndexedIndirectCountKHR, "vkCmdDrawIndexedIndirectCountKHR") + set_proc_address(&CmdDrawIndirect, "vkCmdDrawIndirect") + set_proc_address(&CmdDrawIndirectByteCountEXT, "vkCmdDrawIndirectByteCountEXT") + set_proc_address(&CmdDrawIndirectCount, "vkCmdDrawIndirectCount") + set_proc_address(&CmdDrawIndirectCountAMD, "vkCmdDrawIndirectCountAMD") + set_proc_address(&CmdDrawIndirectCountKHR, "vkCmdDrawIndirectCountKHR") + set_proc_address(&CmdDrawMeshTasksEXT, "vkCmdDrawMeshTasksEXT") + set_proc_address(&CmdDrawMeshTasksIndirectCountEXT, "vkCmdDrawMeshTasksIndirectCountEXT") + set_proc_address(&CmdDrawMeshTasksIndirectCountNV, "vkCmdDrawMeshTasksIndirectCountNV") + set_proc_address(&CmdDrawMeshTasksIndirectEXT, "vkCmdDrawMeshTasksIndirectEXT") + set_proc_address(&CmdDrawMeshTasksIndirectNV, "vkCmdDrawMeshTasksIndirectNV") + set_proc_address(&CmdDrawMeshTasksNV, "vkCmdDrawMeshTasksNV") + set_proc_address(&CmdDrawMultiEXT, "vkCmdDrawMultiEXT") + set_proc_address(&CmdDrawMultiIndexedEXT, "vkCmdDrawMultiIndexedEXT") + set_proc_address(&CmdEndConditionalRenderingEXT, "vkCmdEndConditionalRenderingEXT") + set_proc_address(&CmdEndDebugUtilsLabelEXT, "vkCmdEndDebugUtilsLabelEXT") + set_proc_address(&CmdEndQuery, "vkCmdEndQuery") + set_proc_address(&CmdEndQueryIndexedEXT, "vkCmdEndQueryIndexedEXT") + set_proc_address(&CmdEndRenderPass, "vkCmdEndRenderPass") + set_proc_address(&CmdEndRenderPass2, "vkCmdEndRenderPass2") + set_proc_address(&CmdEndRenderPass2KHR, "vkCmdEndRenderPass2KHR") + set_proc_address(&CmdEndRendering, "vkCmdEndRendering") + set_proc_address(&CmdEndRenderingKHR, "vkCmdEndRenderingKHR") + set_proc_address(&CmdEndTransformFeedbackEXT, "vkCmdEndTransformFeedbackEXT") + set_proc_address(&CmdEndVideoCodingKHR, "vkCmdEndVideoCodingKHR") + set_proc_address(&CmdExecuteCommands, "vkCmdExecuteCommands") + set_proc_address(&CmdExecuteGeneratedCommandsNV, "vkCmdExecuteGeneratedCommandsNV") + set_proc_address(&CmdFillBuffer, "vkCmdFillBuffer") + set_proc_address(&CmdInsertDebugUtilsLabelEXT, "vkCmdInsertDebugUtilsLabelEXT") + set_proc_address(&CmdNextSubpass, "vkCmdNextSubpass") + set_proc_address(&CmdNextSubpass2, "vkCmdNextSubpass2") + set_proc_address(&CmdNextSubpass2KHR, "vkCmdNextSubpass2KHR") + set_proc_address(&CmdOpticalFlowExecuteNV, "vkCmdOpticalFlowExecuteNV") + set_proc_address(&CmdPipelineBarrier, "vkCmdPipelineBarrier") + set_proc_address(&CmdPipelineBarrier2, "vkCmdPipelineBarrier2") + set_proc_address(&CmdPipelineBarrier2KHR, "vkCmdPipelineBarrier2KHR") + set_proc_address(&CmdPreprocessGeneratedCommandsNV, "vkCmdPreprocessGeneratedCommandsNV") + set_proc_address(&CmdPushConstants, "vkCmdPushConstants") + set_proc_address(&CmdPushDescriptorSetKHR, "vkCmdPushDescriptorSetKHR") + set_proc_address(&CmdPushDescriptorSetWithTemplateKHR, "vkCmdPushDescriptorSetWithTemplateKHR") + set_proc_address(&CmdResetEvent, "vkCmdResetEvent") + set_proc_address(&CmdResetEvent2, "vkCmdResetEvent2") + set_proc_address(&CmdResetEvent2KHR, "vkCmdResetEvent2KHR") + set_proc_address(&CmdResetQueryPool, "vkCmdResetQueryPool") + set_proc_address(&CmdResolveImage, "vkCmdResolveImage") + set_proc_address(&CmdResolveImage2, "vkCmdResolveImage2") + set_proc_address(&CmdResolveImage2KHR, "vkCmdResolveImage2KHR") + set_proc_address(&CmdSetAlphaToCoverageEnableEXT, "vkCmdSetAlphaToCoverageEnableEXT") + set_proc_address(&CmdSetAlphaToOneEnableEXT, "vkCmdSetAlphaToOneEnableEXT") + set_proc_address(&CmdSetAttachmentFeedbackLoopEnableEXT, "vkCmdSetAttachmentFeedbackLoopEnableEXT") + set_proc_address(&CmdSetBlendConstants, "vkCmdSetBlendConstants") + set_proc_address(&CmdSetCheckpointNV, "vkCmdSetCheckpointNV") + set_proc_address(&CmdSetCoarseSampleOrderNV, "vkCmdSetCoarseSampleOrderNV") + set_proc_address(&CmdSetColorBlendAdvancedEXT, "vkCmdSetColorBlendAdvancedEXT") + set_proc_address(&CmdSetColorBlendEnableEXT, "vkCmdSetColorBlendEnableEXT") + set_proc_address(&CmdSetColorBlendEquationEXT, "vkCmdSetColorBlendEquationEXT") + set_proc_address(&CmdSetColorWriteMaskEXT, "vkCmdSetColorWriteMaskEXT") + set_proc_address(&CmdSetConservativeRasterizationModeEXT, "vkCmdSetConservativeRasterizationModeEXT") + set_proc_address(&CmdSetCoverageModulationModeNV, "vkCmdSetCoverageModulationModeNV") + set_proc_address(&CmdSetCoverageModulationTableEnableNV, "vkCmdSetCoverageModulationTableEnableNV") + set_proc_address(&CmdSetCoverageModulationTableNV, "vkCmdSetCoverageModulationTableNV") + set_proc_address(&CmdSetCoverageReductionModeNV, "vkCmdSetCoverageReductionModeNV") + set_proc_address(&CmdSetCoverageToColorEnableNV, "vkCmdSetCoverageToColorEnableNV") + set_proc_address(&CmdSetCoverageToColorLocationNV, "vkCmdSetCoverageToColorLocationNV") + set_proc_address(&CmdSetCullMode, "vkCmdSetCullMode") + set_proc_address(&CmdSetCullModeEXT, "vkCmdSetCullModeEXT") + set_proc_address(&CmdSetDepthBias, "vkCmdSetDepthBias") + set_proc_address(&CmdSetDepthBiasEnable, "vkCmdSetDepthBiasEnable") + set_proc_address(&CmdSetDepthBiasEnableEXT, "vkCmdSetDepthBiasEnableEXT") + set_proc_address(&CmdSetDepthBounds, "vkCmdSetDepthBounds") + set_proc_address(&CmdSetDepthBoundsTestEnable, "vkCmdSetDepthBoundsTestEnable") + set_proc_address(&CmdSetDepthBoundsTestEnableEXT, "vkCmdSetDepthBoundsTestEnableEXT") + set_proc_address(&CmdSetDepthClampEnableEXT, "vkCmdSetDepthClampEnableEXT") + set_proc_address(&CmdSetDepthClipEnableEXT, "vkCmdSetDepthClipEnableEXT") + set_proc_address(&CmdSetDepthClipNegativeOneToOneEXT, "vkCmdSetDepthClipNegativeOneToOneEXT") + set_proc_address(&CmdSetDepthCompareOp, "vkCmdSetDepthCompareOp") + set_proc_address(&CmdSetDepthCompareOpEXT, "vkCmdSetDepthCompareOpEXT") + set_proc_address(&CmdSetDepthTestEnable, "vkCmdSetDepthTestEnable") + set_proc_address(&CmdSetDepthTestEnableEXT, "vkCmdSetDepthTestEnableEXT") + set_proc_address(&CmdSetDepthWriteEnable, "vkCmdSetDepthWriteEnable") + set_proc_address(&CmdSetDepthWriteEnableEXT, "vkCmdSetDepthWriteEnableEXT") + set_proc_address(&CmdSetDescriptorBufferOffsetsEXT, "vkCmdSetDescriptorBufferOffsetsEXT") + set_proc_address(&CmdSetDeviceMask, "vkCmdSetDeviceMask") + set_proc_address(&CmdSetDeviceMaskKHR, "vkCmdSetDeviceMaskKHR") + set_proc_address(&CmdSetDiscardRectangleEXT, "vkCmdSetDiscardRectangleEXT") + set_proc_address(&CmdSetDiscardRectangleEnableEXT, "vkCmdSetDiscardRectangleEnableEXT") + set_proc_address(&CmdSetDiscardRectangleModeEXT, "vkCmdSetDiscardRectangleModeEXT") + set_proc_address(&CmdSetEvent, "vkCmdSetEvent") + set_proc_address(&CmdSetEvent2, "vkCmdSetEvent2") + set_proc_address(&CmdSetEvent2KHR, "vkCmdSetEvent2KHR") + set_proc_address(&CmdSetExclusiveScissorEnableNV, "vkCmdSetExclusiveScissorEnableNV") + set_proc_address(&CmdSetExclusiveScissorNV, "vkCmdSetExclusiveScissorNV") + set_proc_address(&CmdSetExtraPrimitiveOverestimationSizeEXT, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") + set_proc_address(&CmdSetFragmentShadingRateEnumNV, "vkCmdSetFragmentShadingRateEnumNV") + set_proc_address(&CmdSetFragmentShadingRateKHR, "vkCmdSetFragmentShadingRateKHR") + set_proc_address(&CmdSetFrontFace, "vkCmdSetFrontFace") + set_proc_address(&CmdSetFrontFaceEXT, "vkCmdSetFrontFaceEXT") + set_proc_address(&CmdSetLineRasterizationModeEXT, "vkCmdSetLineRasterizationModeEXT") + set_proc_address(&CmdSetLineStippleEXT, "vkCmdSetLineStippleEXT") + set_proc_address(&CmdSetLineStippleEnableEXT, "vkCmdSetLineStippleEnableEXT") + set_proc_address(&CmdSetLineWidth, "vkCmdSetLineWidth") + set_proc_address(&CmdSetLogicOpEXT, "vkCmdSetLogicOpEXT") + set_proc_address(&CmdSetLogicOpEnableEXT, "vkCmdSetLogicOpEnableEXT") + set_proc_address(&CmdSetPatchControlPointsEXT, "vkCmdSetPatchControlPointsEXT") + set_proc_address(&CmdSetPerformanceMarkerINTEL, "vkCmdSetPerformanceMarkerINTEL") + set_proc_address(&CmdSetPerformanceOverrideINTEL, "vkCmdSetPerformanceOverrideINTEL") + set_proc_address(&CmdSetPerformanceStreamMarkerINTEL, "vkCmdSetPerformanceStreamMarkerINTEL") + set_proc_address(&CmdSetPolygonModeEXT, "vkCmdSetPolygonModeEXT") + set_proc_address(&CmdSetPrimitiveRestartEnable, "vkCmdSetPrimitiveRestartEnable") + set_proc_address(&CmdSetPrimitiveRestartEnableEXT, "vkCmdSetPrimitiveRestartEnableEXT") + set_proc_address(&CmdSetPrimitiveTopology, "vkCmdSetPrimitiveTopology") + set_proc_address(&CmdSetPrimitiveTopologyEXT, "vkCmdSetPrimitiveTopologyEXT") + set_proc_address(&CmdSetProvokingVertexModeEXT, "vkCmdSetProvokingVertexModeEXT") + set_proc_address(&CmdSetRasterizationSamplesEXT, "vkCmdSetRasterizationSamplesEXT") + set_proc_address(&CmdSetRasterizationStreamEXT, "vkCmdSetRasterizationStreamEXT") + set_proc_address(&CmdSetRasterizerDiscardEnable, "vkCmdSetRasterizerDiscardEnable") + set_proc_address(&CmdSetRasterizerDiscardEnableEXT, "vkCmdSetRasterizerDiscardEnableEXT") + set_proc_address(&CmdSetRayTracingPipelineStackSizeKHR, "vkCmdSetRayTracingPipelineStackSizeKHR") + set_proc_address(&CmdSetRepresentativeFragmentTestEnableNV, "vkCmdSetRepresentativeFragmentTestEnableNV") + set_proc_address(&CmdSetSampleLocationsEXT, "vkCmdSetSampleLocationsEXT") + set_proc_address(&CmdSetSampleLocationsEnableEXT, "vkCmdSetSampleLocationsEnableEXT") + set_proc_address(&CmdSetSampleMaskEXT, "vkCmdSetSampleMaskEXT") + set_proc_address(&CmdSetScissor, "vkCmdSetScissor") + set_proc_address(&CmdSetScissorWithCount, "vkCmdSetScissorWithCount") + set_proc_address(&CmdSetScissorWithCountEXT, "vkCmdSetScissorWithCountEXT") + set_proc_address(&CmdSetShadingRateImageEnableNV, "vkCmdSetShadingRateImageEnableNV") + set_proc_address(&CmdSetStencilCompareMask, "vkCmdSetStencilCompareMask") + set_proc_address(&CmdSetStencilOp, "vkCmdSetStencilOp") + set_proc_address(&CmdSetStencilOpEXT, "vkCmdSetStencilOpEXT") + set_proc_address(&CmdSetStencilReference, "vkCmdSetStencilReference") + set_proc_address(&CmdSetStencilTestEnable, "vkCmdSetStencilTestEnable") + set_proc_address(&CmdSetStencilTestEnableEXT, "vkCmdSetStencilTestEnableEXT") + set_proc_address(&CmdSetStencilWriteMask, "vkCmdSetStencilWriteMask") + set_proc_address(&CmdSetTessellationDomainOriginEXT, "vkCmdSetTessellationDomainOriginEXT") + set_proc_address(&CmdSetVertexInputEXT, "vkCmdSetVertexInputEXT") + set_proc_address(&CmdSetViewport, "vkCmdSetViewport") + set_proc_address(&CmdSetViewportShadingRatePaletteNV, "vkCmdSetViewportShadingRatePaletteNV") + set_proc_address(&CmdSetViewportSwizzleNV, "vkCmdSetViewportSwizzleNV") + set_proc_address(&CmdSetViewportWScalingEnableNV, "vkCmdSetViewportWScalingEnableNV") + set_proc_address(&CmdSetViewportWScalingNV, "vkCmdSetViewportWScalingNV") + set_proc_address(&CmdSetViewportWithCount, "vkCmdSetViewportWithCount") + set_proc_address(&CmdSetViewportWithCountEXT, "vkCmdSetViewportWithCountEXT") + set_proc_address(&CmdSubpassShadingHUAWEI, "vkCmdSubpassShadingHUAWEI") + set_proc_address(&CmdTraceRaysIndirect2KHR, "vkCmdTraceRaysIndirect2KHR") + set_proc_address(&CmdTraceRaysIndirectKHR, "vkCmdTraceRaysIndirectKHR") + set_proc_address(&CmdTraceRaysKHR, "vkCmdTraceRaysKHR") + set_proc_address(&CmdTraceRaysNV, "vkCmdTraceRaysNV") + set_proc_address(&CmdUpdateBuffer, "vkCmdUpdateBuffer") + set_proc_address(&CmdWaitEvents, "vkCmdWaitEvents") + set_proc_address(&CmdWaitEvents2, "vkCmdWaitEvents2") + set_proc_address(&CmdWaitEvents2KHR, "vkCmdWaitEvents2KHR") + set_proc_address(&CmdWriteAccelerationStructuresPropertiesKHR, "vkCmdWriteAccelerationStructuresPropertiesKHR") + set_proc_address(&CmdWriteAccelerationStructuresPropertiesNV, "vkCmdWriteAccelerationStructuresPropertiesNV") + set_proc_address(&CmdWriteBufferMarker2AMD, "vkCmdWriteBufferMarker2AMD") + set_proc_address(&CmdWriteBufferMarkerAMD, "vkCmdWriteBufferMarkerAMD") + set_proc_address(&CmdWriteMicromapsPropertiesEXT, "vkCmdWriteMicromapsPropertiesEXT") + set_proc_address(&CmdWriteTimestamp, "vkCmdWriteTimestamp") + set_proc_address(&CmdWriteTimestamp2, "vkCmdWriteTimestamp2") + set_proc_address(&CmdWriteTimestamp2KHR, "vkCmdWriteTimestamp2KHR") + set_proc_address(&CompileDeferredNV, "vkCompileDeferredNV") + set_proc_address(&CopyAccelerationStructureKHR, "vkCopyAccelerationStructureKHR") + set_proc_address(&CopyAccelerationStructureToMemoryKHR, "vkCopyAccelerationStructureToMemoryKHR") + set_proc_address(&CopyMemoryToAccelerationStructureKHR, "vkCopyMemoryToAccelerationStructureKHR") + set_proc_address(&CopyMemoryToMicromapEXT, "vkCopyMemoryToMicromapEXT") + set_proc_address(&CopyMicromapEXT, "vkCopyMicromapEXT") + set_proc_address(&CopyMicromapToMemoryEXT, "vkCopyMicromapToMemoryEXT") + set_proc_address(&CreateAccelerationStructureKHR, "vkCreateAccelerationStructureKHR") + set_proc_address(&CreateAccelerationStructureNV, "vkCreateAccelerationStructureNV") + set_proc_address(&CreateBuffer, "vkCreateBuffer") + set_proc_address(&CreateBufferView, "vkCreateBufferView") + set_proc_address(&CreateCommandPool, "vkCreateCommandPool") + set_proc_address(&CreateComputePipelines, "vkCreateComputePipelines") + set_proc_address(&CreateCuFunctionNVX, "vkCreateCuFunctionNVX") + set_proc_address(&CreateCuModuleNVX, "vkCreateCuModuleNVX") + set_proc_address(&CreateDeferredOperationKHR, "vkCreateDeferredOperationKHR") + set_proc_address(&CreateDescriptorPool, "vkCreateDescriptorPool") + set_proc_address(&CreateDescriptorSetLayout, "vkCreateDescriptorSetLayout") + set_proc_address(&CreateDescriptorUpdateTemplate, "vkCreateDescriptorUpdateTemplate") + set_proc_address(&CreateDescriptorUpdateTemplateKHR, "vkCreateDescriptorUpdateTemplateKHR") + set_proc_address(&CreateEvent, "vkCreateEvent") + set_proc_address(&CreateFence, "vkCreateFence") + set_proc_address(&CreateFramebuffer, "vkCreateFramebuffer") + set_proc_address(&CreateGraphicsPipelines, "vkCreateGraphicsPipelines") + set_proc_address(&CreateImage, "vkCreateImage") + set_proc_address(&CreateImageView, "vkCreateImageView") + set_proc_address(&CreateIndirectCommandsLayoutNV, "vkCreateIndirectCommandsLayoutNV") + set_proc_address(&CreateMicromapEXT, "vkCreateMicromapEXT") + set_proc_address(&CreateOpticalFlowSessionNV, "vkCreateOpticalFlowSessionNV") + set_proc_address(&CreatePipelineCache, "vkCreatePipelineCache") + set_proc_address(&CreatePipelineLayout, "vkCreatePipelineLayout") + set_proc_address(&CreatePrivateDataSlot, "vkCreatePrivateDataSlot") + set_proc_address(&CreatePrivateDataSlotEXT, "vkCreatePrivateDataSlotEXT") + set_proc_address(&CreateQueryPool, "vkCreateQueryPool") + set_proc_address(&CreateRayTracingPipelinesKHR, "vkCreateRayTracingPipelinesKHR") + set_proc_address(&CreateRayTracingPipelinesNV, "vkCreateRayTracingPipelinesNV") + set_proc_address(&CreateRenderPass, "vkCreateRenderPass") + set_proc_address(&CreateRenderPass2, "vkCreateRenderPass2") + set_proc_address(&CreateRenderPass2KHR, "vkCreateRenderPass2KHR") + set_proc_address(&CreateSampler, "vkCreateSampler") + set_proc_address(&CreateSamplerYcbcrConversion, "vkCreateSamplerYcbcrConversion") + set_proc_address(&CreateSamplerYcbcrConversionKHR, "vkCreateSamplerYcbcrConversionKHR") + set_proc_address(&CreateSemaphore, "vkCreateSemaphore") + set_proc_address(&CreateShaderModule, "vkCreateShaderModule") + set_proc_address(&CreateShadersEXT, "vkCreateShadersEXT") + set_proc_address(&CreateSharedSwapchainsKHR, "vkCreateSharedSwapchainsKHR") + set_proc_address(&CreateSwapchainKHR, "vkCreateSwapchainKHR") + set_proc_address(&CreateValidationCacheEXT, "vkCreateValidationCacheEXT") + set_proc_address(&CreateVideoSessionKHR, "vkCreateVideoSessionKHR") + set_proc_address(&CreateVideoSessionParametersKHR, "vkCreateVideoSessionParametersKHR") + set_proc_address(&DebugMarkerSetObjectNameEXT, "vkDebugMarkerSetObjectNameEXT") + set_proc_address(&DebugMarkerSetObjectTagEXT, "vkDebugMarkerSetObjectTagEXT") + set_proc_address(&DeferredOperationJoinKHR, "vkDeferredOperationJoinKHR") + set_proc_address(&DestroyAccelerationStructureKHR, "vkDestroyAccelerationStructureKHR") + set_proc_address(&DestroyAccelerationStructureNV, "vkDestroyAccelerationStructureNV") + set_proc_address(&DestroyBuffer, "vkDestroyBuffer") + set_proc_address(&DestroyBufferView, "vkDestroyBufferView") + set_proc_address(&DestroyCommandPool, "vkDestroyCommandPool") + set_proc_address(&DestroyCuFunctionNVX, "vkDestroyCuFunctionNVX") + set_proc_address(&DestroyCuModuleNVX, "vkDestroyCuModuleNVX") + set_proc_address(&DestroyDeferredOperationKHR, "vkDestroyDeferredOperationKHR") + set_proc_address(&DestroyDescriptorPool, "vkDestroyDescriptorPool") + set_proc_address(&DestroyDescriptorSetLayout, "vkDestroyDescriptorSetLayout") + set_proc_address(&DestroyDescriptorUpdateTemplate, "vkDestroyDescriptorUpdateTemplate") + set_proc_address(&DestroyDescriptorUpdateTemplateKHR, "vkDestroyDescriptorUpdateTemplateKHR") + set_proc_address(&DestroyDevice, "vkDestroyDevice") + set_proc_address(&DestroyEvent, "vkDestroyEvent") + set_proc_address(&DestroyFence, "vkDestroyFence") + set_proc_address(&DestroyFramebuffer, "vkDestroyFramebuffer") + set_proc_address(&DestroyImage, "vkDestroyImage") + set_proc_address(&DestroyImageView, "vkDestroyImageView") + set_proc_address(&DestroyIndirectCommandsLayoutNV, "vkDestroyIndirectCommandsLayoutNV") + set_proc_address(&DestroyMicromapEXT, "vkDestroyMicromapEXT") + set_proc_address(&DestroyOpticalFlowSessionNV, "vkDestroyOpticalFlowSessionNV") + set_proc_address(&DestroyPipeline, "vkDestroyPipeline") + set_proc_address(&DestroyPipelineCache, "vkDestroyPipelineCache") + set_proc_address(&DestroyPipelineLayout, "vkDestroyPipelineLayout") + set_proc_address(&DestroyPrivateDataSlot, "vkDestroyPrivateDataSlot") + set_proc_address(&DestroyPrivateDataSlotEXT, "vkDestroyPrivateDataSlotEXT") + set_proc_address(&DestroyQueryPool, "vkDestroyQueryPool") + set_proc_address(&DestroyRenderPass, "vkDestroyRenderPass") + set_proc_address(&DestroySampler, "vkDestroySampler") + set_proc_address(&DestroySamplerYcbcrConversion, "vkDestroySamplerYcbcrConversion") + set_proc_address(&DestroySamplerYcbcrConversionKHR, "vkDestroySamplerYcbcrConversionKHR") + set_proc_address(&DestroySemaphore, "vkDestroySemaphore") + set_proc_address(&DestroyShaderEXT, "vkDestroyShaderEXT") + set_proc_address(&DestroyShaderModule, "vkDestroyShaderModule") + set_proc_address(&DestroySwapchainKHR, "vkDestroySwapchainKHR") + set_proc_address(&DestroyValidationCacheEXT, "vkDestroyValidationCacheEXT") + set_proc_address(&DestroyVideoSessionKHR, "vkDestroyVideoSessionKHR") + set_proc_address(&DestroyVideoSessionParametersKHR, "vkDestroyVideoSessionParametersKHR") + set_proc_address(&DeviceWaitIdle, "vkDeviceWaitIdle") + set_proc_address(&DisplayPowerControlEXT, "vkDisplayPowerControlEXT") + set_proc_address(&EndCommandBuffer, "vkEndCommandBuffer") + set_proc_address(&ExportMetalObjectsEXT, "vkExportMetalObjectsEXT") + set_proc_address(&FlushMappedMemoryRanges, "vkFlushMappedMemoryRanges") + set_proc_address(&FreeCommandBuffers, "vkFreeCommandBuffers") + set_proc_address(&FreeDescriptorSets, "vkFreeDescriptorSets") + set_proc_address(&FreeMemory, "vkFreeMemory") + set_proc_address(&GetAccelerationStructureBuildSizesKHR, "vkGetAccelerationStructureBuildSizesKHR") + set_proc_address(&GetAccelerationStructureDeviceAddressKHR, "vkGetAccelerationStructureDeviceAddressKHR") + set_proc_address(&GetAccelerationStructureHandleNV, "vkGetAccelerationStructureHandleNV") + set_proc_address(&GetAccelerationStructureMemoryRequirementsNV, "vkGetAccelerationStructureMemoryRequirementsNV") + set_proc_address(&GetAccelerationStructureOpaqueCaptureDescriptorDataEXT, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") + set_proc_address(&GetBufferDeviceAddress, "vkGetBufferDeviceAddress") + set_proc_address(&GetBufferDeviceAddressEXT, "vkGetBufferDeviceAddressEXT") + set_proc_address(&GetBufferDeviceAddressKHR, "vkGetBufferDeviceAddressKHR") + set_proc_address(&GetBufferMemoryRequirements, "vkGetBufferMemoryRequirements") + set_proc_address(&GetBufferMemoryRequirements2, "vkGetBufferMemoryRequirements2") + set_proc_address(&GetBufferMemoryRequirements2KHR, "vkGetBufferMemoryRequirements2KHR") + set_proc_address(&GetBufferOpaqueCaptureAddress, "vkGetBufferOpaqueCaptureAddress") + set_proc_address(&GetBufferOpaqueCaptureAddressKHR, "vkGetBufferOpaqueCaptureAddressKHR") + set_proc_address(&GetBufferOpaqueCaptureDescriptorDataEXT, "vkGetBufferOpaqueCaptureDescriptorDataEXT") + set_proc_address(&GetCalibratedTimestampsEXT, "vkGetCalibratedTimestampsEXT") + set_proc_address(&GetDeferredOperationMaxConcurrencyKHR, "vkGetDeferredOperationMaxConcurrencyKHR") + set_proc_address(&GetDeferredOperationResultKHR, "vkGetDeferredOperationResultKHR") + set_proc_address(&GetDescriptorEXT, "vkGetDescriptorEXT") + set_proc_address(&GetDescriptorSetHostMappingVALVE, "vkGetDescriptorSetHostMappingVALVE") + set_proc_address(&GetDescriptorSetLayoutBindingOffsetEXT, "vkGetDescriptorSetLayoutBindingOffsetEXT") + set_proc_address(&GetDescriptorSetLayoutHostMappingInfoVALVE, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") + set_proc_address(&GetDescriptorSetLayoutSizeEXT, "vkGetDescriptorSetLayoutSizeEXT") + set_proc_address(&GetDescriptorSetLayoutSupport, "vkGetDescriptorSetLayoutSupport") + set_proc_address(&GetDescriptorSetLayoutSupportKHR, "vkGetDescriptorSetLayoutSupportKHR") + set_proc_address(&GetDeviceAccelerationStructureCompatibilityKHR, "vkGetDeviceAccelerationStructureCompatibilityKHR") + set_proc_address(&GetDeviceBufferMemoryRequirements, "vkGetDeviceBufferMemoryRequirements") + set_proc_address(&GetDeviceBufferMemoryRequirementsKHR, "vkGetDeviceBufferMemoryRequirementsKHR") + set_proc_address(&GetDeviceFaultInfoEXT, "vkGetDeviceFaultInfoEXT") + set_proc_address(&GetDeviceGroupPeerMemoryFeatures, "vkGetDeviceGroupPeerMemoryFeatures") + set_proc_address(&GetDeviceGroupPeerMemoryFeaturesKHR, "vkGetDeviceGroupPeerMemoryFeaturesKHR") + set_proc_address(&GetDeviceGroupPresentCapabilitiesKHR, "vkGetDeviceGroupPresentCapabilitiesKHR") + set_proc_address(&GetDeviceGroupSurfacePresentModes2EXT, "vkGetDeviceGroupSurfacePresentModes2EXT") + set_proc_address(&GetDeviceGroupSurfacePresentModesKHR, "vkGetDeviceGroupSurfacePresentModesKHR") + set_proc_address(&GetDeviceImageMemoryRequirements, "vkGetDeviceImageMemoryRequirements") + set_proc_address(&GetDeviceImageMemoryRequirementsKHR, "vkGetDeviceImageMemoryRequirementsKHR") + set_proc_address(&GetDeviceImageSparseMemoryRequirements, "vkGetDeviceImageSparseMemoryRequirements") + set_proc_address(&GetDeviceImageSparseMemoryRequirementsKHR, "vkGetDeviceImageSparseMemoryRequirementsKHR") + set_proc_address(&GetDeviceMemoryCommitment, "vkGetDeviceMemoryCommitment") + set_proc_address(&GetDeviceMemoryOpaqueCaptureAddress, "vkGetDeviceMemoryOpaqueCaptureAddress") + set_proc_address(&GetDeviceMemoryOpaqueCaptureAddressKHR, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") + set_proc_address(&GetDeviceMicromapCompatibilityEXT, "vkGetDeviceMicromapCompatibilityEXT") + set_proc_address(&GetDeviceProcAddr, "vkGetDeviceProcAddr") + set_proc_address(&GetDeviceQueue, "vkGetDeviceQueue") + set_proc_address(&GetDeviceQueue2, "vkGetDeviceQueue2") + set_proc_address(&GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") + set_proc_address(&GetDynamicRenderingTilePropertiesQCOM, "vkGetDynamicRenderingTilePropertiesQCOM") + set_proc_address(&GetEventStatus, "vkGetEventStatus") + set_proc_address(&GetFenceFdKHR, "vkGetFenceFdKHR") + set_proc_address(&GetFenceStatus, "vkGetFenceStatus") + set_proc_address(&GetFenceWin32HandleKHR, "vkGetFenceWin32HandleKHR") + set_proc_address(&GetFramebufferTilePropertiesQCOM, "vkGetFramebufferTilePropertiesQCOM") + set_proc_address(&GetGeneratedCommandsMemoryRequirementsNV, "vkGetGeneratedCommandsMemoryRequirementsNV") + set_proc_address(&GetImageDrmFormatModifierPropertiesEXT, "vkGetImageDrmFormatModifierPropertiesEXT") + set_proc_address(&GetImageMemoryRequirements, "vkGetImageMemoryRequirements") + set_proc_address(&GetImageMemoryRequirements2, "vkGetImageMemoryRequirements2") + set_proc_address(&GetImageMemoryRequirements2KHR, "vkGetImageMemoryRequirements2KHR") + set_proc_address(&GetImageOpaqueCaptureDescriptorDataEXT, "vkGetImageOpaqueCaptureDescriptorDataEXT") + set_proc_address(&GetImageSparseMemoryRequirements, "vkGetImageSparseMemoryRequirements") + set_proc_address(&GetImageSparseMemoryRequirements2, "vkGetImageSparseMemoryRequirements2") + set_proc_address(&GetImageSparseMemoryRequirements2KHR, "vkGetImageSparseMemoryRequirements2KHR") + set_proc_address(&GetImageSubresourceLayout, "vkGetImageSubresourceLayout") + set_proc_address(&GetImageSubresourceLayout2EXT, "vkGetImageSubresourceLayout2EXT") + set_proc_address(&GetImageViewAddressNVX, "vkGetImageViewAddressNVX") + set_proc_address(&GetImageViewHandleNVX, "vkGetImageViewHandleNVX") + set_proc_address(&GetImageViewOpaqueCaptureDescriptorDataEXT, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") + set_proc_address(&GetMemoryFdKHR, "vkGetMemoryFdKHR") + set_proc_address(&GetMemoryFdPropertiesKHR, "vkGetMemoryFdPropertiesKHR") + set_proc_address(&GetMemoryHostPointerPropertiesEXT, "vkGetMemoryHostPointerPropertiesEXT") + set_proc_address(&GetMemoryRemoteAddressNV, "vkGetMemoryRemoteAddressNV") + set_proc_address(&GetMemoryWin32HandleKHR, "vkGetMemoryWin32HandleKHR") + set_proc_address(&GetMemoryWin32HandleNV, "vkGetMemoryWin32HandleNV") + set_proc_address(&GetMemoryWin32HandlePropertiesKHR, "vkGetMemoryWin32HandlePropertiesKHR") + set_proc_address(&GetMicromapBuildSizesEXT, "vkGetMicromapBuildSizesEXT") + set_proc_address(&GetPastPresentationTimingGOOGLE, "vkGetPastPresentationTimingGOOGLE") + set_proc_address(&GetPerformanceParameterINTEL, "vkGetPerformanceParameterINTEL") + set_proc_address(&GetPipelineCacheData, "vkGetPipelineCacheData") + set_proc_address(&GetPipelineExecutableInternalRepresentationsKHR, "vkGetPipelineExecutableInternalRepresentationsKHR") + set_proc_address(&GetPipelineExecutablePropertiesKHR, "vkGetPipelineExecutablePropertiesKHR") + set_proc_address(&GetPipelineExecutableStatisticsKHR, "vkGetPipelineExecutableStatisticsKHR") + set_proc_address(&GetPipelinePropertiesEXT, "vkGetPipelinePropertiesEXT") + set_proc_address(&GetPrivateData, "vkGetPrivateData") + set_proc_address(&GetPrivateDataEXT, "vkGetPrivateDataEXT") + set_proc_address(&GetQueryPoolResults, "vkGetQueryPoolResults") + set_proc_address(&GetQueueCheckpointData2NV, "vkGetQueueCheckpointData2NV") + set_proc_address(&GetQueueCheckpointDataNV, "vkGetQueueCheckpointDataNV") + set_proc_address(&GetRayTracingCaptureReplayShaderGroupHandlesKHR, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") + set_proc_address(&GetRayTracingShaderGroupHandlesKHR, "vkGetRayTracingShaderGroupHandlesKHR") + set_proc_address(&GetRayTracingShaderGroupHandlesNV, "vkGetRayTracingShaderGroupHandlesNV") + set_proc_address(&GetRayTracingShaderGroupStackSizeKHR, "vkGetRayTracingShaderGroupStackSizeKHR") + set_proc_address(&GetRefreshCycleDurationGOOGLE, "vkGetRefreshCycleDurationGOOGLE") + set_proc_address(&GetRenderAreaGranularity, "vkGetRenderAreaGranularity") + set_proc_address(&GetSamplerOpaqueCaptureDescriptorDataEXT, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") + set_proc_address(&GetSemaphoreCounterValue, "vkGetSemaphoreCounterValue") + set_proc_address(&GetSemaphoreCounterValueKHR, "vkGetSemaphoreCounterValueKHR") + set_proc_address(&GetSemaphoreFdKHR, "vkGetSemaphoreFdKHR") + set_proc_address(&GetSemaphoreWin32HandleKHR, "vkGetSemaphoreWin32HandleKHR") + set_proc_address(&GetShaderBinaryDataEXT, "vkGetShaderBinaryDataEXT") + set_proc_address(&GetShaderInfoAMD, "vkGetShaderInfoAMD") + set_proc_address(&GetShaderModuleCreateInfoIdentifierEXT, "vkGetShaderModuleCreateInfoIdentifierEXT") + set_proc_address(&GetShaderModuleIdentifierEXT, "vkGetShaderModuleIdentifierEXT") + set_proc_address(&GetSwapchainCounterEXT, "vkGetSwapchainCounterEXT") + set_proc_address(&GetSwapchainImagesKHR, "vkGetSwapchainImagesKHR") + set_proc_address(&GetSwapchainStatusKHR, "vkGetSwapchainStatusKHR") + set_proc_address(&GetValidationCacheDataEXT, "vkGetValidationCacheDataEXT") + set_proc_address(&GetVideoSessionMemoryRequirementsKHR, "vkGetVideoSessionMemoryRequirementsKHR") + set_proc_address(&ImportFenceFdKHR, "vkImportFenceFdKHR") + set_proc_address(&ImportFenceWin32HandleKHR, "vkImportFenceWin32HandleKHR") + set_proc_address(&ImportSemaphoreFdKHR, "vkImportSemaphoreFdKHR") + set_proc_address(&ImportSemaphoreWin32HandleKHR, "vkImportSemaphoreWin32HandleKHR") + set_proc_address(&InitializePerformanceApiINTEL, "vkInitializePerformanceApiINTEL") + set_proc_address(&InvalidateMappedMemoryRanges, "vkInvalidateMappedMemoryRanges") + set_proc_address(&MapMemory, "vkMapMemory") + set_proc_address(&MapMemory2KHR, "vkMapMemory2KHR") + set_proc_address(&MergePipelineCaches, "vkMergePipelineCaches") + set_proc_address(&MergeValidationCachesEXT, "vkMergeValidationCachesEXT") + set_proc_address(&QueueBeginDebugUtilsLabelEXT, "vkQueueBeginDebugUtilsLabelEXT") + set_proc_address(&QueueBindSparse, "vkQueueBindSparse") + set_proc_address(&QueueEndDebugUtilsLabelEXT, "vkQueueEndDebugUtilsLabelEXT") + set_proc_address(&QueueInsertDebugUtilsLabelEXT, "vkQueueInsertDebugUtilsLabelEXT") + set_proc_address(&QueuePresentKHR, "vkQueuePresentKHR") + set_proc_address(&QueueSetPerformanceConfigurationINTEL, "vkQueueSetPerformanceConfigurationINTEL") + set_proc_address(&QueueSubmit, "vkQueueSubmit") + set_proc_address(&QueueSubmit2, "vkQueueSubmit2") + set_proc_address(&QueueSubmit2KHR, "vkQueueSubmit2KHR") + set_proc_address(&QueueWaitIdle, "vkQueueWaitIdle") + set_proc_address(&RegisterDeviceEventEXT, "vkRegisterDeviceEventEXT") + set_proc_address(&RegisterDisplayEventEXT, "vkRegisterDisplayEventEXT") + set_proc_address(&ReleaseFullScreenExclusiveModeEXT, "vkReleaseFullScreenExclusiveModeEXT") + set_proc_address(&ReleasePerformanceConfigurationINTEL, "vkReleasePerformanceConfigurationINTEL") + set_proc_address(&ReleaseProfilingLockKHR, "vkReleaseProfilingLockKHR") + set_proc_address(&ReleaseSwapchainImagesEXT, "vkReleaseSwapchainImagesEXT") + set_proc_address(&ResetCommandBuffer, "vkResetCommandBuffer") + set_proc_address(&ResetCommandPool, "vkResetCommandPool") + set_proc_address(&ResetDescriptorPool, "vkResetDescriptorPool") + set_proc_address(&ResetEvent, "vkResetEvent") + set_proc_address(&ResetFences, "vkResetFences") + set_proc_address(&ResetQueryPool, "vkResetQueryPool") + set_proc_address(&ResetQueryPoolEXT, "vkResetQueryPoolEXT") + set_proc_address(&SetDebugUtilsObjectNameEXT, "vkSetDebugUtilsObjectNameEXT") + set_proc_address(&SetDebugUtilsObjectTagEXT, "vkSetDebugUtilsObjectTagEXT") + set_proc_address(&SetDeviceMemoryPriorityEXT, "vkSetDeviceMemoryPriorityEXT") + set_proc_address(&SetEvent, "vkSetEvent") + set_proc_address(&SetHdrMetadataEXT, "vkSetHdrMetadataEXT") + set_proc_address(&SetLocalDimmingAMD, "vkSetLocalDimmingAMD") + set_proc_address(&SetPrivateData, "vkSetPrivateData") + set_proc_address(&SetPrivateDataEXT, "vkSetPrivateDataEXT") + set_proc_address(&SignalSemaphore, "vkSignalSemaphore") + set_proc_address(&SignalSemaphoreKHR, "vkSignalSemaphoreKHR") + set_proc_address(&TrimCommandPool, "vkTrimCommandPool") + set_proc_address(&TrimCommandPoolKHR, "vkTrimCommandPoolKHR") + set_proc_address(&UninitializePerformanceApiINTEL, "vkUninitializePerformanceApiINTEL") + set_proc_address(&UnmapMemory, "vkUnmapMemory") + set_proc_address(&UnmapMemory2KHR, "vkUnmapMemory2KHR") + set_proc_address(&UpdateDescriptorSetWithTemplate, "vkUpdateDescriptorSetWithTemplate") + set_proc_address(&UpdateDescriptorSetWithTemplateKHR, "vkUpdateDescriptorSetWithTemplateKHR") + set_proc_address(&UpdateDescriptorSets, "vkUpdateDescriptorSets") + set_proc_address(&UpdateVideoSessionParametersKHR, "vkUpdateVideoSessionParametersKHR") + set_proc_address(&WaitForFences, "vkWaitForFences") + set_proc_address(&WaitForPresentKHR, "vkWaitForPresentKHR") + set_proc_address(&WaitSemaphores, "vkWaitSemaphores") + set_proc_address(&WaitSemaphoresKHR, "vkWaitSemaphoresKHR") + set_proc_address(&WriteAccelerationStructuresPropertiesKHR, "vkWriteAccelerationStructuresPropertiesKHR") + set_proc_address(&WriteMicromapsPropertiesEXT, "vkWriteMicromapsPropertiesEXT") } // Device Procedure VTable Device_VTable :: struct { - AcquireFullScreenExclusiveModeEXT: ProcAcquireFullScreenExclusiveModeEXT, - AcquireNextImage2KHR: ProcAcquireNextImage2KHR, - AcquireNextImageKHR: ProcAcquireNextImageKHR, - AcquirePerformanceConfigurationINTEL: ProcAcquirePerformanceConfigurationINTEL, - AcquireProfilingLockKHR: ProcAcquireProfilingLockKHR, - AllocateCommandBuffers: ProcAllocateCommandBuffers, - AllocateDescriptorSets: ProcAllocateDescriptorSets, - AllocateMemory: ProcAllocateMemory, - BeginCommandBuffer: ProcBeginCommandBuffer, - BindAccelerationStructureMemoryNV: ProcBindAccelerationStructureMemoryNV, - BindBufferMemory: ProcBindBufferMemory, - BindBufferMemory2: ProcBindBufferMemory2, - BindBufferMemory2KHR: ProcBindBufferMemory2KHR, - BindImageMemory: ProcBindImageMemory, - BindImageMemory2: ProcBindImageMemory2, - BindImageMemory2KHR: ProcBindImageMemory2KHR, - BuildAccelerationStructuresKHR: ProcBuildAccelerationStructuresKHR, - CmdBeginConditionalRenderingEXT: ProcCmdBeginConditionalRenderingEXT, - CmdBeginDebugUtilsLabelEXT: ProcCmdBeginDebugUtilsLabelEXT, - CmdBeginQuery: ProcCmdBeginQuery, - CmdBeginQueryIndexedEXT: ProcCmdBeginQueryIndexedEXT, - CmdBeginRenderPass: ProcCmdBeginRenderPass, - CmdBeginRenderPass2: ProcCmdBeginRenderPass2, - CmdBeginRenderPass2KHR: ProcCmdBeginRenderPass2KHR, - CmdBeginRendering: ProcCmdBeginRendering, - CmdBeginRenderingKHR: ProcCmdBeginRenderingKHR, - CmdBeginTransformFeedbackEXT: ProcCmdBeginTransformFeedbackEXT, - CmdBindDescriptorSets: ProcCmdBindDescriptorSets, - CmdBindIndexBuffer: ProcCmdBindIndexBuffer, - CmdBindInvocationMaskHUAWEI: ProcCmdBindInvocationMaskHUAWEI, - CmdBindPipeline: ProcCmdBindPipeline, - CmdBindPipelineShaderGroupNV: ProcCmdBindPipelineShaderGroupNV, - CmdBindShadingRateImageNV: ProcCmdBindShadingRateImageNV, - CmdBindTransformFeedbackBuffersEXT: ProcCmdBindTransformFeedbackBuffersEXT, - CmdBindVertexBuffers: ProcCmdBindVertexBuffers, - CmdBindVertexBuffers2: ProcCmdBindVertexBuffers2, - CmdBindVertexBuffers2EXT: ProcCmdBindVertexBuffers2EXT, - CmdBlitImage: ProcCmdBlitImage, - CmdBlitImage2: ProcCmdBlitImage2, - CmdBlitImage2KHR: ProcCmdBlitImage2KHR, - CmdBuildAccelerationStructureNV: ProcCmdBuildAccelerationStructureNV, - CmdBuildAccelerationStructuresIndirectKHR: ProcCmdBuildAccelerationStructuresIndirectKHR, - CmdBuildAccelerationStructuresKHR: ProcCmdBuildAccelerationStructuresKHR, - CmdClearAttachments: ProcCmdClearAttachments, - CmdClearColorImage: ProcCmdClearColorImage, - CmdClearDepthStencilImage: ProcCmdClearDepthStencilImage, - CmdCopyAccelerationStructureKHR: ProcCmdCopyAccelerationStructureKHR, - CmdCopyAccelerationStructureNV: ProcCmdCopyAccelerationStructureNV, - CmdCopyAccelerationStructureToMemoryKHR: ProcCmdCopyAccelerationStructureToMemoryKHR, - CmdCopyBuffer: ProcCmdCopyBuffer, - CmdCopyBuffer2: ProcCmdCopyBuffer2, - CmdCopyBuffer2KHR: ProcCmdCopyBuffer2KHR, - CmdCopyBufferToImage: ProcCmdCopyBufferToImage, - CmdCopyBufferToImage2: ProcCmdCopyBufferToImage2, - CmdCopyBufferToImage2KHR: ProcCmdCopyBufferToImage2KHR, - CmdCopyImage: ProcCmdCopyImage, - CmdCopyImage2: ProcCmdCopyImage2, - CmdCopyImage2KHR: ProcCmdCopyImage2KHR, - CmdCopyImageToBuffer: ProcCmdCopyImageToBuffer, - CmdCopyImageToBuffer2: ProcCmdCopyImageToBuffer2, - CmdCopyImageToBuffer2KHR: ProcCmdCopyImageToBuffer2KHR, - CmdCopyMemoryToAccelerationStructureKHR: ProcCmdCopyMemoryToAccelerationStructureKHR, - CmdCopyQueryPoolResults: ProcCmdCopyQueryPoolResults, - CmdCuLaunchKernelNVX: ProcCmdCuLaunchKernelNVX, - CmdDebugMarkerBeginEXT: ProcCmdDebugMarkerBeginEXT, - CmdDebugMarkerEndEXT: ProcCmdDebugMarkerEndEXT, - CmdDebugMarkerInsertEXT: ProcCmdDebugMarkerInsertEXT, - CmdDispatch: ProcCmdDispatch, - CmdDispatchBase: ProcCmdDispatchBase, - CmdDispatchBaseKHR: ProcCmdDispatchBaseKHR, - CmdDispatchIndirect: ProcCmdDispatchIndirect, - CmdDraw: ProcCmdDraw, - CmdDrawIndexed: ProcCmdDrawIndexed, - CmdDrawIndexedIndirect: ProcCmdDrawIndexedIndirect, - CmdDrawIndexedIndirectCount: ProcCmdDrawIndexedIndirectCount, - CmdDrawIndexedIndirectCountAMD: ProcCmdDrawIndexedIndirectCountAMD, - CmdDrawIndexedIndirectCountKHR: ProcCmdDrawIndexedIndirectCountKHR, - CmdDrawIndirect: ProcCmdDrawIndirect, - CmdDrawIndirectByteCountEXT: ProcCmdDrawIndirectByteCountEXT, - CmdDrawIndirectCount: ProcCmdDrawIndirectCount, - CmdDrawIndirectCountAMD: ProcCmdDrawIndirectCountAMD, - CmdDrawIndirectCountKHR: ProcCmdDrawIndirectCountKHR, - CmdDrawMeshTasksIndirectCountNV: ProcCmdDrawMeshTasksIndirectCountNV, - CmdDrawMeshTasksIndirectNV: ProcCmdDrawMeshTasksIndirectNV, - CmdDrawMeshTasksNV: ProcCmdDrawMeshTasksNV, - CmdDrawMultiEXT: ProcCmdDrawMultiEXT, - CmdDrawMultiIndexedEXT: ProcCmdDrawMultiIndexedEXT, - CmdEndConditionalRenderingEXT: ProcCmdEndConditionalRenderingEXT, - CmdEndDebugUtilsLabelEXT: ProcCmdEndDebugUtilsLabelEXT, - CmdEndQuery: ProcCmdEndQuery, - CmdEndQueryIndexedEXT: ProcCmdEndQueryIndexedEXT, - CmdEndRenderPass: ProcCmdEndRenderPass, - CmdEndRenderPass2: ProcCmdEndRenderPass2, - CmdEndRenderPass2KHR: ProcCmdEndRenderPass2KHR, - CmdEndRendering: ProcCmdEndRendering, - CmdEndRenderingKHR: ProcCmdEndRenderingKHR, - CmdEndTransformFeedbackEXT: ProcCmdEndTransformFeedbackEXT, - CmdExecuteCommands: ProcCmdExecuteCommands, - CmdExecuteGeneratedCommandsNV: ProcCmdExecuteGeneratedCommandsNV, - CmdFillBuffer: ProcCmdFillBuffer, - CmdInsertDebugUtilsLabelEXT: ProcCmdInsertDebugUtilsLabelEXT, - CmdNextSubpass: ProcCmdNextSubpass, - CmdNextSubpass2: ProcCmdNextSubpass2, - CmdNextSubpass2KHR: ProcCmdNextSubpass2KHR, - CmdPipelineBarrier: ProcCmdPipelineBarrier, - CmdPipelineBarrier2: ProcCmdPipelineBarrier2, - CmdPipelineBarrier2KHR: ProcCmdPipelineBarrier2KHR, - CmdPreprocessGeneratedCommandsNV: ProcCmdPreprocessGeneratedCommandsNV, - CmdPushConstants: ProcCmdPushConstants, - CmdPushDescriptorSetKHR: ProcCmdPushDescriptorSetKHR, - CmdPushDescriptorSetWithTemplateKHR: ProcCmdPushDescriptorSetWithTemplateKHR, - CmdResetEvent: ProcCmdResetEvent, - CmdResetEvent2: ProcCmdResetEvent2, - CmdResetEvent2KHR: ProcCmdResetEvent2KHR, - CmdResetQueryPool: ProcCmdResetQueryPool, - CmdResolveImage: ProcCmdResolveImage, - CmdResolveImage2: ProcCmdResolveImage2, - CmdResolveImage2KHR: ProcCmdResolveImage2KHR, - CmdSetBlendConstants: ProcCmdSetBlendConstants, - CmdSetCheckpointNV: ProcCmdSetCheckpointNV, - CmdSetCoarseSampleOrderNV: ProcCmdSetCoarseSampleOrderNV, - CmdSetCullMode: ProcCmdSetCullMode, - CmdSetCullModeEXT: ProcCmdSetCullModeEXT, - CmdSetDepthBias: ProcCmdSetDepthBias, - CmdSetDepthBiasEnable: ProcCmdSetDepthBiasEnable, - CmdSetDepthBiasEnableEXT: ProcCmdSetDepthBiasEnableEXT, - CmdSetDepthBounds: ProcCmdSetDepthBounds, - CmdSetDepthBoundsTestEnable: ProcCmdSetDepthBoundsTestEnable, - CmdSetDepthBoundsTestEnableEXT: ProcCmdSetDepthBoundsTestEnableEXT, - CmdSetDepthCompareOp: ProcCmdSetDepthCompareOp, - CmdSetDepthCompareOpEXT: ProcCmdSetDepthCompareOpEXT, - CmdSetDepthTestEnable: ProcCmdSetDepthTestEnable, - CmdSetDepthTestEnableEXT: ProcCmdSetDepthTestEnableEXT, - CmdSetDepthWriteEnable: ProcCmdSetDepthWriteEnable, - CmdSetDepthWriteEnableEXT: ProcCmdSetDepthWriteEnableEXT, - CmdSetDeviceMask: ProcCmdSetDeviceMask, - CmdSetDeviceMaskKHR: ProcCmdSetDeviceMaskKHR, - CmdSetDiscardRectangleEXT: ProcCmdSetDiscardRectangleEXT, - CmdSetEvent: ProcCmdSetEvent, - CmdSetEvent2: ProcCmdSetEvent2, - CmdSetEvent2KHR: ProcCmdSetEvent2KHR, - CmdSetExclusiveScissorNV: ProcCmdSetExclusiveScissorNV, - CmdSetFragmentShadingRateEnumNV: ProcCmdSetFragmentShadingRateEnumNV, - CmdSetFragmentShadingRateKHR: ProcCmdSetFragmentShadingRateKHR, - CmdSetFrontFace: ProcCmdSetFrontFace, - CmdSetFrontFaceEXT: ProcCmdSetFrontFaceEXT, - CmdSetLineStippleEXT: ProcCmdSetLineStippleEXT, - CmdSetLineWidth: ProcCmdSetLineWidth, - CmdSetLogicOpEXT: ProcCmdSetLogicOpEXT, - CmdSetPatchControlPointsEXT: ProcCmdSetPatchControlPointsEXT, - CmdSetPerformanceMarkerINTEL: ProcCmdSetPerformanceMarkerINTEL, - CmdSetPerformanceOverrideINTEL: ProcCmdSetPerformanceOverrideINTEL, - CmdSetPerformanceStreamMarkerINTEL: ProcCmdSetPerformanceStreamMarkerINTEL, - CmdSetPrimitiveRestartEnable: ProcCmdSetPrimitiveRestartEnable, - CmdSetPrimitiveRestartEnableEXT: ProcCmdSetPrimitiveRestartEnableEXT, - CmdSetPrimitiveTopology: ProcCmdSetPrimitiveTopology, - CmdSetPrimitiveTopologyEXT: ProcCmdSetPrimitiveTopologyEXT, - CmdSetRasterizerDiscardEnable: ProcCmdSetRasterizerDiscardEnable, - CmdSetRasterizerDiscardEnableEXT: ProcCmdSetRasterizerDiscardEnableEXT, - CmdSetRayTracingPipelineStackSizeKHR: ProcCmdSetRayTracingPipelineStackSizeKHR, - CmdSetSampleLocationsEXT: ProcCmdSetSampleLocationsEXT, - CmdSetScissor: ProcCmdSetScissor, - CmdSetScissorWithCount: ProcCmdSetScissorWithCount, - CmdSetScissorWithCountEXT: ProcCmdSetScissorWithCountEXT, - CmdSetStencilCompareMask: ProcCmdSetStencilCompareMask, - CmdSetStencilOp: ProcCmdSetStencilOp, - CmdSetStencilOpEXT: ProcCmdSetStencilOpEXT, - CmdSetStencilReference: ProcCmdSetStencilReference, - CmdSetStencilTestEnable: ProcCmdSetStencilTestEnable, - CmdSetStencilTestEnableEXT: ProcCmdSetStencilTestEnableEXT, - CmdSetStencilWriteMask: ProcCmdSetStencilWriteMask, - CmdSetVertexInputEXT: ProcCmdSetVertexInputEXT, - CmdSetViewport: ProcCmdSetViewport, - CmdSetViewportShadingRatePaletteNV: ProcCmdSetViewportShadingRatePaletteNV, - CmdSetViewportWScalingNV: ProcCmdSetViewportWScalingNV, - CmdSetViewportWithCount: ProcCmdSetViewportWithCount, - CmdSetViewportWithCountEXT: ProcCmdSetViewportWithCountEXT, - CmdSubpassShadingHUAWEI: ProcCmdSubpassShadingHUAWEI, - CmdTraceRaysIndirectKHR: ProcCmdTraceRaysIndirectKHR, - CmdTraceRaysKHR: ProcCmdTraceRaysKHR, - CmdTraceRaysNV: ProcCmdTraceRaysNV, - CmdUpdateBuffer: ProcCmdUpdateBuffer, - CmdWaitEvents: ProcCmdWaitEvents, - CmdWaitEvents2: ProcCmdWaitEvents2, - CmdWaitEvents2KHR: ProcCmdWaitEvents2KHR, - CmdWriteAccelerationStructuresPropertiesKHR: ProcCmdWriteAccelerationStructuresPropertiesKHR, - CmdWriteAccelerationStructuresPropertiesNV: ProcCmdWriteAccelerationStructuresPropertiesNV, - CmdWriteBufferMarker2AMD: ProcCmdWriteBufferMarker2AMD, - CmdWriteBufferMarkerAMD: ProcCmdWriteBufferMarkerAMD, - CmdWriteTimestamp: ProcCmdWriteTimestamp, - CmdWriteTimestamp2: ProcCmdWriteTimestamp2, - CmdWriteTimestamp2KHR: ProcCmdWriteTimestamp2KHR, - CompileDeferredNV: ProcCompileDeferredNV, - CopyAccelerationStructureKHR: ProcCopyAccelerationStructureKHR, - CopyAccelerationStructureToMemoryKHR: ProcCopyAccelerationStructureToMemoryKHR, - CopyMemoryToAccelerationStructureKHR: ProcCopyMemoryToAccelerationStructureKHR, - CreateAccelerationStructureKHR: ProcCreateAccelerationStructureKHR, - CreateAccelerationStructureNV: ProcCreateAccelerationStructureNV, - CreateBuffer: ProcCreateBuffer, - CreateBufferView: ProcCreateBufferView, - CreateCommandPool: ProcCreateCommandPool, - CreateComputePipelines: ProcCreateComputePipelines, - CreateCuFunctionNVX: ProcCreateCuFunctionNVX, - CreateCuModuleNVX: ProcCreateCuModuleNVX, - CreateDeferredOperationKHR: ProcCreateDeferredOperationKHR, - CreateDescriptorPool: ProcCreateDescriptorPool, - CreateDescriptorSetLayout: ProcCreateDescriptorSetLayout, - CreateDescriptorUpdateTemplate: ProcCreateDescriptorUpdateTemplate, - CreateDescriptorUpdateTemplateKHR: ProcCreateDescriptorUpdateTemplateKHR, - CreateEvent: ProcCreateEvent, - CreateFence: ProcCreateFence, - CreateFramebuffer: ProcCreateFramebuffer, - CreateGraphicsPipelines: ProcCreateGraphicsPipelines, - CreateImage: ProcCreateImage, - CreateImageView: ProcCreateImageView, - CreateIndirectCommandsLayoutNV: ProcCreateIndirectCommandsLayoutNV, - CreatePipelineCache: ProcCreatePipelineCache, - CreatePipelineLayout: ProcCreatePipelineLayout, - CreatePrivateDataSlot: ProcCreatePrivateDataSlot, - CreatePrivateDataSlotEXT: ProcCreatePrivateDataSlotEXT, - CreateQueryPool: ProcCreateQueryPool, - CreateRayTracingPipelinesKHR: ProcCreateRayTracingPipelinesKHR, - CreateRayTracingPipelinesNV: ProcCreateRayTracingPipelinesNV, - CreateRenderPass: ProcCreateRenderPass, - CreateRenderPass2: ProcCreateRenderPass2, - CreateRenderPass2KHR: ProcCreateRenderPass2KHR, - CreateSampler: ProcCreateSampler, - CreateSamplerYcbcrConversion: ProcCreateSamplerYcbcrConversion, - CreateSamplerYcbcrConversionKHR: ProcCreateSamplerYcbcrConversionKHR, - CreateSemaphore: ProcCreateSemaphore, - CreateShaderModule: ProcCreateShaderModule, - CreateSharedSwapchainsKHR: ProcCreateSharedSwapchainsKHR, - CreateSwapchainKHR: ProcCreateSwapchainKHR, - CreateValidationCacheEXT: ProcCreateValidationCacheEXT, - DebugMarkerSetObjectNameEXT: ProcDebugMarkerSetObjectNameEXT, - DebugMarkerSetObjectTagEXT: ProcDebugMarkerSetObjectTagEXT, - DeferredOperationJoinKHR: ProcDeferredOperationJoinKHR, - DestroyAccelerationStructureKHR: ProcDestroyAccelerationStructureKHR, - DestroyAccelerationStructureNV: ProcDestroyAccelerationStructureNV, - DestroyBuffer: ProcDestroyBuffer, - DestroyBufferView: ProcDestroyBufferView, - DestroyCommandPool: ProcDestroyCommandPool, - DestroyCuFunctionNVX: ProcDestroyCuFunctionNVX, - DestroyCuModuleNVX: ProcDestroyCuModuleNVX, - DestroyDeferredOperationKHR: ProcDestroyDeferredOperationKHR, - DestroyDescriptorPool: ProcDestroyDescriptorPool, - DestroyDescriptorSetLayout: ProcDestroyDescriptorSetLayout, - DestroyDescriptorUpdateTemplate: ProcDestroyDescriptorUpdateTemplate, - DestroyDescriptorUpdateTemplateKHR: ProcDestroyDescriptorUpdateTemplateKHR, - DestroyDevice: ProcDestroyDevice, - DestroyEvent: ProcDestroyEvent, - DestroyFence: ProcDestroyFence, - DestroyFramebuffer: ProcDestroyFramebuffer, - DestroyImage: ProcDestroyImage, - DestroyImageView: ProcDestroyImageView, - DestroyIndirectCommandsLayoutNV: ProcDestroyIndirectCommandsLayoutNV, - DestroyPipeline: ProcDestroyPipeline, - DestroyPipelineCache: ProcDestroyPipelineCache, - DestroyPipelineLayout: ProcDestroyPipelineLayout, - DestroyPrivateDataSlot: ProcDestroyPrivateDataSlot, - DestroyPrivateDataSlotEXT: ProcDestroyPrivateDataSlotEXT, - DestroyQueryPool: ProcDestroyQueryPool, - DestroyRenderPass: ProcDestroyRenderPass, - DestroySampler: ProcDestroySampler, - DestroySamplerYcbcrConversion: ProcDestroySamplerYcbcrConversion, - DestroySamplerYcbcrConversionKHR: ProcDestroySamplerYcbcrConversionKHR, - DestroySemaphore: ProcDestroySemaphore, - DestroyShaderModule: ProcDestroyShaderModule, - DestroySwapchainKHR: ProcDestroySwapchainKHR, - DestroyValidationCacheEXT: ProcDestroyValidationCacheEXT, - DeviceWaitIdle: ProcDeviceWaitIdle, - DisplayPowerControlEXT: ProcDisplayPowerControlEXT, - EndCommandBuffer: ProcEndCommandBuffer, - FlushMappedMemoryRanges: ProcFlushMappedMemoryRanges, - FreeCommandBuffers: ProcFreeCommandBuffers, - FreeDescriptorSets: ProcFreeDescriptorSets, - FreeMemory: ProcFreeMemory, - GetAccelerationStructureBuildSizesKHR: ProcGetAccelerationStructureBuildSizesKHR, - GetAccelerationStructureDeviceAddressKHR: ProcGetAccelerationStructureDeviceAddressKHR, - GetAccelerationStructureHandleNV: ProcGetAccelerationStructureHandleNV, - GetAccelerationStructureMemoryRequirementsNV: ProcGetAccelerationStructureMemoryRequirementsNV, - GetBufferDeviceAddress: ProcGetBufferDeviceAddress, - GetBufferDeviceAddressEXT: ProcGetBufferDeviceAddressEXT, - GetBufferDeviceAddressKHR: ProcGetBufferDeviceAddressKHR, - GetBufferMemoryRequirements: ProcGetBufferMemoryRequirements, - GetBufferMemoryRequirements2: ProcGetBufferMemoryRequirements2, - GetBufferMemoryRequirements2KHR: ProcGetBufferMemoryRequirements2KHR, - GetBufferOpaqueCaptureAddress: ProcGetBufferOpaqueCaptureAddress, - GetBufferOpaqueCaptureAddressKHR: ProcGetBufferOpaqueCaptureAddressKHR, - GetCalibratedTimestampsEXT: ProcGetCalibratedTimestampsEXT, - GetDeferredOperationMaxConcurrencyKHR: ProcGetDeferredOperationMaxConcurrencyKHR, - GetDeferredOperationResultKHR: ProcGetDeferredOperationResultKHR, - GetDescriptorSetHostMappingVALVE: ProcGetDescriptorSetHostMappingVALVE, - GetDescriptorSetLayoutHostMappingInfoVALVE: ProcGetDescriptorSetLayoutHostMappingInfoVALVE, - GetDescriptorSetLayoutSupport: ProcGetDescriptorSetLayoutSupport, - GetDescriptorSetLayoutSupportKHR: ProcGetDescriptorSetLayoutSupportKHR, - GetDeviceAccelerationStructureCompatibilityKHR: ProcGetDeviceAccelerationStructureCompatibilityKHR, - GetDeviceBufferMemoryRequirements: ProcGetDeviceBufferMemoryRequirements, - GetDeviceBufferMemoryRequirementsKHR: ProcGetDeviceBufferMemoryRequirementsKHR, - GetDeviceGroupPeerMemoryFeatures: ProcGetDeviceGroupPeerMemoryFeatures, - GetDeviceGroupPeerMemoryFeaturesKHR: ProcGetDeviceGroupPeerMemoryFeaturesKHR, - GetDeviceGroupPresentCapabilitiesKHR: ProcGetDeviceGroupPresentCapabilitiesKHR, - GetDeviceGroupSurfacePresentModes2EXT: ProcGetDeviceGroupSurfacePresentModes2EXT, - GetDeviceGroupSurfacePresentModesKHR: ProcGetDeviceGroupSurfacePresentModesKHR, - GetDeviceImageMemoryRequirements: ProcGetDeviceImageMemoryRequirements, - GetDeviceImageMemoryRequirementsKHR: ProcGetDeviceImageMemoryRequirementsKHR, - GetDeviceImageSparseMemoryRequirements: ProcGetDeviceImageSparseMemoryRequirements, - GetDeviceImageSparseMemoryRequirementsKHR: ProcGetDeviceImageSparseMemoryRequirementsKHR, - GetDeviceMemoryCommitment: ProcGetDeviceMemoryCommitment, - GetDeviceMemoryOpaqueCaptureAddress: ProcGetDeviceMemoryOpaqueCaptureAddress, - GetDeviceMemoryOpaqueCaptureAddressKHR: ProcGetDeviceMemoryOpaqueCaptureAddressKHR, - GetDeviceProcAddr: ProcGetDeviceProcAddr, - GetDeviceQueue: ProcGetDeviceQueue, - GetDeviceQueue2: ProcGetDeviceQueue2, - GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, - GetEventStatus: ProcGetEventStatus, - GetFenceFdKHR: ProcGetFenceFdKHR, - GetFenceStatus: ProcGetFenceStatus, - GetFenceWin32HandleKHR: ProcGetFenceWin32HandleKHR, - GetGeneratedCommandsMemoryRequirementsNV: ProcGetGeneratedCommandsMemoryRequirementsNV, - GetImageDrmFormatModifierPropertiesEXT: ProcGetImageDrmFormatModifierPropertiesEXT, - GetImageMemoryRequirements: ProcGetImageMemoryRequirements, - GetImageMemoryRequirements2: ProcGetImageMemoryRequirements2, - GetImageMemoryRequirements2KHR: ProcGetImageMemoryRequirements2KHR, - GetImageSparseMemoryRequirements: ProcGetImageSparseMemoryRequirements, - GetImageSparseMemoryRequirements2: ProcGetImageSparseMemoryRequirements2, - GetImageSparseMemoryRequirements2KHR: ProcGetImageSparseMemoryRequirements2KHR, - GetImageSubresourceLayout: ProcGetImageSubresourceLayout, - GetImageViewAddressNVX: ProcGetImageViewAddressNVX, - GetImageViewHandleNVX: ProcGetImageViewHandleNVX, - GetMemoryFdKHR: ProcGetMemoryFdKHR, - GetMemoryFdPropertiesKHR: ProcGetMemoryFdPropertiesKHR, - GetMemoryHostPointerPropertiesEXT: ProcGetMemoryHostPointerPropertiesEXT, - GetMemoryRemoteAddressNV: ProcGetMemoryRemoteAddressNV, - GetMemoryWin32HandleKHR: ProcGetMemoryWin32HandleKHR, - GetMemoryWin32HandleNV: ProcGetMemoryWin32HandleNV, - GetMemoryWin32HandlePropertiesKHR: ProcGetMemoryWin32HandlePropertiesKHR, - GetPastPresentationTimingGOOGLE: ProcGetPastPresentationTimingGOOGLE, - GetPerformanceParameterINTEL: ProcGetPerformanceParameterINTEL, - GetPipelineCacheData: ProcGetPipelineCacheData, - GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR, - GetPipelineExecutablePropertiesKHR: ProcGetPipelineExecutablePropertiesKHR, - GetPipelineExecutableStatisticsKHR: ProcGetPipelineExecutableStatisticsKHR, - GetPrivateData: ProcGetPrivateData, - GetPrivateDataEXT: ProcGetPrivateDataEXT, - GetQueryPoolResults: ProcGetQueryPoolResults, - GetQueueCheckpointData2NV: ProcGetQueueCheckpointData2NV, - GetQueueCheckpointDataNV: ProcGetQueueCheckpointDataNV, - GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR, - GetRayTracingShaderGroupHandlesKHR: ProcGetRayTracingShaderGroupHandlesKHR, - GetRayTracingShaderGroupHandlesNV: ProcGetRayTracingShaderGroupHandlesNV, - GetRayTracingShaderGroupStackSizeKHR: ProcGetRayTracingShaderGroupStackSizeKHR, - GetRefreshCycleDurationGOOGLE: ProcGetRefreshCycleDurationGOOGLE, - GetRenderAreaGranularity: ProcGetRenderAreaGranularity, - GetSemaphoreCounterValue: ProcGetSemaphoreCounterValue, - GetSemaphoreCounterValueKHR: ProcGetSemaphoreCounterValueKHR, - GetSemaphoreFdKHR: ProcGetSemaphoreFdKHR, - GetSemaphoreWin32HandleKHR: ProcGetSemaphoreWin32HandleKHR, - GetShaderInfoAMD: ProcGetShaderInfoAMD, - GetSwapchainCounterEXT: ProcGetSwapchainCounterEXT, - GetSwapchainImagesKHR: ProcGetSwapchainImagesKHR, - GetSwapchainStatusKHR: ProcGetSwapchainStatusKHR, - GetValidationCacheDataEXT: ProcGetValidationCacheDataEXT, - ImportFenceFdKHR: ProcImportFenceFdKHR, - ImportFenceWin32HandleKHR: ProcImportFenceWin32HandleKHR, - ImportSemaphoreFdKHR: ProcImportSemaphoreFdKHR, - ImportSemaphoreWin32HandleKHR: ProcImportSemaphoreWin32HandleKHR, - InitializePerformanceApiINTEL: ProcInitializePerformanceApiINTEL, - InvalidateMappedMemoryRanges: ProcInvalidateMappedMemoryRanges, - MapMemory: ProcMapMemory, - MergePipelineCaches: ProcMergePipelineCaches, - MergeValidationCachesEXT: ProcMergeValidationCachesEXT, - QueueBeginDebugUtilsLabelEXT: ProcQueueBeginDebugUtilsLabelEXT, - QueueBindSparse: ProcQueueBindSparse, - QueueEndDebugUtilsLabelEXT: ProcQueueEndDebugUtilsLabelEXT, - QueueInsertDebugUtilsLabelEXT: ProcQueueInsertDebugUtilsLabelEXT, - QueuePresentKHR: ProcQueuePresentKHR, - QueueSetPerformanceConfigurationINTEL: ProcQueueSetPerformanceConfigurationINTEL, - QueueSubmit: ProcQueueSubmit, - QueueSubmit2: ProcQueueSubmit2, - QueueSubmit2KHR: ProcQueueSubmit2KHR, - QueueWaitIdle: ProcQueueWaitIdle, - RegisterDeviceEventEXT: ProcRegisterDeviceEventEXT, - RegisterDisplayEventEXT: ProcRegisterDisplayEventEXT, - ReleaseFullScreenExclusiveModeEXT: ProcReleaseFullScreenExclusiveModeEXT, - ReleasePerformanceConfigurationINTEL: ProcReleasePerformanceConfigurationINTEL, - ReleaseProfilingLockKHR: ProcReleaseProfilingLockKHR, - ResetCommandBuffer: ProcResetCommandBuffer, - ResetCommandPool: ProcResetCommandPool, - ResetDescriptorPool: ProcResetDescriptorPool, - ResetEvent: ProcResetEvent, - ResetFences: ProcResetFences, - ResetQueryPool: ProcResetQueryPool, - ResetQueryPoolEXT: ProcResetQueryPoolEXT, - SetDebugUtilsObjectNameEXT: ProcSetDebugUtilsObjectNameEXT, - SetDebugUtilsObjectTagEXT: ProcSetDebugUtilsObjectTagEXT, - SetDeviceMemoryPriorityEXT: ProcSetDeviceMemoryPriorityEXT, - SetEvent: ProcSetEvent, - SetHdrMetadataEXT: ProcSetHdrMetadataEXT, - SetLocalDimmingAMD: ProcSetLocalDimmingAMD, - SetPrivateData: ProcSetPrivateData, - SetPrivateDataEXT: ProcSetPrivateDataEXT, - SignalSemaphore: ProcSignalSemaphore, - SignalSemaphoreKHR: ProcSignalSemaphoreKHR, - TrimCommandPool: ProcTrimCommandPool, - TrimCommandPoolKHR: ProcTrimCommandPoolKHR, - UninitializePerformanceApiINTEL: ProcUninitializePerformanceApiINTEL, - UnmapMemory: ProcUnmapMemory, - UpdateDescriptorSetWithTemplate: ProcUpdateDescriptorSetWithTemplate, - UpdateDescriptorSetWithTemplateKHR: ProcUpdateDescriptorSetWithTemplateKHR, - UpdateDescriptorSets: ProcUpdateDescriptorSets, - WaitForFences: ProcWaitForFences, - WaitForPresentKHR: ProcWaitForPresentKHR, - WaitSemaphores: ProcWaitSemaphores, - WaitSemaphoresKHR: ProcWaitSemaphoresKHR, - WriteAccelerationStructuresPropertiesKHR: ProcWriteAccelerationStructuresPropertiesKHR, + AcquireFullScreenExclusiveModeEXT: ProcAcquireFullScreenExclusiveModeEXT, + AcquireNextImage2KHR: ProcAcquireNextImage2KHR, + AcquireNextImageKHR: ProcAcquireNextImageKHR, + AcquirePerformanceConfigurationINTEL: ProcAcquirePerformanceConfigurationINTEL, + AcquireProfilingLockKHR: ProcAcquireProfilingLockKHR, + AllocateCommandBuffers: ProcAllocateCommandBuffers, + AllocateDescriptorSets: ProcAllocateDescriptorSets, + AllocateMemory: ProcAllocateMemory, + BeginCommandBuffer: ProcBeginCommandBuffer, + BindAccelerationStructureMemoryNV: ProcBindAccelerationStructureMemoryNV, + BindBufferMemory: ProcBindBufferMemory, + BindBufferMemory2: ProcBindBufferMemory2, + BindBufferMemory2KHR: ProcBindBufferMemory2KHR, + BindImageMemory: ProcBindImageMemory, + BindImageMemory2: ProcBindImageMemory2, + BindImageMemory2KHR: ProcBindImageMemory2KHR, + BindOpticalFlowSessionImageNV: ProcBindOpticalFlowSessionImageNV, + BindVideoSessionMemoryKHR: ProcBindVideoSessionMemoryKHR, + BuildAccelerationStructuresKHR: ProcBuildAccelerationStructuresKHR, + BuildMicromapsEXT: ProcBuildMicromapsEXT, + CmdBeginConditionalRenderingEXT: ProcCmdBeginConditionalRenderingEXT, + CmdBeginDebugUtilsLabelEXT: ProcCmdBeginDebugUtilsLabelEXT, + CmdBeginQuery: ProcCmdBeginQuery, + CmdBeginQueryIndexedEXT: ProcCmdBeginQueryIndexedEXT, + CmdBeginRenderPass: ProcCmdBeginRenderPass, + CmdBeginRenderPass2: ProcCmdBeginRenderPass2, + CmdBeginRenderPass2KHR: ProcCmdBeginRenderPass2KHR, + CmdBeginRendering: ProcCmdBeginRendering, + CmdBeginRenderingKHR: ProcCmdBeginRenderingKHR, + CmdBeginTransformFeedbackEXT: ProcCmdBeginTransformFeedbackEXT, + CmdBeginVideoCodingKHR: ProcCmdBeginVideoCodingKHR, + CmdBindDescriptorBufferEmbeddedSamplersEXT: ProcCmdBindDescriptorBufferEmbeddedSamplersEXT, + CmdBindDescriptorBuffersEXT: ProcCmdBindDescriptorBuffersEXT, + CmdBindDescriptorSets: ProcCmdBindDescriptorSets, + CmdBindIndexBuffer: ProcCmdBindIndexBuffer, + CmdBindInvocationMaskHUAWEI: ProcCmdBindInvocationMaskHUAWEI, + CmdBindPipeline: ProcCmdBindPipeline, + CmdBindPipelineShaderGroupNV: ProcCmdBindPipelineShaderGroupNV, + CmdBindShadersEXT: ProcCmdBindShadersEXT, + CmdBindShadingRateImageNV: ProcCmdBindShadingRateImageNV, + CmdBindTransformFeedbackBuffersEXT: ProcCmdBindTransformFeedbackBuffersEXT, + CmdBindVertexBuffers: ProcCmdBindVertexBuffers, + CmdBindVertexBuffers2: ProcCmdBindVertexBuffers2, + CmdBindVertexBuffers2EXT: ProcCmdBindVertexBuffers2EXT, + CmdBlitImage: ProcCmdBlitImage, + CmdBlitImage2: ProcCmdBlitImage2, + CmdBlitImage2KHR: ProcCmdBlitImage2KHR, + CmdBuildAccelerationStructureNV: ProcCmdBuildAccelerationStructureNV, + CmdBuildAccelerationStructuresIndirectKHR: ProcCmdBuildAccelerationStructuresIndirectKHR, + CmdBuildAccelerationStructuresKHR: ProcCmdBuildAccelerationStructuresKHR, + CmdBuildMicromapsEXT: ProcCmdBuildMicromapsEXT, + CmdClearAttachments: ProcCmdClearAttachments, + CmdClearColorImage: ProcCmdClearColorImage, + CmdClearDepthStencilImage: ProcCmdClearDepthStencilImage, + CmdControlVideoCodingKHR: ProcCmdControlVideoCodingKHR, + CmdCopyAccelerationStructureKHR: ProcCmdCopyAccelerationStructureKHR, + CmdCopyAccelerationStructureNV: ProcCmdCopyAccelerationStructureNV, + CmdCopyAccelerationStructureToMemoryKHR: ProcCmdCopyAccelerationStructureToMemoryKHR, + CmdCopyBuffer: ProcCmdCopyBuffer, + CmdCopyBuffer2: ProcCmdCopyBuffer2, + CmdCopyBuffer2KHR: ProcCmdCopyBuffer2KHR, + CmdCopyBufferToImage: ProcCmdCopyBufferToImage, + CmdCopyBufferToImage2: ProcCmdCopyBufferToImage2, + CmdCopyBufferToImage2KHR: ProcCmdCopyBufferToImage2KHR, + CmdCopyImage: ProcCmdCopyImage, + CmdCopyImage2: ProcCmdCopyImage2, + CmdCopyImage2KHR: ProcCmdCopyImage2KHR, + CmdCopyImageToBuffer: ProcCmdCopyImageToBuffer, + CmdCopyImageToBuffer2: ProcCmdCopyImageToBuffer2, + CmdCopyImageToBuffer2KHR: ProcCmdCopyImageToBuffer2KHR, + CmdCopyMemoryIndirectNV: ProcCmdCopyMemoryIndirectNV, + CmdCopyMemoryToAccelerationStructureKHR: ProcCmdCopyMemoryToAccelerationStructureKHR, + CmdCopyMemoryToImageIndirectNV: ProcCmdCopyMemoryToImageIndirectNV, + CmdCopyMemoryToMicromapEXT: ProcCmdCopyMemoryToMicromapEXT, + CmdCopyMicromapEXT: ProcCmdCopyMicromapEXT, + CmdCopyMicromapToMemoryEXT: ProcCmdCopyMicromapToMemoryEXT, + CmdCopyQueryPoolResults: ProcCmdCopyQueryPoolResults, + CmdCuLaunchKernelNVX: ProcCmdCuLaunchKernelNVX, + CmdDebugMarkerBeginEXT: ProcCmdDebugMarkerBeginEXT, + CmdDebugMarkerEndEXT: ProcCmdDebugMarkerEndEXT, + CmdDebugMarkerInsertEXT: ProcCmdDebugMarkerInsertEXT, + CmdDecodeVideoKHR: ProcCmdDecodeVideoKHR, + CmdDecompressMemoryIndirectCountNV: ProcCmdDecompressMemoryIndirectCountNV, + CmdDecompressMemoryNV: ProcCmdDecompressMemoryNV, + CmdDispatch: ProcCmdDispatch, + CmdDispatchBase: ProcCmdDispatchBase, + CmdDispatchBaseKHR: ProcCmdDispatchBaseKHR, + CmdDispatchIndirect: ProcCmdDispatchIndirect, + CmdDraw: ProcCmdDraw, + CmdDrawClusterHUAWEI: ProcCmdDrawClusterHUAWEI, + CmdDrawClusterIndirectHUAWEI: ProcCmdDrawClusterIndirectHUAWEI, + CmdDrawIndexed: ProcCmdDrawIndexed, + CmdDrawIndexedIndirect: ProcCmdDrawIndexedIndirect, + CmdDrawIndexedIndirectCount: ProcCmdDrawIndexedIndirectCount, + CmdDrawIndexedIndirectCountAMD: ProcCmdDrawIndexedIndirectCountAMD, + CmdDrawIndexedIndirectCountKHR: ProcCmdDrawIndexedIndirectCountKHR, + CmdDrawIndirect: ProcCmdDrawIndirect, + CmdDrawIndirectByteCountEXT: ProcCmdDrawIndirectByteCountEXT, + CmdDrawIndirectCount: ProcCmdDrawIndirectCount, + CmdDrawIndirectCountAMD: ProcCmdDrawIndirectCountAMD, + CmdDrawIndirectCountKHR: ProcCmdDrawIndirectCountKHR, + CmdDrawMeshTasksEXT: ProcCmdDrawMeshTasksEXT, + CmdDrawMeshTasksIndirectCountEXT: ProcCmdDrawMeshTasksIndirectCountEXT, + CmdDrawMeshTasksIndirectCountNV: ProcCmdDrawMeshTasksIndirectCountNV, + CmdDrawMeshTasksIndirectEXT: ProcCmdDrawMeshTasksIndirectEXT, + CmdDrawMeshTasksIndirectNV: ProcCmdDrawMeshTasksIndirectNV, + CmdDrawMeshTasksNV: ProcCmdDrawMeshTasksNV, + CmdDrawMultiEXT: ProcCmdDrawMultiEXT, + CmdDrawMultiIndexedEXT: ProcCmdDrawMultiIndexedEXT, + CmdEndConditionalRenderingEXT: ProcCmdEndConditionalRenderingEXT, + CmdEndDebugUtilsLabelEXT: ProcCmdEndDebugUtilsLabelEXT, + CmdEndQuery: ProcCmdEndQuery, + CmdEndQueryIndexedEXT: ProcCmdEndQueryIndexedEXT, + CmdEndRenderPass: ProcCmdEndRenderPass, + CmdEndRenderPass2: ProcCmdEndRenderPass2, + CmdEndRenderPass2KHR: ProcCmdEndRenderPass2KHR, + CmdEndRendering: ProcCmdEndRendering, + CmdEndRenderingKHR: ProcCmdEndRenderingKHR, + CmdEndTransformFeedbackEXT: ProcCmdEndTransformFeedbackEXT, + CmdEndVideoCodingKHR: ProcCmdEndVideoCodingKHR, + CmdExecuteCommands: ProcCmdExecuteCommands, + CmdExecuteGeneratedCommandsNV: ProcCmdExecuteGeneratedCommandsNV, + CmdFillBuffer: ProcCmdFillBuffer, + CmdInsertDebugUtilsLabelEXT: ProcCmdInsertDebugUtilsLabelEXT, + CmdNextSubpass: ProcCmdNextSubpass, + CmdNextSubpass2: ProcCmdNextSubpass2, + CmdNextSubpass2KHR: ProcCmdNextSubpass2KHR, + CmdOpticalFlowExecuteNV: ProcCmdOpticalFlowExecuteNV, + CmdPipelineBarrier: ProcCmdPipelineBarrier, + CmdPipelineBarrier2: ProcCmdPipelineBarrier2, + CmdPipelineBarrier2KHR: ProcCmdPipelineBarrier2KHR, + CmdPreprocessGeneratedCommandsNV: ProcCmdPreprocessGeneratedCommandsNV, + CmdPushConstants: ProcCmdPushConstants, + CmdPushDescriptorSetKHR: ProcCmdPushDescriptorSetKHR, + CmdPushDescriptorSetWithTemplateKHR: ProcCmdPushDescriptorSetWithTemplateKHR, + CmdResetEvent: ProcCmdResetEvent, + CmdResetEvent2: ProcCmdResetEvent2, + CmdResetEvent2KHR: ProcCmdResetEvent2KHR, + CmdResetQueryPool: ProcCmdResetQueryPool, + CmdResolveImage: ProcCmdResolveImage, + CmdResolveImage2: ProcCmdResolveImage2, + CmdResolveImage2KHR: ProcCmdResolveImage2KHR, + CmdSetAlphaToCoverageEnableEXT: ProcCmdSetAlphaToCoverageEnableEXT, + CmdSetAlphaToOneEnableEXT: ProcCmdSetAlphaToOneEnableEXT, + CmdSetAttachmentFeedbackLoopEnableEXT: ProcCmdSetAttachmentFeedbackLoopEnableEXT, + CmdSetBlendConstants: ProcCmdSetBlendConstants, + CmdSetCheckpointNV: ProcCmdSetCheckpointNV, + CmdSetCoarseSampleOrderNV: ProcCmdSetCoarseSampleOrderNV, + CmdSetColorBlendAdvancedEXT: ProcCmdSetColorBlendAdvancedEXT, + CmdSetColorBlendEnableEXT: ProcCmdSetColorBlendEnableEXT, + CmdSetColorBlendEquationEXT: ProcCmdSetColorBlendEquationEXT, + CmdSetColorWriteMaskEXT: ProcCmdSetColorWriteMaskEXT, + CmdSetConservativeRasterizationModeEXT: ProcCmdSetConservativeRasterizationModeEXT, + CmdSetCoverageModulationModeNV: ProcCmdSetCoverageModulationModeNV, + CmdSetCoverageModulationTableEnableNV: ProcCmdSetCoverageModulationTableEnableNV, + CmdSetCoverageModulationTableNV: ProcCmdSetCoverageModulationTableNV, + CmdSetCoverageReductionModeNV: ProcCmdSetCoverageReductionModeNV, + CmdSetCoverageToColorEnableNV: ProcCmdSetCoverageToColorEnableNV, + CmdSetCoverageToColorLocationNV: ProcCmdSetCoverageToColorLocationNV, + CmdSetCullMode: ProcCmdSetCullMode, + CmdSetCullModeEXT: ProcCmdSetCullModeEXT, + CmdSetDepthBias: ProcCmdSetDepthBias, + CmdSetDepthBiasEnable: ProcCmdSetDepthBiasEnable, + CmdSetDepthBiasEnableEXT: ProcCmdSetDepthBiasEnableEXT, + CmdSetDepthBounds: ProcCmdSetDepthBounds, + CmdSetDepthBoundsTestEnable: ProcCmdSetDepthBoundsTestEnable, + CmdSetDepthBoundsTestEnableEXT: ProcCmdSetDepthBoundsTestEnableEXT, + CmdSetDepthClampEnableEXT: ProcCmdSetDepthClampEnableEXT, + CmdSetDepthClipEnableEXT: ProcCmdSetDepthClipEnableEXT, + CmdSetDepthClipNegativeOneToOneEXT: ProcCmdSetDepthClipNegativeOneToOneEXT, + CmdSetDepthCompareOp: ProcCmdSetDepthCompareOp, + CmdSetDepthCompareOpEXT: ProcCmdSetDepthCompareOpEXT, + CmdSetDepthTestEnable: ProcCmdSetDepthTestEnable, + CmdSetDepthTestEnableEXT: ProcCmdSetDepthTestEnableEXT, + CmdSetDepthWriteEnable: ProcCmdSetDepthWriteEnable, + CmdSetDepthWriteEnableEXT: ProcCmdSetDepthWriteEnableEXT, + CmdSetDescriptorBufferOffsetsEXT: ProcCmdSetDescriptorBufferOffsetsEXT, + CmdSetDeviceMask: ProcCmdSetDeviceMask, + CmdSetDeviceMaskKHR: ProcCmdSetDeviceMaskKHR, + CmdSetDiscardRectangleEXT: ProcCmdSetDiscardRectangleEXT, + CmdSetDiscardRectangleEnableEXT: ProcCmdSetDiscardRectangleEnableEXT, + CmdSetDiscardRectangleModeEXT: ProcCmdSetDiscardRectangleModeEXT, + CmdSetEvent: ProcCmdSetEvent, + CmdSetEvent2: ProcCmdSetEvent2, + CmdSetEvent2KHR: ProcCmdSetEvent2KHR, + CmdSetExclusiveScissorEnableNV: ProcCmdSetExclusiveScissorEnableNV, + CmdSetExclusiveScissorNV: ProcCmdSetExclusiveScissorNV, + CmdSetExtraPrimitiveOverestimationSizeEXT: ProcCmdSetExtraPrimitiveOverestimationSizeEXT, + CmdSetFragmentShadingRateEnumNV: ProcCmdSetFragmentShadingRateEnumNV, + CmdSetFragmentShadingRateKHR: ProcCmdSetFragmentShadingRateKHR, + CmdSetFrontFace: ProcCmdSetFrontFace, + CmdSetFrontFaceEXT: ProcCmdSetFrontFaceEXT, + CmdSetLineRasterizationModeEXT: ProcCmdSetLineRasterizationModeEXT, + CmdSetLineStippleEXT: ProcCmdSetLineStippleEXT, + CmdSetLineStippleEnableEXT: ProcCmdSetLineStippleEnableEXT, + CmdSetLineWidth: ProcCmdSetLineWidth, + CmdSetLogicOpEXT: ProcCmdSetLogicOpEXT, + CmdSetLogicOpEnableEXT: ProcCmdSetLogicOpEnableEXT, + CmdSetPatchControlPointsEXT: ProcCmdSetPatchControlPointsEXT, + CmdSetPerformanceMarkerINTEL: ProcCmdSetPerformanceMarkerINTEL, + CmdSetPerformanceOverrideINTEL: ProcCmdSetPerformanceOverrideINTEL, + CmdSetPerformanceStreamMarkerINTEL: ProcCmdSetPerformanceStreamMarkerINTEL, + CmdSetPolygonModeEXT: ProcCmdSetPolygonModeEXT, + CmdSetPrimitiveRestartEnable: ProcCmdSetPrimitiveRestartEnable, + CmdSetPrimitiveRestartEnableEXT: ProcCmdSetPrimitiveRestartEnableEXT, + CmdSetPrimitiveTopology: ProcCmdSetPrimitiveTopology, + CmdSetPrimitiveTopologyEXT: ProcCmdSetPrimitiveTopologyEXT, + CmdSetProvokingVertexModeEXT: ProcCmdSetProvokingVertexModeEXT, + CmdSetRasterizationSamplesEXT: ProcCmdSetRasterizationSamplesEXT, + CmdSetRasterizationStreamEXT: ProcCmdSetRasterizationStreamEXT, + CmdSetRasterizerDiscardEnable: ProcCmdSetRasterizerDiscardEnable, + CmdSetRasterizerDiscardEnableEXT: ProcCmdSetRasterizerDiscardEnableEXT, + CmdSetRayTracingPipelineStackSizeKHR: ProcCmdSetRayTracingPipelineStackSizeKHR, + CmdSetRepresentativeFragmentTestEnableNV: ProcCmdSetRepresentativeFragmentTestEnableNV, + CmdSetSampleLocationsEXT: ProcCmdSetSampleLocationsEXT, + CmdSetSampleLocationsEnableEXT: ProcCmdSetSampleLocationsEnableEXT, + CmdSetSampleMaskEXT: ProcCmdSetSampleMaskEXT, + CmdSetScissor: ProcCmdSetScissor, + CmdSetScissorWithCount: ProcCmdSetScissorWithCount, + CmdSetScissorWithCountEXT: ProcCmdSetScissorWithCountEXT, + CmdSetShadingRateImageEnableNV: ProcCmdSetShadingRateImageEnableNV, + CmdSetStencilCompareMask: ProcCmdSetStencilCompareMask, + CmdSetStencilOp: ProcCmdSetStencilOp, + CmdSetStencilOpEXT: ProcCmdSetStencilOpEXT, + CmdSetStencilReference: ProcCmdSetStencilReference, + CmdSetStencilTestEnable: ProcCmdSetStencilTestEnable, + CmdSetStencilTestEnableEXT: ProcCmdSetStencilTestEnableEXT, + CmdSetStencilWriteMask: ProcCmdSetStencilWriteMask, + CmdSetTessellationDomainOriginEXT: ProcCmdSetTessellationDomainOriginEXT, + CmdSetVertexInputEXT: ProcCmdSetVertexInputEXT, + CmdSetViewport: ProcCmdSetViewport, + CmdSetViewportShadingRatePaletteNV: ProcCmdSetViewportShadingRatePaletteNV, + CmdSetViewportSwizzleNV: ProcCmdSetViewportSwizzleNV, + CmdSetViewportWScalingEnableNV: ProcCmdSetViewportWScalingEnableNV, + CmdSetViewportWScalingNV: ProcCmdSetViewportWScalingNV, + CmdSetViewportWithCount: ProcCmdSetViewportWithCount, + CmdSetViewportWithCountEXT: ProcCmdSetViewportWithCountEXT, + CmdSubpassShadingHUAWEI: ProcCmdSubpassShadingHUAWEI, + CmdTraceRaysIndirect2KHR: ProcCmdTraceRaysIndirect2KHR, + CmdTraceRaysIndirectKHR: ProcCmdTraceRaysIndirectKHR, + CmdTraceRaysKHR: ProcCmdTraceRaysKHR, + CmdTraceRaysNV: ProcCmdTraceRaysNV, + CmdUpdateBuffer: ProcCmdUpdateBuffer, + CmdWaitEvents: ProcCmdWaitEvents, + CmdWaitEvents2: ProcCmdWaitEvents2, + CmdWaitEvents2KHR: ProcCmdWaitEvents2KHR, + CmdWriteAccelerationStructuresPropertiesKHR: ProcCmdWriteAccelerationStructuresPropertiesKHR, + CmdWriteAccelerationStructuresPropertiesNV: ProcCmdWriteAccelerationStructuresPropertiesNV, + CmdWriteBufferMarker2AMD: ProcCmdWriteBufferMarker2AMD, + CmdWriteBufferMarkerAMD: ProcCmdWriteBufferMarkerAMD, + CmdWriteMicromapsPropertiesEXT: ProcCmdWriteMicromapsPropertiesEXT, + CmdWriteTimestamp: ProcCmdWriteTimestamp, + CmdWriteTimestamp2: ProcCmdWriteTimestamp2, + CmdWriteTimestamp2KHR: ProcCmdWriteTimestamp2KHR, + CompileDeferredNV: ProcCompileDeferredNV, + CopyAccelerationStructureKHR: ProcCopyAccelerationStructureKHR, + CopyAccelerationStructureToMemoryKHR: ProcCopyAccelerationStructureToMemoryKHR, + CopyMemoryToAccelerationStructureKHR: ProcCopyMemoryToAccelerationStructureKHR, + CopyMemoryToMicromapEXT: ProcCopyMemoryToMicromapEXT, + CopyMicromapEXT: ProcCopyMicromapEXT, + CopyMicromapToMemoryEXT: ProcCopyMicromapToMemoryEXT, + CreateAccelerationStructureKHR: ProcCreateAccelerationStructureKHR, + CreateAccelerationStructureNV: ProcCreateAccelerationStructureNV, + CreateBuffer: ProcCreateBuffer, + CreateBufferView: ProcCreateBufferView, + CreateCommandPool: ProcCreateCommandPool, + CreateComputePipelines: ProcCreateComputePipelines, + CreateCuFunctionNVX: ProcCreateCuFunctionNVX, + CreateCuModuleNVX: ProcCreateCuModuleNVX, + CreateDeferredOperationKHR: ProcCreateDeferredOperationKHR, + CreateDescriptorPool: ProcCreateDescriptorPool, + CreateDescriptorSetLayout: ProcCreateDescriptorSetLayout, + CreateDescriptorUpdateTemplate: ProcCreateDescriptorUpdateTemplate, + CreateDescriptorUpdateTemplateKHR: ProcCreateDescriptorUpdateTemplateKHR, + CreateEvent: ProcCreateEvent, + CreateFence: ProcCreateFence, + CreateFramebuffer: ProcCreateFramebuffer, + CreateGraphicsPipelines: ProcCreateGraphicsPipelines, + CreateImage: ProcCreateImage, + CreateImageView: ProcCreateImageView, + CreateIndirectCommandsLayoutNV: ProcCreateIndirectCommandsLayoutNV, + CreateMicromapEXT: ProcCreateMicromapEXT, + CreateOpticalFlowSessionNV: ProcCreateOpticalFlowSessionNV, + CreatePipelineCache: ProcCreatePipelineCache, + CreatePipelineLayout: ProcCreatePipelineLayout, + CreatePrivateDataSlot: ProcCreatePrivateDataSlot, + CreatePrivateDataSlotEXT: ProcCreatePrivateDataSlotEXT, + CreateQueryPool: ProcCreateQueryPool, + CreateRayTracingPipelinesKHR: ProcCreateRayTracingPipelinesKHR, + CreateRayTracingPipelinesNV: ProcCreateRayTracingPipelinesNV, + CreateRenderPass: ProcCreateRenderPass, + CreateRenderPass2: ProcCreateRenderPass2, + CreateRenderPass2KHR: ProcCreateRenderPass2KHR, + CreateSampler: ProcCreateSampler, + CreateSamplerYcbcrConversion: ProcCreateSamplerYcbcrConversion, + CreateSamplerYcbcrConversionKHR: ProcCreateSamplerYcbcrConversionKHR, + CreateSemaphore: ProcCreateSemaphore, + CreateShaderModule: ProcCreateShaderModule, + CreateShadersEXT: ProcCreateShadersEXT, + CreateSharedSwapchainsKHR: ProcCreateSharedSwapchainsKHR, + CreateSwapchainKHR: ProcCreateSwapchainKHR, + CreateValidationCacheEXT: ProcCreateValidationCacheEXT, + CreateVideoSessionKHR: ProcCreateVideoSessionKHR, + CreateVideoSessionParametersKHR: ProcCreateVideoSessionParametersKHR, + DebugMarkerSetObjectNameEXT: ProcDebugMarkerSetObjectNameEXT, + DebugMarkerSetObjectTagEXT: ProcDebugMarkerSetObjectTagEXT, + DeferredOperationJoinKHR: ProcDeferredOperationJoinKHR, + DestroyAccelerationStructureKHR: ProcDestroyAccelerationStructureKHR, + DestroyAccelerationStructureNV: ProcDestroyAccelerationStructureNV, + DestroyBuffer: ProcDestroyBuffer, + DestroyBufferView: ProcDestroyBufferView, + DestroyCommandPool: ProcDestroyCommandPool, + DestroyCuFunctionNVX: ProcDestroyCuFunctionNVX, + DestroyCuModuleNVX: ProcDestroyCuModuleNVX, + DestroyDeferredOperationKHR: ProcDestroyDeferredOperationKHR, + DestroyDescriptorPool: ProcDestroyDescriptorPool, + DestroyDescriptorSetLayout: ProcDestroyDescriptorSetLayout, + DestroyDescriptorUpdateTemplate: ProcDestroyDescriptorUpdateTemplate, + DestroyDescriptorUpdateTemplateKHR: ProcDestroyDescriptorUpdateTemplateKHR, + DestroyDevice: ProcDestroyDevice, + DestroyEvent: ProcDestroyEvent, + DestroyFence: ProcDestroyFence, + DestroyFramebuffer: ProcDestroyFramebuffer, + DestroyImage: ProcDestroyImage, + DestroyImageView: ProcDestroyImageView, + DestroyIndirectCommandsLayoutNV: ProcDestroyIndirectCommandsLayoutNV, + DestroyMicromapEXT: ProcDestroyMicromapEXT, + DestroyOpticalFlowSessionNV: ProcDestroyOpticalFlowSessionNV, + DestroyPipeline: ProcDestroyPipeline, + DestroyPipelineCache: ProcDestroyPipelineCache, + DestroyPipelineLayout: ProcDestroyPipelineLayout, + DestroyPrivateDataSlot: ProcDestroyPrivateDataSlot, + DestroyPrivateDataSlotEXT: ProcDestroyPrivateDataSlotEXT, + DestroyQueryPool: ProcDestroyQueryPool, + DestroyRenderPass: ProcDestroyRenderPass, + DestroySampler: ProcDestroySampler, + DestroySamplerYcbcrConversion: ProcDestroySamplerYcbcrConversion, + DestroySamplerYcbcrConversionKHR: ProcDestroySamplerYcbcrConversionKHR, + DestroySemaphore: ProcDestroySemaphore, + DestroyShaderEXT: ProcDestroyShaderEXT, + DestroyShaderModule: ProcDestroyShaderModule, + DestroySwapchainKHR: ProcDestroySwapchainKHR, + DestroyValidationCacheEXT: ProcDestroyValidationCacheEXT, + DestroyVideoSessionKHR: ProcDestroyVideoSessionKHR, + DestroyVideoSessionParametersKHR: ProcDestroyVideoSessionParametersKHR, + DeviceWaitIdle: ProcDeviceWaitIdle, + DisplayPowerControlEXT: ProcDisplayPowerControlEXT, + EndCommandBuffer: ProcEndCommandBuffer, + ExportMetalObjectsEXT: ProcExportMetalObjectsEXT, + FlushMappedMemoryRanges: ProcFlushMappedMemoryRanges, + FreeCommandBuffers: ProcFreeCommandBuffers, + FreeDescriptorSets: ProcFreeDescriptorSets, + FreeMemory: ProcFreeMemory, + GetAccelerationStructureBuildSizesKHR: ProcGetAccelerationStructureBuildSizesKHR, + GetAccelerationStructureDeviceAddressKHR: ProcGetAccelerationStructureDeviceAddressKHR, + GetAccelerationStructureHandleNV: ProcGetAccelerationStructureHandleNV, + GetAccelerationStructureMemoryRequirementsNV: ProcGetAccelerationStructureMemoryRequirementsNV, + GetAccelerationStructureOpaqueCaptureDescriptorDataEXT: ProcGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, + GetBufferDeviceAddress: ProcGetBufferDeviceAddress, + GetBufferDeviceAddressEXT: ProcGetBufferDeviceAddressEXT, + GetBufferDeviceAddressKHR: ProcGetBufferDeviceAddressKHR, + GetBufferMemoryRequirements: ProcGetBufferMemoryRequirements, + GetBufferMemoryRequirements2: ProcGetBufferMemoryRequirements2, + GetBufferMemoryRequirements2KHR: ProcGetBufferMemoryRequirements2KHR, + GetBufferOpaqueCaptureAddress: ProcGetBufferOpaqueCaptureAddress, + GetBufferOpaqueCaptureAddressKHR: ProcGetBufferOpaqueCaptureAddressKHR, + GetBufferOpaqueCaptureDescriptorDataEXT: ProcGetBufferOpaqueCaptureDescriptorDataEXT, + GetCalibratedTimestampsEXT: ProcGetCalibratedTimestampsEXT, + GetDeferredOperationMaxConcurrencyKHR: ProcGetDeferredOperationMaxConcurrencyKHR, + GetDeferredOperationResultKHR: ProcGetDeferredOperationResultKHR, + GetDescriptorEXT: ProcGetDescriptorEXT, + GetDescriptorSetHostMappingVALVE: ProcGetDescriptorSetHostMappingVALVE, + GetDescriptorSetLayoutBindingOffsetEXT: ProcGetDescriptorSetLayoutBindingOffsetEXT, + GetDescriptorSetLayoutHostMappingInfoVALVE: ProcGetDescriptorSetLayoutHostMappingInfoVALVE, + GetDescriptorSetLayoutSizeEXT: ProcGetDescriptorSetLayoutSizeEXT, + GetDescriptorSetLayoutSupport: ProcGetDescriptorSetLayoutSupport, + GetDescriptorSetLayoutSupportKHR: ProcGetDescriptorSetLayoutSupportKHR, + GetDeviceAccelerationStructureCompatibilityKHR: ProcGetDeviceAccelerationStructureCompatibilityKHR, + GetDeviceBufferMemoryRequirements: ProcGetDeviceBufferMemoryRequirements, + GetDeviceBufferMemoryRequirementsKHR: ProcGetDeviceBufferMemoryRequirementsKHR, + GetDeviceFaultInfoEXT: ProcGetDeviceFaultInfoEXT, + GetDeviceGroupPeerMemoryFeatures: ProcGetDeviceGroupPeerMemoryFeatures, + GetDeviceGroupPeerMemoryFeaturesKHR: ProcGetDeviceGroupPeerMemoryFeaturesKHR, + GetDeviceGroupPresentCapabilitiesKHR: ProcGetDeviceGroupPresentCapabilitiesKHR, + GetDeviceGroupSurfacePresentModes2EXT: ProcGetDeviceGroupSurfacePresentModes2EXT, + GetDeviceGroupSurfacePresentModesKHR: ProcGetDeviceGroupSurfacePresentModesKHR, + GetDeviceImageMemoryRequirements: ProcGetDeviceImageMemoryRequirements, + GetDeviceImageMemoryRequirementsKHR: ProcGetDeviceImageMemoryRequirementsKHR, + GetDeviceImageSparseMemoryRequirements: ProcGetDeviceImageSparseMemoryRequirements, + GetDeviceImageSparseMemoryRequirementsKHR: ProcGetDeviceImageSparseMemoryRequirementsKHR, + GetDeviceMemoryCommitment: ProcGetDeviceMemoryCommitment, + GetDeviceMemoryOpaqueCaptureAddress: ProcGetDeviceMemoryOpaqueCaptureAddress, + GetDeviceMemoryOpaqueCaptureAddressKHR: ProcGetDeviceMemoryOpaqueCaptureAddressKHR, + GetDeviceMicromapCompatibilityEXT: ProcGetDeviceMicromapCompatibilityEXT, + GetDeviceProcAddr: ProcGetDeviceProcAddr, + GetDeviceQueue: ProcGetDeviceQueue, + GetDeviceQueue2: ProcGetDeviceQueue2, + GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + GetDynamicRenderingTilePropertiesQCOM: ProcGetDynamicRenderingTilePropertiesQCOM, + GetEventStatus: ProcGetEventStatus, + GetFenceFdKHR: ProcGetFenceFdKHR, + GetFenceStatus: ProcGetFenceStatus, + GetFenceWin32HandleKHR: ProcGetFenceWin32HandleKHR, + GetFramebufferTilePropertiesQCOM: ProcGetFramebufferTilePropertiesQCOM, + GetGeneratedCommandsMemoryRequirementsNV: ProcGetGeneratedCommandsMemoryRequirementsNV, + GetImageDrmFormatModifierPropertiesEXT: ProcGetImageDrmFormatModifierPropertiesEXT, + GetImageMemoryRequirements: ProcGetImageMemoryRequirements, + GetImageMemoryRequirements2: ProcGetImageMemoryRequirements2, + GetImageMemoryRequirements2KHR: ProcGetImageMemoryRequirements2KHR, + GetImageOpaqueCaptureDescriptorDataEXT: ProcGetImageOpaqueCaptureDescriptorDataEXT, + GetImageSparseMemoryRequirements: ProcGetImageSparseMemoryRequirements, + GetImageSparseMemoryRequirements2: ProcGetImageSparseMemoryRequirements2, + GetImageSparseMemoryRequirements2KHR: ProcGetImageSparseMemoryRequirements2KHR, + GetImageSubresourceLayout: ProcGetImageSubresourceLayout, + GetImageSubresourceLayout2EXT: ProcGetImageSubresourceLayout2EXT, + GetImageViewAddressNVX: ProcGetImageViewAddressNVX, + GetImageViewHandleNVX: ProcGetImageViewHandleNVX, + GetImageViewOpaqueCaptureDescriptorDataEXT: ProcGetImageViewOpaqueCaptureDescriptorDataEXT, + GetMemoryFdKHR: ProcGetMemoryFdKHR, + GetMemoryFdPropertiesKHR: ProcGetMemoryFdPropertiesKHR, + GetMemoryHostPointerPropertiesEXT: ProcGetMemoryHostPointerPropertiesEXT, + GetMemoryRemoteAddressNV: ProcGetMemoryRemoteAddressNV, + GetMemoryWin32HandleKHR: ProcGetMemoryWin32HandleKHR, + GetMemoryWin32HandleNV: ProcGetMemoryWin32HandleNV, + GetMemoryWin32HandlePropertiesKHR: ProcGetMemoryWin32HandlePropertiesKHR, + GetMicromapBuildSizesEXT: ProcGetMicromapBuildSizesEXT, + GetPastPresentationTimingGOOGLE: ProcGetPastPresentationTimingGOOGLE, + GetPerformanceParameterINTEL: ProcGetPerformanceParameterINTEL, + GetPipelineCacheData: ProcGetPipelineCacheData, + GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR, + GetPipelineExecutablePropertiesKHR: ProcGetPipelineExecutablePropertiesKHR, + GetPipelineExecutableStatisticsKHR: ProcGetPipelineExecutableStatisticsKHR, + GetPipelinePropertiesEXT: ProcGetPipelinePropertiesEXT, + GetPrivateData: ProcGetPrivateData, + GetPrivateDataEXT: ProcGetPrivateDataEXT, + GetQueryPoolResults: ProcGetQueryPoolResults, + GetQueueCheckpointData2NV: ProcGetQueueCheckpointData2NV, + GetQueueCheckpointDataNV: ProcGetQueueCheckpointDataNV, + GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR, + GetRayTracingShaderGroupHandlesKHR: ProcGetRayTracingShaderGroupHandlesKHR, + GetRayTracingShaderGroupHandlesNV: ProcGetRayTracingShaderGroupHandlesNV, + GetRayTracingShaderGroupStackSizeKHR: ProcGetRayTracingShaderGroupStackSizeKHR, + GetRefreshCycleDurationGOOGLE: ProcGetRefreshCycleDurationGOOGLE, + GetRenderAreaGranularity: ProcGetRenderAreaGranularity, + GetSamplerOpaqueCaptureDescriptorDataEXT: ProcGetSamplerOpaqueCaptureDescriptorDataEXT, + GetSemaphoreCounterValue: ProcGetSemaphoreCounterValue, + GetSemaphoreCounterValueKHR: ProcGetSemaphoreCounterValueKHR, + GetSemaphoreFdKHR: ProcGetSemaphoreFdKHR, + GetSemaphoreWin32HandleKHR: ProcGetSemaphoreWin32HandleKHR, + GetShaderBinaryDataEXT: ProcGetShaderBinaryDataEXT, + GetShaderInfoAMD: ProcGetShaderInfoAMD, + GetShaderModuleCreateInfoIdentifierEXT: ProcGetShaderModuleCreateInfoIdentifierEXT, + GetShaderModuleIdentifierEXT: ProcGetShaderModuleIdentifierEXT, + GetSwapchainCounterEXT: ProcGetSwapchainCounterEXT, + GetSwapchainImagesKHR: ProcGetSwapchainImagesKHR, + GetSwapchainStatusKHR: ProcGetSwapchainStatusKHR, + GetValidationCacheDataEXT: ProcGetValidationCacheDataEXT, + GetVideoSessionMemoryRequirementsKHR: ProcGetVideoSessionMemoryRequirementsKHR, + ImportFenceFdKHR: ProcImportFenceFdKHR, + ImportFenceWin32HandleKHR: ProcImportFenceWin32HandleKHR, + ImportSemaphoreFdKHR: ProcImportSemaphoreFdKHR, + ImportSemaphoreWin32HandleKHR: ProcImportSemaphoreWin32HandleKHR, + InitializePerformanceApiINTEL: ProcInitializePerformanceApiINTEL, + InvalidateMappedMemoryRanges: ProcInvalidateMappedMemoryRanges, + MapMemory: ProcMapMemory, + MapMemory2KHR: ProcMapMemory2KHR, + MergePipelineCaches: ProcMergePipelineCaches, + MergeValidationCachesEXT: ProcMergeValidationCachesEXT, + QueueBeginDebugUtilsLabelEXT: ProcQueueBeginDebugUtilsLabelEXT, + QueueBindSparse: ProcQueueBindSparse, + QueueEndDebugUtilsLabelEXT: ProcQueueEndDebugUtilsLabelEXT, + QueueInsertDebugUtilsLabelEXT: ProcQueueInsertDebugUtilsLabelEXT, + QueuePresentKHR: ProcQueuePresentKHR, + QueueSetPerformanceConfigurationINTEL: ProcQueueSetPerformanceConfigurationINTEL, + QueueSubmit: ProcQueueSubmit, + QueueSubmit2: ProcQueueSubmit2, + QueueSubmit2KHR: ProcQueueSubmit2KHR, + QueueWaitIdle: ProcQueueWaitIdle, + RegisterDeviceEventEXT: ProcRegisterDeviceEventEXT, + RegisterDisplayEventEXT: ProcRegisterDisplayEventEXT, + ReleaseFullScreenExclusiveModeEXT: ProcReleaseFullScreenExclusiveModeEXT, + ReleasePerformanceConfigurationINTEL: ProcReleasePerformanceConfigurationINTEL, + ReleaseProfilingLockKHR: ProcReleaseProfilingLockKHR, + ReleaseSwapchainImagesEXT: ProcReleaseSwapchainImagesEXT, + ResetCommandBuffer: ProcResetCommandBuffer, + ResetCommandPool: ProcResetCommandPool, + ResetDescriptorPool: ProcResetDescriptorPool, + ResetEvent: ProcResetEvent, + ResetFences: ProcResetFences, + ResetQueryPool: ProcResetQueryPool, + ResetQueryPoolEXT: ProcResetQueryPoolEXT, + SetDebugUtilsObjectNameEXT: ProcSetDebugUtilsObjectNameEXT, + SetDebugUtilsObjectTagEXT: ProcSetDebugUtilsObjectTagEXT, + SetDeviceMemoryPriorityEXT: ProcSetDeviceMemoryPriorityEXT, + SetEvent: ProcSetEvent, + SetHdrMetadataEXT: ProcSetHdrMetadataEXT, + SetLocalDimmingAMD: ProcSetLocalDimmingAMD, + SetPrivateData: ProcSetPrivateData, + SetPrivateDataEXT: ProcSetPrivateDataEXT, + SignalSemaphore: ProcSignalSemaphore, + SignalSemaphoreKHR: ProcSignalSemaphoreKHR, + TrimCommandPool: ProcTrimCommandPool, + TrimCommandPoolKHR: ProcTrimCommandPoolKHR, + UninitializePerformanceApiINTEL: ProcUninitializePerformanceApiINTEL, + UnmapMemory: ProcUnmapMemory, + UnmapMemory2KHR: ProcUnmapMemory2KHR, + UpdateDescriptorSetWithTemplate: ProcUpdateDescriptorSetWithTemplate, + UpdateDescriptorSetWithTemplateKHR: ProcUpdateDescriptorSetWithTemplateKHR, + UpdateDescriptorSets: ProcUpdateDescriptorSets, + UpdateVideoSessionParametersKHR: ProcUpdateVideoSessionParametersKHR, + WaitForFences: ProcWaitForFences, + WaitForPresentKHR: ProcWaitForPresentKHR, + WaitSemaphores: ProcWaitSemaphores, + WaitSemaphoresKHR: ProcWaitSemaphoresKHR, + WriteAccelerationStructuresPropertiesKHR: ProcWriteAccelerationStructuresPropertiesKHR, + WriteMicromapsPropertiesEXT: ProcWriteMicromapsPropertiesEXT, } load_proc_addresses_device_vtable :: proc(device: Device, vtable: ^Device_VTable) { - vtable.AcquireFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT") - vtable.AcquireNextImage2KHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImage2KHR") - vtable.AcquireNextImageKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImageKHR") - vtable.AcquirePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL") - vtable.AcquireProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireProfilingLockKHR") - vtable.AllocateCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkAllocateCommandBuffers") - vtable.AllocateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkAllocateDescriptorSets") - vtable.AllocateMemory = auto_cast GetDeviceProcAddr(device, "vkAllocateMemory") - vtable.BeginCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkBeginCommandBuffer") - vtable.BindAccelerationStructureMemoryNV = auto_cast GetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV") - vtable.BindBufferMemory = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory") - vtable.BindBufferMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2") - vtable.BindBufferMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2KHR") - vtable.BindImageMemory = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory") - vtable.BindImageMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2") - vtable.BindImageMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2KHR") - vtable.BuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR") - vtable.CmdBeginConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT") - vtable.CmdBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT") - vtable.CmdBeginQuery = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQuery") - vtable.CmdBeginQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT") - vtable.CmdBeginRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass") - vtable.CmdBeginRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2") - vtable.CmdBeginRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR") - vtable.CmdBeginRendering = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRendering") - vtable.CmdBeginRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderingKHR") - vtable.CmdBeginTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT") - vtable.CmdBindDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorSets") - vtable.CmdBindIndexBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdBindIndexBuffer") - vtable.CmdBindInvocationMaskHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI") - vtable.CmdBindPipeline = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipeline") - vtable.CmdBindPipelineShaderGroupNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV") - vtable.CmdBindShadingRateImageNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV") - vtable.CmdBindTransformFeedbackBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT") - vtable.CmdBindVertexBuffers = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers") - vtable.CmdBindVertexBuffers2 = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2") - vtable.CmdBindVertexBuffers2EXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT") - vtable.CmdBlitImage = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage") - vtable.CmdBlitImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2") - vtable.CmdBlitImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2KHR") - vtable.CmdBuildAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV") - vtable.CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR") - vtable.CmdBuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR") - vtable.CmdClearAttachments = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments") - vtable.CmdClearColorImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage") - vtable.CmdClearDepthStencilImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage") - vtable.CmdCopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR") - vtable.CmdCopyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV") - vtable.CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR") - vtable.CmdCopyBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer") - vtable.CmdCopyBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2") - vtable.CmdCopyBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR") - vtable.CmdCopyBufferToImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage") - vtable.CmdCopyBufferToImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2") - vtable.CmdCopyBufferToImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR") - vtable.CmdCopyImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage") - vtable.CmdCopyImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2") - vtable.CmdCopyImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2KHR") - vtable.CmdCopyImageToBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer") - vtable.CmdCopyImageToBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2") - vtable.CmdCopyImageToBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR") - vtable.CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR") - vtable.CmdCopyQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults") - vtable.CmdCuLaunchKernelNVX = auto_cast GetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX") - vtable.CmdDebugMarkerBeginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT") - vtable.CmdDebugMarkerEndEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT") - vtable.CmdDebugMarkerInsertEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT") - vtable.CmdDispatch = auto_cast GetDeviceProcAddr(device, "vkCmdDispatch") - vtable.CmdDispatchBase = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBase") - vtable.CmdDispatchBaseKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBaseKHR") - vtable.CmdDispatchIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchIndirect") - vtable.CmdDraw = auto_cast GetDeviceProcAddr(device, "vkCmdDraw") - vtable.CmdDrawIndexed = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexed") - vtable.CmdDrawIndexedIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect") - vtable.CmdDrawIndexedIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount") - vtable.CmdDrawIndexedIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD") - vtable.CmdDrawIndexedIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR") - vtable.CmdDrawIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirect") - vtable.CmdDrawIndirectByteCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT") - vtable.CmdDrawIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCount") - vtable.CmdDrawIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD") - vtable.CmdDrawIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR") - vtable.CmdDrawMeshTasksIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV") - vtable.CmdDrawMeshTasksIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV") - vtable.CmdDrawMeshTasksNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV") - vtable.CmdDrawMultiEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiEXT") - vtable.CmdDrawMultiIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT") - vtable.CmdEndConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT") - vtable.CmdEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT") - vtable.CmdEndQuery = auto_cast GetDeviceProcAddr(device, "vkCmdEndQuery") - vtable.CmdEndQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT") - vtable.CmdEndRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass") - vtable.CmdEndRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2") - vtable.CmdEndRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR") - vtable.CmdEndRendering = auto_cast GetDeviceProcAddr(device, "vkCmdEndRendering") - vtable.CmdEndRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderingKHR") - vtable.CmdEndTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT") - vtable.CmdExecuteCommands = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteCommands") - vtable.CmdExecuteGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV") - vtable.CmdFillBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdFillBuffer") - vtable.CmdInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT") - vtable.CmdNextSubpass = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass") - vtable.CmdNextSubpass2 = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2") - vtable.CmdNextSubpass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2KHR") - vtable.CmdPipelineBarrier = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier") - vtable.CmdPipelineBarrier2 = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2") - vtable.CmdPipelineBarrier2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR") - vtable.CmdPreprocessGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV") - vtable.CmdPushConstants = auto_cast GetDeviceProcAddr(device, "vkCmdPushConstants") - vtable.CmdPushDescriptorSetKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR") - vtable.CmdPushDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR") - vtable.CmdResetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent") - vtable.CmdResetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2") - vtable.CmdResetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2KHR") - vtable.CmdResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkCmdResetQueryPool") - vtable.CmdResolveImage = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage") - vtable.CmdResolveImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2") - vtable.CmdResolveImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2KHR") - vtable.CmdSetBlendConstants = auto_cast GetDeviceProcAddr(device, "vkCmdSetBlendConstants") - vtable.CmdSetCheckpointNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCheckpointNV") - vtable.CmdSetCoarseSampleOrderNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV") - vtable.CmdSetCullMode = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullMode") - vtable.CmdSetCullModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullModeEXT") - vtable.CmdSetDepthBias = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBias") - vtable.CmdSetDepthBiasEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable") - vtable.CmdSetDepthBiasEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT") - vtable.CmdSetDepthBounds = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBounds") - vtable.CmdSetDepthBoundsTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable") - vtable.CmdSetDepthBoundsTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT") - vtable.CmdSetDepthCompareOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOp") - vtable.CmdSetDepthCompareOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT") - vtable.CmdSetDepthTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnable") - vtable.CmdSetDepthTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT") - vtable.CmdSetDepthWriteEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable") - vtable.CmdSetDepthWriteEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT") - vtable.CmdSetDeviceMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMask") - vtable.CmdSetDeviceMaskKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR") - vtable.CmdSetDiscardRectangleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT") - vtable.CmdSetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent") - vtable.CmdSetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2") - vtable.CmdSetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2KHR") - vtable.CmdSetExclusiveScissorNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV") - vtable.CmdSetFragmentShadingRateEnumNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV") - vtable.CmdSetFragmentShadingRateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR") - vtable.CmdSetFrontFace = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFace") - vtable.CmdSetFrontFaceEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT") - vtable.CmdSetLineStippleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEXT") - vtable.CmdSetLineWidth = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineWidth") - vtable.CmdSetLogicOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEXT") - vtable.CmdSetPatchControlPointsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT") - vtable.CmdSetPerformanceMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL") - vtable.CmdSetPerformanceOverrideINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL") - vtable.CmdSetPerformanceStreamMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL") - vtable.CmdSetPrimitiveRestartEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable") - vtable.CmdSetPrimitiveRestartEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT") - vtable.CmdSetPrimitiveTopology = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology") - vtable.CmdSetPrimitiveTopologyEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT") - vtable.CmdSetRasterizerDiscardEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable") - vtable.CmdSetRasterizerDiscardEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT") - vtable.CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR") - vtable.CmdSetSampleLocationsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT") - vtable.CmdSetScissor = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissor") - vtable.CmdSetScissorWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCount") - vtable.CmdSetScissorWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT") - vtable.CmdSetStencilCompareMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilCompareMask") - vtable.CmdSetStencilOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOp") - vtable.CmdSetStencilOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOpEXT") - vtable.CmdSetStencilReference = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilReference") - vtable.CmdSetStencilTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnable") - vtable.CmdSetStencilTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT") - vtable.CmdSetStencilWriteMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilWriteMask") - vtable.CmdSetVertexInputEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetVertexInputEXT") - vtable.CmdSetViewport = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewport") - vtable.CmdSetViewportShadingRatePaletteNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV") - vtable.CmdSetViewportWScalingNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV") - vtable.CmdSetViewportWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCount") - vtable.CmdSetViewportWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT") - vtable.CmdSubpassShadingHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI") - vtable.CmdTraceRaysIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR") - vtable.CmdTraceRaysKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysKHR") - vtable.CmdTraceRaysNV = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysNV") - vtable.CmdUpdateBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdUpdateBuffer") - vtable.CmdWaitEvents = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents") - vtable.CmdWaitEvents2 = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2") - vtable.CmdWaitEvents2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2KHR") - vtable.CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR") - vtable.CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV") - vtable.CmdWriteBufferMarker2AMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD") - vtable.CmdWriteBufferMarkerAMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD") - vtable.CmdWriteTimestamp = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp") - vtable.CmdWriteTimestamp2 = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2") - vtable.CmdWriteTimestamp2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR") - vtable.CompileDeferredNV = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV") - vtable.CopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR") - vtable.CopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR") - vtable.CopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR") - vtable.CreateAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR") - vtable.CreateAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureNV") - vtable.CreateBuffer = auto_cast GetDeviceProcAddr(device, "vkCreateBuffer") - vtable.CreateBufferView = auto_cast GetDeviceProcAddr(device, "vkCreateBufferView") - vtable.CreateCommandPool = auto_cast GetDeviceProcAddr(device, "vkCreateCommandPool") - vtable.CreateComputePipelines = auto_cast GetDeviceProcAddr(device, "vkCreateComputePipelines") - vtable.CreateCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuFunctionNVX") - vtable.CreateCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuModuleNVX") - vtable.CreateDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDeferredOperationKHR") - vtable.CreateDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorPool") - vtable.CreateDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorSetLayout") - vtable.CreateDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate") - vtable.CreateDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR") - vtable.CreateEvent = auto_cast GetDeviceProcAddr(device, "vkCreateEvent") - vtable.CreateFence = auto_cast GetDeviceProcAddr(device, "vkCreateFence") - vtable.CreateFramebuffer = auto_cast GetDeviceProcAddr(device, "vkCreateFramebuffer") - vtable.CreateGraphicsPipelines = auto_cast GetDeviceProcAddr(device, "vkCreateGraphicsPipelines") - vtable.CreateImage = auto_cast GetDeviceProcAddr(device, "vkCreateImage") - vtable.CreateImageView = auto_cast GetDeviceProcAddr(device, "vkCreateImageView") - vtable.CreateIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV") - vtable.CreatePipelineCache = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineCache") - vtable.CreatePipelineLayout = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineLayout") - vtable.CreatePrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlot") - vtable.CreatePrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT") - vtable.CreateQueryPool = auto_cast GetDeviceProcAddr(device, "vkCreateQueryPool") - vtable.CreateRayTracingPipelinesKHR = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR") - vtable.CreateRayTracingPipelinesNV = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV") - vtable.CreateRenderPass = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass") - vtable.CreateRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2") - vtable.CreateRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2KHR") - vtable.CreateSampler = auto_cast GetDeviceProcAddr(device, "vkCreateSampler") - vtable.CreateSamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion") - vtable.CreateSamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR") - vtable.CreateSemaphore = auto_cast GetDeviceProcAddr(device, "vkCreateSemaphore") - vtable.CreateShaderModule = auto_cast GetDeviceProcAddr(device, "vkCreateShaderModule") - vtable.CreateSharedSwapchainsKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR") - vtable.CreateSwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSwapchainKHR") - vtable.CreateValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkCreateValidationCacheEXT") - vtable.DebugMarkerSetObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT") - vtable.DebugMarkerSetObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT") - vtable.DeferredOperationJoinKHR = auto_cast GetDeviceProcAddr(device, "vkDeferredOperationJoinKHR") - vtable.DestroyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR") - vtable.DestroyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV") - vtable.DestroyBuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyBuffer") - vtable.DestroyBufferView = auto_cast GetDeviceProcAddr(device, "vkDestroyBufferView") - vtable.DestroyCommandPool = auto_cast GetDeviceProcAddr(device, "vkDestroyCommandPool") - vtable.DestroyCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuFunctionNVX") - vtable.DestroyCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuModuleNVX") - vtable.DestroyDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR") - vtable.DestroyDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorPool") - vtable.DestroyDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout") - vtable.DestroyDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate") - vtable.DestroyDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR") - vtable.DestroyDevice = auto_cast GetDeviceProcAddr(device, "vkDestroyDevice") - vtable.DestroyEvent = auto_cast GetDeviceProcAddr(device, "vkDestroyEvent") - vtable.DestroyFence = auto_cast GetDeviceProcAddr(device, "vkDestroyFence") - vtable.DestroyFramebuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyFramebuffer") - vtable.DestroyImage = auto_cast GetDeviceProcAddr(device, "vkDestroyImage") - vtable.DestroyImageView = auto_cast GetDeviceProcAddr(device, "vkDestroyImageView") - vtable.DestroyIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV") - vtable.DestroyPipeline = auto_cast GetDeviceProcAddr(device, "vkDestroyPipeline") - vtable.DestroyPipelineCache = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineCache") - vtable.DestroyPipelineLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineLayout") - vtable.DestroyPrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlot") - vtable.DestroyPrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT") - vtable.DestroyQueryPool = auto_cast GetDeviceProcAddr(device, "vkDestroyQueryPool") - vtable.DestroyRenderPass = auto_cast GetDeviceProcAddr(device, "vkDestroyRenderPass") - vtable.DestroySampler = auto_cast GetDeviceProcAddr(device, "vkDestroySampler") - vtable.DestroySamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion") - vtable.DestroySamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR") - vtable.DestroySemaphore = auto_cast GetDeviceProcAddr(device, "vkDestroySemaphore") - vtable.DestroyShaderModule = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderModule") - vtable.DestroySwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySwapchainKHR") - vtable.DestroyValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyValidationCacheEXT") - vtable.DeviceWaitIdle = auto_cast GetDeviceProcAddr(device, "vkDeviceWaitIdle") - vtable.DisplayPowerControlEXT = auto_cast GetDeviceProcAddr(device, "vkDisplayPowerControlEXT") - vtable.EndCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkEndCommandBuffer") - vtable.FlushMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkFlushMappedMemoryRanges") - vtable.FreeCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkFreeCommandBuffers") - vtable.FreeDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkFreeDescriptorSets") - vtable.FreeMemory = auto_cast GetDeviceProcAddr(device, "vkFreeMemory") - vtable.GetAccelerationStructureBuildSizesKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR") - vtable.GetAccelerationStructureDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR") - vtable.GetAccelerationStructureHandleNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV") - vtable.GetAccelerationStructureMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV") - vtable.GetBufferDeviceAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddress") - vtable.GetBufferDeviceAddressEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT") - vtable.GetBufferDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR") - vtable.GetBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements") - vtable.GetBufferMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2") - vtable.GetBufferMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR") - vtable.GetBufferOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress") - vtable.GetBufferOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR") - vtable.GetCalibratedTimestampsEXT = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT") - vtable.GetDeferredOperationMaxConcurrencyKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR") - vtable.GetDeferredOperationResultKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR") - vtable.GetDescriptorSetHostMappingVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE") - vtable.GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") - vtable.GetDescriptorSetLayoutSupport = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport") - vtable.GetDescriptorSetLayoutSupportKHR = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR") - vtable.GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR") - vtable.GetDeviceBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements") - vtable.GetDeviceBufferMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR") - vtable.GetDeviceGroupPeerMemoryFeatures = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures") - vtable.GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR") - vtable.GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR") - vtable.GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT") - vtable.GetDeviceGroupSurfacePresentModesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR") - vtable.GetDeviceImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements") - vtable.GetDeviceImageMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR") - vtable.GetDeviceImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements") - vtable.GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR") - vtable.GetDeviceMemoryCommitment = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment") - vtable.GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress") - vtable.GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") - vtable.GetDeviceProcAddr = auto_cast GetDeviceProcAddr(device, "vkGetDeviceProcAddr") - vtable.GetDeviceQueue = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue") - vtable.GetDeviceQueue2 = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue2") - vtable.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") - vtable.GetEventStatus = auto_cast GetDeviceProcAddr(device, "vkGetEventStatus") - vtable.GetFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceFdKHR") - vtable.GetFenceStatus = auto_cast GetDeviceProcAddr(device, "vkGetFenceStatus") - vtable.GetFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR") - vtable.GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV") - vtable.GetImageDrmFormatModifierPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT") - vtable.GetImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements") - vtable.GetImageMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2") - vtable.GetImageMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR") - vtable.GetImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements") - vtable.GetImageSparseMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2") - vtable.GetImageSparseMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR") - vtable.GetImageSubresourceLayout = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout") - vtable.GetImageViewAddressNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewAddressNVX") - vtable.GetImageViewHandleNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewHandleNVX") - vtable.GetMemoryFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR") - vtable.GetMemoryFdPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR") - vtable.GetMemoryHostPointerPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT") - vtable.GetMemoryRemoteAddressNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV") - vtable.GetMemoryWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR") - vtable.GetMemoryWin32HandleNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV") - vtable.GetMemoryWin32HandlePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR") - vtable.GetPastPresentationTimingGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE") - vtable.GetPerformanceParameterINTEL = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL") - vtable.GetPipelineCacheData = auto_cast GetDeviceProcAddr(device, "vkGetPipelineCacheData") - vtable.GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR") - vtable.GetPipelineExecutablePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR") - vtable.GetPipelineExecutableStatisticsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR") - vtable.GetPrivateData = auto_cast GetDeviceProcAddr(device, "vkGetPrivateData") - vtable.GetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetPrivateDataEXT") - vtable.GetQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkGetQueryPoolResults") - vtable.GetQueueCheckpointData2NV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV") - vtable.GetQueueCheckpointDataNV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV") - vtable.GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") - vtable.GetRayTracingShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR") - vtable.GetRayTracingShaderGroupHandlesNV = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV") - vtable.GetRayTracingShaderGroupStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR") - vtable.GetRefreshCycleDurationGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE") - vtable.GetRenderAreaGranularity = auto_cast GetDeviceProcAddr(device, "vkGetRenderAreaGranularity") - vtable.GetSemaphoreCounterValue = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValue") - vtable.GetSemaphoreCounterValueKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR") - vtable.GetSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreFdKHR") - vtable.GetSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR") - vtable.GetShaderInfoAMD = auto_cast GetDeviceProcAddr(device, "vkGetShaderInfoAMD") - vtable.GetSwapchainCounterEXT = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainCounterEXT") - vtable.GetSwapchainImagesKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainImagesKHR") - vtable.GetSwapchainStatusKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainStatusKHR") - vtable.GetValidationCacheDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetValidationCacheDataEXT") - vtable.ImportFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceFdKHR") - vtable.ImportFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR") - vtable.ImportSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreFdKHR") - vtable.ImportSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR") - vtable.InitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL") - vtable.InvalidateMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges") - vtable.MapMemory = auto_cast GetDeviceProcAddr(device, "vkMapMemory") - vtable.MergePipelineCaches = auto_cast GetDeviceProcAddr(device, "vkMergePipelineCaches") - vtable.MergeValidationCachesEXT = auto_cast GetDeviceProcAddr(device, "vkMergeValidationCachesEXT") - vtable.QueueBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT") - vtable.QueueBindSparse = auto_cast GetDeviceProcAddr(device, "vkQueueBindSparse") - vtable.QueueEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT") - vtable.QueueInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT") - vtable.QueuePresentKHR = auto_cast GetDeviceProcAddr(device, "vkQueuePresentKHR") - vtable.QueueSetPerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL") - vtable.QueueSubmit = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit") - vtable.QueueSubmit2 = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2") - vtable.QueueSubmit2KHR = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2KHR") - vtable.QueueWaitIdle = auto_cast GetDeviceProcAddr(device, "vkQueueWaitIdle") - vtable.RegisterDeviceEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDeviceEventEXT") - vtable.RegisterDisplayEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDisplayEventEXT") - vtable.ReleaseFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT") - vtable.ReleasePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL") - vtable.ReleaseProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkReleaseProfilingLockKHR") - vtable.ResetCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkResetCommandBuffer") - vtable.ResetCommandPool = auto_cast GetDeviceProcAddr(device, "vkResetCommandPool") - vtable.ResetDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkResetDescriptorPool") - vtable.ResetEvent = auto_cast GetDeviceProcAddr(device, "vkResetEvent") - vtable.ResetFences = auto_cast GetDeviceProcAddr(device, "vkResetFences") - vtable.ResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkResetQueryPool") - vtable.ResetQueryPoolEXT = auto_cast GetDeviceProcAddr(device, "vkResetQueryPoolEXT") - vtable.SetDebugUtilsObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT") - vtable.SetDebugUtilsObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT") - vtable.SetDeviceMemoryPriorityEXT = auto_cast GetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT") - vtable.SetEvent = auto_cast GetDeviceProcAddr(device, "vkSetEvent") - vtable.SetHdrMetadataEXT = auto_cast GetDeviceProcAddr(device, "vkSetHdrMetadataEXT") - vtable.SetLocalDimmingAMD = auto_cast GetDeviceProcAddr(device, "vkSetLocalDimmingAMD") - vtable.SetPrivateData = auto_cast GetDeviceProcAddr(device, "vkSetPrivateData") - vtable.SetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkSetPrivateDataEXT") - vtable.SignalSemaphore = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphore") - vtable.SignalSemaphoreKHR = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphoreKHR") - vtable.TrimCommandPool = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPool") - vtable.TrimCommandPoolKHR = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPoolKHR") - vtable.UninitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL") - vtable.UnmapMemory = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory") - vtable.UpdateDescriptorSetWithTemplate = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate") - vtable.UpdateDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR") - vtable.UpdateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSets") - vtable.WaitForFences = auto_cast GetDeviceProcAddr(device, "vkWaitForFences") - vtable.WaitForPresentKHR = auto_cast GetDeviceProcAddr(device, "vkWaitForPresentKHR") - vtable.WaitSemaphores = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphores") - vtable.WaitSemaphoresKHR = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphoresKHR") - vtable.WriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR") + vtable.AcquireFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT") + vtable.AcquireNextImage2KHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImage2KHR") + vtable.AcquireNextImageKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImageKHR") + vtable.AcquirePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL") + vtable.AcquireProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireProfilingLockKHR") + vtable.AllocateCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkAllocateCommandBuffers") + vtable.AllocateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkAllocateDescriptorSets") + vtable.AllocateMemory = auto_cast GetDeviceProcAddr(device, "vkAllocateMemory") + vtable.BeginCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkBeginCommandBuffer") + vtable.BindAccelerationStructureMemoryNV = auto_cast GetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV") + vtable.BindBufferMemory = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory") + vtable.BindBufferMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2") + vtable.BindBufferMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2KHR") + vtable.BindImageMemory = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory") + vtable.BindImageMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2") + vtable.BindImageMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2KHR") + vtable.BindOpticalFlowSessionImageNV = auto_cast GetDeviceProcAddr(device, "vkBindOpticalFlowSessionImageNV") + vtable.BindVideoSessionMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkBindVideoSessionMemoryKHR") + vtable.BuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR") + vtable.BuildMicromapsEXT = auto_cast GetDeviceProcAddr(device, "vkBuildMicromapsEXT") + vtable.CmdBeginConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT") + vtable.CmdBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT") + vtable.CmdBeginQuery = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQuery") + vtable.CmdBeginQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT") + vtable.CmdBeginRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass") + vtable.CmdBeginRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2") + vtable.CmdBeginRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR") + vtable.CmdBeginRendering = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRendering") + vtable.CmdBeginRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderingKHR") + vtable.CmdBeginTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT") + vtable.CmdBeginVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginVideoCodingKHR") + vtable.CmdBindDescriptorBufferEmbeddedSamplersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") + vtable.CmdBindDescriptorBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorBuffersEXT") + vtable.CmdBindDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorSets") + vtable.CmdBindIndexBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdBindIndexBuffer") + vtable.CmdBindInvocationMaskHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI") + vtable.CmdBindPipeline = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipeline") + vtable.CmdBindPipelineShaderGroupNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV") + vtable.CmdBindShadersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadersEXT") + vtable.CmdBindShadingRateImageNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV") + vtable.CmdBindTransformFeedbackBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT") + vtable.CmdBindVertexBuffers = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers") + vtable.CmdBindVertexBuffers2 = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2") + vtable.CmdBindVertexBuffers2EXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT") + vtable.CmdBlitImage = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage") + vtable.CmdBlitImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2") + vtable.CmdBlitImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2KHR") + vtable.CmdBuildAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV") + vtable.CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR") + vtable.CmdBuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR") + vtable.CmdBuildMicromapsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBuildMicromapsEXT") + vtable.CmdClearAttachments = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments") + vtable.CmdClearColorImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage") + vtable.CmdClearDepthStencilImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage") + vtable.CmdControlVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR") + vtable.CmdCopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR") + vtable.CmdCopyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV") + vtable.CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR") + vtable.CmdCopyBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer") + vtable.CmdCopyBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2") + vtable.CmdCopyBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR") + vtable.CmdCopyBufferToImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage") + vtable.CmdCopyBufferToImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2") + vtable.CmdCopyBufferToImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR") + vtable.CmdCopyImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage") + vtable.CmdCopyImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2") + vtable.CmdCopyImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2KHR") + vtable.CmdCopyImageToBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer") + vtable.CmdCopyImageToBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2") + vtable.CmdCopyImageToBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR") + vtable.CmdCopyMemoryIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryIndirectNV") + vtable.CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR") + vtable.CmdCopyMemoryToImageIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToImageIndirectNV") + vtable.CmdCopyMemoryToMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToMicromapEXT") + vtable.CmdCopyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMicromapEXT") + vtable.CmdCopyMicromapToMemoryEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMicromapToMemoryEXT") + vtable.CmdCopyQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults") + vtable.CmdCuLaunchKernelNVX = auto_cast GetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX") + vtable.CmdDebugMarkerBeginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT") + vtable.CmdDebugMarkerEndEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT") + vtable.CmdDebugMarkerInsertEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT") + vtable.CmdDecodeVideoKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDecodeVideoKHR") + vtable.CmdDecompressMemoryIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDecompressMemoryIndirectCountNV") + vtable.CmdDecompressMemoryNV = auto_cast GetDeviceProcAddr(device, "vkCmdDecompressMemoryNV") + vtable.CmdDispatch = auto_cast GetDeviceProcAddr(device, "vkCmdDispatch") + vtable.CmdDispatchBase = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBase") + vtable.CmdDispatchBaseKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBaseKHR") + vtable.CmdDispatchIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchIndirect") + vtable.CmdDraw = auto_cast GetDeviceProcAddr(device, "vkCmdDraw") + vtable.CmdDrawClusterHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdDrawClusterHUAWEI") + vtable.CmdDrawClusterIndirectHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdDrawClusterIndirectHUAWEI") + vtable.CmdDrawIndexed = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexed") + vtable.CmdDrawIndexedIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect") + vtable.CmdDrawIndexedIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount") + vtable.CmdDrawIndexedIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD") + vtable.CmdDrawIndexedIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR") + vtable.CmdDrawIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirect") + vtable.CmdDrawIndirectByteCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT") + vtable.CmdDrawIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCount") + vtable.CmdDrawIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD") + vtable.CmdDrawIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR") + vtable.CmdDrawMeshTasksEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksEXT") + vtable.CmdDrawMeshTasksIndirectCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountEXT") + vtable.CmdDrawMeshTasksIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV") + vtable.CmdDrawMeshTasksIndirectEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectEXT") + vtable.CmdDrawMeshTasksIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV") + vtable.CmdDrawMeshTasksNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV") + vtable.CmdDrawMultiEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiEXT") + vtable.CmdDrawMultiIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT") + vtable.CmdEndConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT") + vtable.CmdEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT") + vtable.CmdEndQuery = auto_cast GetDeviceProcAddr(device, "vkCmdEndQuery") + vtable.CmdEndQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT") + vtable.CmdEndRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass") + vtable.CmdEndRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2") + vtable.CmdEndRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR") + vtable.CmdEndRendering = auto_cast GetDeviceProcAddr(device, "vkCmdEndRendering") + vtable.CmdEndRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderingKHR") + vtable.CmdEndTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT") + vtable.CmdEndVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndVideoCodingKHR") + vtable.CmdExecuteCommands = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteCommands") + vtable.CmdExecuteGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV") + vtable.CmdFillBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdFillBuffer") + vtable.CmdInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT") + vtable.CmdNextSubpass = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass") + vtable.CmdNextSubpass2 = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2") + vtable.CmdNextSubpass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2KHR") + vtable.CmdOpticalFlowExecuteNV = auto_cast GetDeviceProcAddr(device, "vkCmdOpticalFlowExecuteNV") + vtable.CmdPipelineBarrier = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier") + vtable.CmdPipelineBarrier2 = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2") + vtable.CmdPipelineBarrier2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR") + vtable.CmdPreprocessGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV") + vtable.CmdPushConstants = auto_cast GetDeviceProcAddr(device, "vkCmdPushConstants") + vtable.CmdPushDescriptorSetKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR") + vtable.CmdPushDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR") + vtable.CmdResetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent") + vtable.CmdResetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2") + vtable.CmdResetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2KHR") + vtable.CmdResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkCmdResetQueryPool") + vtable.CmdResolveImage = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage") + vtable.CmdResolveImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2") + vtable.CmdResolveImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2KHR") + vtable.CmdSetAlphaToCoverageEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAlphaToCoverageEnableEXT") + vtable.CmdSetAlphaToOneEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAlphaToOneEnableEXT") + vtable.CmdSetAttachmentFeedbackLoopEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAttachmentFeedbackLoopEnableEXT") + vtable.CmdSetBlendConstants = auto_cast GetDeviceProcAddr(device, "vkCmdSetBlendConstants") + vtable.CmdSetCheckpointNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCheckpointNV") + vtable.CmdSetCoarseSampleOrderNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV") + vtable.CmdSetColorBlendAdvancedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendAdvancedEXT") + vtable.CmdSetColorBlendEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendEnableEXT") + vtable.CmdSetColorBlendEquationEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendEquationEXT") + vtable.CmdSetColorWriteMaskEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorWriteMaskEXT") + vtable.CmdSetConservativeRasterizationModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetConservativeRasterizationModeEXT") + vtable.CmdSetCoverageModulationModeNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationModeNV") + vtable.CmdSetCoverageModulationTableEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationTableEnableNV") + vtable.CmdSetCoverageModulationTableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationTableNV") + vtable.CmdSetCoverageReductionModeNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageReductionModeNV") + vtable.CmdSetCoverageToColorEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageToColorEnableNV") + vtable.CmdSetCoverageToColorLocationNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageToColorLocationNV") + vtable.CmdSetCullMode = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullMode") + vtable.CmdSetCullModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullModeEXT") + vtable.CmdSetDepthBias = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBias") + vtable.CmdSetDepthBiasEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable") + vtable.CmdSetDepthBiasEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT") + vtable.CmdSetDepthBounds = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBounds") + vtable.CmdSetDepthBoundsTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable") + vtable.CmdSetDepthBoundsTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT") + vtable.CmdSetDepthClampEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClampEnableEXT") + vtable.CmdSetDepthClipEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClipEnableEXT") + vtable.CmdSetDepthClipNegativeOneToOneEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClipNegativeOneToOneEXT") + vtable.CmdSetDepthCompareOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOp") + vtable.CmdSetDepthCompareOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT") + vtable.CmdSetDepthTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnable") + vtable.CmdSetDepthTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT") + vtable.CmdSetDepthWriteEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable") + vtable.CmdSetDepthWriteEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT") + vtable.CmdSetDescriptorBufferOffsetsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDescriptorBufferOffsetsEXT") + vtable.CmdSetDeviceMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMask") + vtable.CmdSetDeviceMaskKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR") + vtable.CmdSetDiscardRectangleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT") + vtable.CmdSetDiscardRectangleEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEnableEXT") + vtable.CmdSetDiscardRectangleModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleModeEXT") + vtable.CmdSetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent") + vtable.CmdSetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2") + vtable.CmdSetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2KHR") + vtable.CmdSetExclusiveScissorEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorEnableNV") + vtable.CmdSetExclusiveScissorNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV") + vtable.CmdSetExtraPrimitiveOverestimationSizeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") + vtable.CmdSetFragmentShadingRateEnumNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV") + vtable.CmdSetFragmentShadingRateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR") + vtable.CmdSetFrontFace = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFace") + vtable.CmdSetFrontFaceEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT") + vtable.CmdSetLineRasterizationModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineRasterizationModeEXT") + vtable.CmdSetLineStippleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEXT") + vtable.CmdSetLineStippleEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEnableEXT") + vtable.CmdSetLineWidth = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineWidth") + vtable.CmdSetLogicOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEXT") + vtable.CmdSetLogicOpEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEnableEXT") + vtable.CmdSetPatchControlPointsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT") + vtable.CmdSetPerformanceMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL") + vtable.CmdSetPerformanceOverrideINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL") + vtable.CmdSetPerformanceStreamMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL") + vtable.CmdSetPolygonModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPolygonModeEXT") + vtable.CmdSetPrimitiveRestartEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable") + vtable.CmdSetPrimitiveRestartEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT") + vtable.CmdSetPrimitiveTopology = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology") + vtable.CmdSetPrimitiveTopologyEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT") + vtable.CmdSetProvokingVertexModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetProvokingVertexModeEXT") + vtable.CmdSetRasterizationSamplesEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizationSamplesEXT") + vtable.CmdSetRasterizationStreamEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizationStreamEXT") + vtable.CmdSetRasterizerDiscardEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable") + vtable.CmdSetRasterizerDiscardEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT") + vtable.CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR") + vtable.CmdSetRepresentativeFragmentTestEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetRepresentativeFragmentTestEnableNV") + vtable.CmdSetSampleLocationsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT") + vtable.CmdSetSampleLocationsEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEnableEXT") + vtable.CmdSetSampleMaskEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleMaskEXT") + vtable.CmdSetScissor = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissor") + vtable.CmdSetScissorWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCount") + vtable.CmdSetScissorWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT") + vtable.CmdSetShadingRateImageEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetShadingRateImageEnableNV") + vtable.CmdSetStencilCompareMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilCompareMask") + vtable.CmdSetStencilOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOp") + vtable.CmdSetStencilOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOpEXT") + vtable.CmdSetStencilReference = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilReference") + vtable.CmdSetStencilTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnable") + vtable.CmdSetStencilTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT") + vtable.CmdSetStencilWriteMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilWriteMask") + vtable.CmdSetTessellationDomainOriginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetTessellationDomainOriginEXT") + vtable.CmdSetVertexInputEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetVertexInputEXT") + vtable.CmdSetViewport = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewport") + vtable.CmdSetViewportShadingRatePaletteNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV") + vtable.CmdSetViewportSwizzleNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportSwizzleNV") + vtable.CmdSetViewportWScalingEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingEnableNV") + vtable.CmdSetViewportWScalingNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV") + vtable.CmdSetViewportWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCount") + vtable.CmdSetViewportWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT") + vtable.CmdSubpassShadingHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI") + vtable.CmdTraceRaysIndirect2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirect2KHR") + vtable.CmdTraceRaysIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR") + vtable.CmdTraceRaysKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysKHR") + vtable.CmdTraceRaysNV = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysNV") + vtable.CmdUpdateBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdUpdateBuffer") + vtable.CmdWaitEvents = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents") + vtable.CmdWaitEvents2 = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2") + vtable.CmdWaitEvents2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2KHR") + vtable.CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR") + vtable.CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV") + vtable.CmdWriteBufferMarker2AMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD") + vtable.CmdWriteBufferMarkerAMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD") + vtable.CmdWriteMicromapsPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkCmdWriteMicromapsPropertiesEXT") + vtable.CmdWriteTimestamp = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp") + vtable.CmdWriteTimestamp2 = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2") + vtable.CmdWriteTimestamp2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR") + vtable.CompileDeferredNV = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV") + vtable.CopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR") + vtable.CopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR") + vtable.CopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR") + vtable.CopyMemoryToMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToMicromapEXT") + vtable.CopyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMicromapEXT") + vtable.CopyMicromapToMemoryEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMicromapToMemoryEXT") + vtable.CreateAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR") + vtable.CreateAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureNV") + vtable.CreateBuffer = auto_cast GetDeviceProcAddr(device, "vkCreateBuffer") + vtable.CreateBufferView = auto_cast GetDeviceProcAddr(device, "vkCreateBufferView") + vtable.CreateCommandPool = auto_cast GetDeviceProcAddr(device, "vkCreateCommandPool") + vtable.CreateComputePipelines = auto_cast GetDeviceProcAddr(device, "vkCreateComputePipelines") + vtable.CreateCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuFunctionNVX") + vtable.CreateCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuModuleNVX") + vtable.CreateDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDeferredOperationKHR") + vtable.CreateDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorPool") + vtable.CreateDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorSetLayout") + vtable.CreateDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate") + vtable.CreateDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR") + vtable.CreateEvent = auto_cast GetDeviceProcAddr(device, "vkCreateEvent") + vtable.CreateFence = auto_cast GetDeviceProcAddr(device, "vkCreateFence") + vtable.CreateFramebuffer = auto_cast GetDeviceProcAddr(device, "vkCreateFramebuffer") + vtable.CreateGraphicsPipelines = auto_cast GetDeviceProcAddr(device, "vkCreateGraphicsPipelines") + vtable.CreateImage = auto_cast GetDeviceProcAddr(device, "vkCreateImage") + vtable.CreateImageView = auto_cast GetDeviceProcAddr(device, "vkCreateImageView") + vtable.CreateIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV") + vtable.CreateMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCreateMicromapEXT") + vtable.CreateOpticalFlowSessionNV = auto_cast GetDeviceProcAddr(device, "vkCreateOpticalFlowSessionNV") + vtable.CreatePipelineCache = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineCache") + vtable.CreatePipelineLayout = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineLayout") + vtable.CreatePrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlot") + vtable.CreatePrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT") + vtable.CreateQueryPool = auto_cast GetDeviceProcAddr(device, "vkCreateQueryPool") + vtable.CreateRayTracingPipelinesKHR = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR") + vtable.CreateRayTracingPipelinesNV = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV") + vtable.CreateRenderPass = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass") + vtable.CreateRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2") + vtable.CreateRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2KHR") + vtable.CreateSampler = auto_cast GetDeviceProcAddr(device, "vkCreateSampler") + vtable.CreateSamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion") + vtable.CreateSamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR") + vtable.CreateSemaphore = auto_cast GetDeviceProcAddr(device, "vkCreateSemaphore") + vtable.CreateShaderModule = auto_cast GetDeviceProcAddr(device, "vkCreateShaderModule") + vtable.CreateShadersEXT = auto_cast GetDeviceProcAddr(device, "vkCreateShadersEXT") + vtable.CreateSharedSwapchainsKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR") + vtable.CreateSwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSwapchainKHR") + vtable.CreateValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkCreateValidationCacheEXT") + vtable.CreateVideoSessionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateVideoSessionKHR") + vtable.CreateVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkCreateVideoSessionParametersKHR") + vtable.DebugMarkerSetObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT") + vtable.DebugMarkerSetObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT") + vtable.DeferredOperationJoinKHR = auto_cast GetDeviceProcAddr(device, "vkDeferredOperationJoinKHR") + vtable.DestroyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR") + vtable.DestroyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV") + vtable.DestroyBuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyBuffer") + vtable.DestroyBufferView = auto_cast GetDeviceProcAddr(device, "vkDestroyBufferView") + vtable.DestroyCommandPool = auto_cast GetDeviceProcAddr(device, "vkDestroyCommandPool") + vtable.DestroyCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuFunctionNVX") + vtable.DestroyCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuModuleNVX") + vtable.DestroyDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR") + vtable.DestroyDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorPool") + vtable.DestroyDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout") + vtable.DestroyDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate") + vtable.DestroyDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR") + vtable.DestroyDevice = auto_cast GetDeviceProcAddr(device, "vkDestroyDevice") + vtable.DestroyEvent = auto_cast GetDeviceProcAddr(device, "vkDestroyEvent") + vtable.DestroyFence = auto_cast GetDeviceProcAddr(device, "vkDestroyFence") + vtable.DestroyFramebuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyFramebuffer") + vtable.DestroyImage = auto_cast GetDeviceProcAddr(device, "vkDestroyImage") + vtable.DestroyImageView = auto_cast GetDeviceProcAddr(device, "vkDestroyImageView") + vtable.DestroyIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV") + vtable.DestroyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyMicromapEXT") + vtable.DestroyOpticalFlowSessionNV = auto_cast GetDeviceProcAddr(device, "vkDestroyOpticalFlowSessionNV") + vtable.DestroyPipeline = auto_cast GetDeviceProcAddr(device, "vkDestroyPipeline") + vtable.DestroyPipelineCache = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineCache") + vtable.DestroyPipelineLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineLayout") + vtable.DestroyPrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlot") + vtable.DestroyPrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT") + vtable.DestroyQueryPool = auto_cast GetDeviceProcAddr(device, "vkDestroyQueryPool") + vtable.DestroyRenderPass = auto_cast GetDeviceProcAddr(device, "vkDestroyRenderPass") + vtable.DestroySampler = auto_cast GetDeviceProcAddr(device, "vkDestroySampler") + vtable.DestroySamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion") + vtable.DestroySamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR") + vtable.DestroySemaphore = auto_cast GetDeviceProcAddr(device, "vkDestroySemaphore") + vtable.DestroyShaderEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderEXT") + vtable.DestroyShaderModule = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderModule") + vtable.DestroySwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySwapchainKHR") + vtable.DestroyValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyValidationCacheEXT") + vtable.DestroyVideoSessionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyVideoSessionKHR") + vtable.DestroyVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyVideoSessionParametersKHR") + vtable.DeviceWaitIdle = auto_cast GetDeviceProcAddr(device, "vkDeviceWaitIdle") + vtable.DisplayPowerControlEXT = auto_cast GetDeviceProcAddr(device, "vkDisplayPowerControlEXT") + vtable.EndCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkEndCommandBuffer") + vtable.ExportMetalObjectsEXT = auto_cast GetDeviceProcAddr(device, "vkExportMetalObjectsEXT") + vtable.FlushMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkFlushMappedMemoryRanges") + vtable.FreeCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkFreeCommandBuffers") + vtable.FreeDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkFreeDescriptorSets") + vtable.FreeMemory = auto_cast GetDeviceProcAddr(device, "vkFreeMemory") + vtable.GetAccelerationStructureBuildSizesKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR") + vtable.GetAccelerationStructureDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR") + vtable.GetAccelerationStructureHandleNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV") + vtable.GetAccelerationStructureMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV") + vtable.GetAccelerationStructureOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") + vtable.GetBufferDeviceAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddress") + vtable.GetBufferDeviceAddressEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT") + vtable.GetBufferDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR") + vtable.GetBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements") + vtable.GetBufferMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2") + vtable.GetBufferMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR") + vtable.GetBufferOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress") + vtable.GetBufferOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR") + vtable.GetBufferOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT") + vtable.GetCalibratedTimestampsEXT = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT") + vtable.GetDeferredOperationMaxConcurrencyKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR") + vtable.GetDeferredOperationResultKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR") + vtable.GetDescriptorEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorEXT") + vtable.GetDescriptorSetHostMappingVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE") + vtable.GetDescriptorSetLayoutBindingOffsetEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutBindingOffsetEXT") + vtable.GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") + vtable.GetDescriptorSetLayoutSizeEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSizeEXT") + vtable.GetDescriptorSetLayoutSupport = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport") + vtable.GetDescriptorSetLayoutSupportKHR = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR") + vtable.GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR") + vtable.GetDeviceBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements") + vtable.GetDeviceBufferMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR") + vtable.GetDeviceFaultInfoEXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceFaultInfoEXT") + vtable.GetDeviceGroupPeerMemoryFeatures = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures") + vtable.GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR") + vtable.GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR") + vtable.GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT") + vtable.GetDeviceGroupSurfacePresentModesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR") + vtable.GetDeviceImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements") + vtable.GetDeviceImageMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR") + vtable.GetDeviceImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements") + vtable.GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR") + vtable.GetDeviceMemoryCommitment = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment") + vtable.GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress") + vtable.GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") + vtable.GetDeviceMicromapCompatibilityEXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMicromapCompatibilityEXT") + vtable.GetDeviceProcAddr = auto_cast GetDeviceProcAddr(device, "vkGetDeviceProcAddr") + vtable.GetDeviceQueue = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue") + vtable.GetDeviceQueue2 = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue2") + vtable.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") + vtable.GetDynamicRenderingTilePropertiesQCOM = auto_cast GetDeviceProcAddr(device, "vkGetDynamicRenderingTilePropertiesQCOM") + vtable.GetEventStatus = auto_cast GetDeviceProcAddr(device, "vkGetEventStatus") + vtable.GetFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceFdKHR") + vtable.GetFenceStatus = auto_cast GetDeviceProcAddr(device, "vkGetFenceStatus") + vtable.GetFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR") + vtable.GetFramebufferTilePropertiesQCOM = auto_cast GetDeviceProcAddr(device, "vkGetFramebufferTilePropertiesQCOM") + vtable.GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV") + vtable.GetImageDrmFormatModifierPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT") + vtable.GetImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements") + vtable.GetImageMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2") + vtable.GetImageMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR") + vtable.GetImageOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageOpaqueCaptureDescriptorDataEXT") + vtable.GetImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements") + vtable.GetImageSparseMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2") + vtable.GetImageSparseMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR") + vtable.GetImageSubresourceLayout = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout") + vtable.GetImageSubresourceLayout2EXT = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout2EXT") + vtable.GetImageViewAddressNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewAddressNVX") + vtable.GetImageViewHandleNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewHandleNVX") + vtable.GetImageViewOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") + vtable.GetMemoryFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR") + vtable.GetMemoryFdPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR") + vtable.GetMemoryHostPointerPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT") + vtable.GetMemoryRemoteAddressNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV") + vtable.GetMemoryWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR") + vtable.GetMemoryWin32HandleNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV") + vtable.GetMemoryWin32HandlePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR") + vtable.GetMicromapBuildSizesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMicromapBuildSizesEXT") + vtable.GetPastPresentationTimingGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE") + vtable.GetPerformanceParameterINTEL = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL") + vtable.GetPipelineCacheData = auto_cast GetDeviceProcAddr(device, "vkGetPipelineCacheData") + vtable.GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR") + vtable.GetPipelineExecutablePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR") + vtable.GetPipelineExecutableStatisticsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR") + vtable.GetPipelinePropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetPipelinePropertiesEXT") + vtable.GetPrivateData = auto_cast GetDeviceProcAddr(device, "vkGetPrivateData") + vtable.GetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetPrivateDataEXT") + vtable.GetQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkGetQueryPoolResults") + vtable.GetQueueCheckpointData2NV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV") + vtable.GetQueueCheckpointDataNV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV") + vtable.GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") + vtable.GetRayTracingShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR") + vtable.GetRayTracingShaderGroupHandlesNV = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV") + vtable.GetRayTracingShaderGroupStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR") + vtable.GetRefreshCycleDurationGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE") + vtable.GetRenderAreaGranularity = auto_cast GetDeviceProcAddr(device, "vkGetRenderAreaGranularity") + vtable.GetSamplerOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") + vtable.GetSemaphoreCounterValue = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValue") + vtable.GetSemaphoreCounterValueKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR") + vtable.GetSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreFdKHR") + vtable.GetSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR") + vtable.GetShaderBinaryDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderBinaryDataEXT") + vtable.GetShaderInfoAMD = auto_cast GetDeviceProcAddr(device, "vkGetShaderInfoAMD") + vtable.GetShaderModuleCreateInfoIdentifierEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderModuleCreateInfoIdentifierEXT") + vtable.GetShaderModuleIdentifierEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderModuleIdentifierEXT") + vtable.GetSwapchainCounterEXT = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainCounterEXT") + vtable.GetSwapchainImagesKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainImagesKHR") + vtable.GetSwapchainStatusKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainStatusKHR") + vtable.GetValidationCacheDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetValidationCacheDataEXT") + vtable.GetVideoSessionMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR") + vtable.ImportFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceFdKHR") + vtable.ImportFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR") + vtable.ImportSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreFdKHR") + vtable.ImportSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR") + vtable.InitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL") + vtable.InvalidateMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges") + vtable.MapMemory = auto_cast GetDeviceProcAddr(device, "vkMapMemory") + vtable.MapMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkMapMemory2KHR") + vtable.MergePipelineCaches = auto_cast GetDeviceProcAddr(device, "vkMergePipelineCaches") + vtable.MergeValidationCachesEXT = auto_cast GetDeviceProcAddr(device, "vkMergeValidationCachesEXT") + vtable.QueueBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT") + vtable.QueueBindSparse = auto_cast GetDeviceProcAddr(device, "vkQueueBindSparse") + vtable.QueueEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT") + vtable.QueueInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT") + vtable.QueuePresentKHR = auto_cast GetDeviceProcAddr(device, "vkQueuePresentKHR") + vtable.QueueSetPerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL") + vtable.QueueSubmit = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit") + vtable.QueueSubmit2 = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2") + vtable.QueueSubmit2KHR = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2KHR") + vtable.QueueWaitIdle = auto_cast GetDeviceProcAddr(device, "vkQueueWaitIdle") + vtable.RegisterDeviceEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDeviceEventEXT") + vtable.RegisterDisplayEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDisplayEventEXT") + vtable.ReleaseFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT") + vtable.ReleasePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL") + vtable.ReleaseProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkReleaseProfilingLockKHR") + vtable.ReleaseSwapchainImagesEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseSwapchainImagesEXT") + vtable.ResetCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkResetCommandBuffer") + vtable.ResetCommandPool = auto_cast GetDeviceProcAddr(device, "vkResetCommandPool") + vtable.ResetDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkResetDescriptorPool") + vtable.ResetEvent = auto_cast GetDeviceProcAddr(device, "vkResetEvent") + vtable.ResetFences = auto_cast GetDeviceProcAddr(device, "vkResetFences") + vtable.ResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkResetQueryPool") + vtable.ResetQueryPoolEXT = auto_cast GetDeviceProcAddr(device, "vkResetQueryPoolEXT") + vtable.SetDebugUtilsObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT") + vtable.SetDebugUtilsObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT") + vtable.SetDeviceMemoryPriorityEXT = auto_cast GetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT") + vtable.SetEvent = auto_cast GetDeviceProcAddr(device, "vkSetEvent") + vtable.SetHdrMetadataEXT = auto_cast GetDeviceProcAddr(device, "vkSetHdrMetadataEXT") + vtable.SetLocalDimmingAMD = auto_cast GetDeviceProcAddr(device, "vkSetLocalDimmingAMD") + vtable.SetPrivateData = auto_cast GetDeviceProcAddr(device, "vkSetPrivateData") + vtable.SetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkSetPrivateDataEXT") + vtable.SignalSemaphore = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphore") + vtable.SignalSemaphoreKHR = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphoreKHR") + vtable.TrimCommandPool = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPool") + vtable.TrimCommandPoolKHR = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPoolKHR") + vtable.UninitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL") + vtable.UnmapMemory = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory") + vtable.UnmapMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory2KHR") + vtable.UpdateDescriptorSetWithTemplate = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate") + vtable.UpdateDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR") + vtable.UpdateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSets") + vtable.UpdateVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateVideoSessionParametersKHR") + vtable.WaitForFences = auto_cast GetDeviceProcAddr(device, "vkWaitForFences") + vtable.WaitForPresentKHR = auto_cast GetDeviceProcAddr(device, "vkWaitForPresentKHR") + vtable.WaitSemaphores = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphores") + vtable.WaitSemaphoresKHR = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphoresKHR") + vtable.WriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR") + vtable.WriteMicromapsPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkWriteMicromapsPropertiesEXT") } load_proc_addresses_device :: proc(device: Device) { - AcquireFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT") - AcquireNextImage2KHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImage2KHR") - AcquireNextImageKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImageKHR") - AcquirePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL") - AcquireProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireProfilingLockKHR") - AllocateCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkAllocateCommandBuffers") - AllocateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkAllocateDescriptorSets") - AllocateMemory = auto_cast GetDeviceProcAddr(device, "vkAllocateMemory") - BeginCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkBeginCommandBuffer") - BindAccelerationStructureMemoryNV = auto_cast GetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV") - BindBufferMemory = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory") - BindBufferMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2") - BindBufferMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2KHR") - BindImageMemory = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory") - BindImageMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2") - BindImageMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2KHR") - BuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR") - CmdBeginConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT") - CmdBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT") - CmdBeginQuery = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQuery") - CmdBeginQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT") - CmdBeginRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass") - CmdBeginRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2") - CmdBeginRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR") - CmdBeginRendering = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRendering") - CmdBeginRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderingKHR") - CmdBeginTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT") - CmdBindDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorSets") - CmdBindIndexBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdBindIndexBuffer") - CmdBindInvocationMaskHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI") - CmdBindPipeline = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipeline") - CmdBindPipelineShaderGroupNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV") - CmdBindShadingRateImageNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV") - CmdBindTransformFeedbackBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT") - CmdBindVertexBuffers = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers") - CmdBindVertexBuffers2 = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2") - CmdBindVertexBuffers2EXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT") - CmdBlitImage = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage") - CmdBlitImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2") - CmdBlitImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2KHR") - CmdBuildAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV") - CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR") - CmdBuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR") - CmdClearAttachments = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments") - CmdClearColorImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage") - CmdClearDepthStencilImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage") - CmdCopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR") - CmdCopyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV") - CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR") - CmdCopyBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer") - CmdCopyBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2") - CmdCopyBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR") - CmdCopyBufferToImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage") - CmdCopyBufferToImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2") - CmdCopyBufferToImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR") - CmdCopyImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage") - CmdCopyImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2") - CmdCopyImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2KHR") - CmdCopyImageToBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer") - CmdCopyImageToBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2") - CmdCopyImageToBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR") - CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR") - CmdCopyQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults") - CmdCuLaunchKernelNVX = auto_cast GetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX") - CmdDebugMarkerBeginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT") - CmdDebugMarkerEndEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT") - CmdDebugMarkerInsertEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT") - CmdDispatch = auto_cast GetDeviceProcAddr(device, "vkCmdDispatch") - CmdDispatchBase = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBase") - CmdDispatchBaseKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBaseKHR") - CmdDispatchIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchIndirect") - CmdDraw = auto_cast GetDeviceProcAddr(device, "vkCmdDraw") - CmdDrawIndexed = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexed") - CmdDrawIndexedIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect") - CmdDrawIndexedIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount") - CmdDrawIndexedIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD") - CmdDrawIndexedIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR") - CmdDrawIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirect") - CmdDrawIndirectByteCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT") - CmdDrawIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCount") - CmdDrawIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD") - CmdDrawIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR") - CmdDrawMeshTasksIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV") - CmdDrawMeshTasksIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV") - CmdDrawMeshTasksNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV") - CmdDrawMultiEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiEXT") - CmdDrawMultiIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT") - CmdEndConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT") - CmdEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT") - CmdEndQuery = auto_cast GetDeviceProcAddr(device, "vkCmdEndQuery") - CmdEndQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT") - CmdEndRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass") - CmdEndRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2") - CmdEndRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR") - CmdEndRendering = auto_cast GetDeviceProcAddr(device, "vkCmdEndRendering") - CmdEndRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderingKHR") - CmdEndTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT") - CmdExecuteCommands = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteCommands") - CmdExecuteGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV") - CmdFillBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdFillBuffer") - CmdInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT") - CmdNextSubpass = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass") - CmdNextSubpass2 = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2") - CmdNextSubpass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2KHR") - CmdPipelineBarrier = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier") - CmdPipelineBarrier2 = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2") - CmdPipelineBarrier2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR") - CmdPreprocessGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV") - CmdPushConstants = auto_cast GetDeviceProcAddr(device, "vkCmdPushConstants") - CmdPushDescriptorSetKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR") - CmdPushDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR") - CmdResetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent") - CmdResetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2") - CmdResetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2KHR") - CmdResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkCmdResetQueryPool") - CmdResolveImage = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage") - CmdResolveImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2") - CmdResolveImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2KHR") - CmdSetBlendConstants = auto_cast GetDeviceProcAddr(device, "vkCmdSetBlendConstants") - CmdSetCheckpointNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCheckpointNV") - CmdSetCoarseSampleOrderNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV") - CmdSetCullMode = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullMode") - CmdSetCullModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullModeEXT") - CmdSetDepthBias = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBias") - CmdSetDepthBiasEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable") - CmdSetDepthBiasEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT") - CmdSetDepthBounds = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBounds") - CmdSetDepthBoundsTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable") - CmdSetDepthBoundsTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT") - CmdSetDepthCompareOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOp") - CmdSetDepthCompareOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT") - CmdSetDepthTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnable") - CmdSetDepthTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT") - CmdSetDepthWriteEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable") - CmdSetDepthWriteEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT") - CmdSetDeviceMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMask") - CmdSetDeviceMaskKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR") - CmdSetDiscardRectangleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT") - CmdSetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent") - CmdSetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2") - CmdSetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2KHR") - CmdSetExclusiveScissorNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV") - CmdSetFragmentShadingRateEnumNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV") - CmdSetFragmentShadingRateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR") - CmdSetFrontFace = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFace") - CmdSetFrontFaceEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT") - CmdSetLineStippleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEXT") - CmdSetLineWidth = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineWidth") - CmdSetLogicOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEXT") - CmdSetPatchControlPointsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT") - CmdSetPerformanceMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL") - CmdSetPerformanceOverrideINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL") - CmdSetPerformanceStreamMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL") - CmdSetPrimitiveRestartEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable") - CmdSetPrimitiveRestartEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT") - CmdSetPrimitiveTopology = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology") - CmdSetPrimitiveTopologyEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT") - CmdSetRasterizerDiscardEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable") - CmdSetRasterizerDiscardEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT") - CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR") - CmdSetSampleLocationsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT") - CmdSetScissor = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissor") - CmdSetScissorWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCount") - CmdSetScissorWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT") - CmdSetStencilCompareMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilCompareMask") - CmdSetStencilOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOp") - CmdSetStencilOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOpEXT") - CmdSetStencilReference = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilReference") - CmdSetStencilTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnable") - CmdSetStencilTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT") - CmdSetStencilWriteMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilWriteMask") - CmdSetVertexInputEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetVertexInputEXT") - CmdSetViewport = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewport") - CmdSetViewportShadingRatePaletteNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV") - CmdSetViewportWScalingNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV") - CmdSetViewportWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCount") - CmdSetViewportWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT") - CmdSubpassShadingHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI") - CmdTraceRaysIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR") - CmdTraceRaysKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysKHR") - CmdTraceRaysNV = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysNV") - CmdUpdateBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdUpdateBuffer") - CmdWaitEvents = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents") - CmdWaitEvents2 = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2") - CmdWaitEvents2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2KHR") - CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR") - CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV") - CmdWriteBufferMarker2AMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD") - CmdWriteBufferMarkerAMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD") - CmdWriteTimestamp = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp") - CmdWriteTimestamp2 = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2") - CmdWriteTimestamp2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR") - CompileDeferredNV = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV") - CopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR") - CopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR") - CopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR") - CreateAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR") - CreateAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureNV") - CreateBuffer = auto_cast GetDeviceProcAddr(device, "vkCreateBuffer") - CreateBufferView = auto_cast GetDeviceProcAddr(device, "vkCreateBufferView") - CreateCommandPool = auto_cast GetDeviceProcAddr(device, "vkCreateCommandPool") - CreateComputePipelines = auto_cast GetDeviceProcAddr(device, "vkCreateComputePipelines") - CreateCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuFunctionNVX") - CreateCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuModuleNVX") - CreateDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDeferredOperationKHR") - CreateDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorPool") - CreateDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorSetLayout") - CreateDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate") - CreateDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR") - CreateEvent = auto_cast GetDeviceProcAddr(device, "vkCreateEvent") - CreateFence = auto_cast GetDeviceProcAddr(device, "vkCreateFence") - CreateFramebuffer = auto_cast GetDeviceProcAddr(device, "vkCreateFramebuffer") - CreateGraphicsPipelines = auto_cast GetDeviceProcAddr(device, "vkCreateGraphicsPipelines") - CreateImage = auto_cast GetDeviceProcAddr(device, "vkCreateImage") - CreateImageView = auto_cast GetDeviceProcAddr(device, "vkCreateImageView") - CreateIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV") - CreatePipelineCache = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineCache") - CreatePipelineLayout = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineLayout") - CreatePrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlot") - CreatePrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT") - CreateQueryPool = auto_cast GetDeviceProcAddr(device, "vkCreateQueryPool") - CreateRayTracingPipelinesKHR = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR") - CreateRayTracingPipelinesNV = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV") - CreateRenderPass = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass") - CreateRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2") - CreateRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2KHR") - CreateSampler = auto_cast GetDeviceProcAddr(device, "vkCreateSampler") - CreateSamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion") - CreateSamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR") - CreateSemaphore = auto_cast GetDeviceProcAddr(device, "vkCreateSemaphore") - CreateShaderModule = auto_cast GetDeviceProcAddr(device, "vkCreateShaderModule") - CreateSharedSwapchainsKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR") - CreateSwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSwapchainKHR") - CreateValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkCreateValidationCacheEXT") - DebugMarkerSetObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT") - DebugMarkerSetObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT") - DeferredOperationJoinKHR = auto_cast GetDeviceProcAddr(device, "vkDeferredOperationJoinKHR") - DestroyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR") - DestroyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV") - DestroyBuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyBuffer") - DestroyBufferView = auto_cast GetDeviceProcAddr(device, "vkDestroyBufferView") - DestroyCommandPool = auto_cast GetDeviceProcAddr(device, "vkDestroyCommandPool") - DestroyCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuFunctionNVX") - DestroyCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuModuleNVX") - DestroyDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR") - DestroyDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorPool") - DestroyDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout") - DestroyDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate") - DestroyDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR") - DestroyDevice = auto_cast GetDeviceProcAddr(device, "vkDestroyDevice") - DestroyEvent = auto_cast GetDeviceProcAddr(device, "vkDestroyEvent") - DestroyFence = auto_cast GetDeviceProcAddr(device, "vkDestroyFence") - DestroyFramebuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyFramebuffer") - DestroyImage = auto_cast GetDeviceProcAddr(device, "vkDestroyImage") - DestroyImageView = auto_cast GetDeviceProcAddr(device, "vkDestroyImageView") - DestroyIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV") - DestroyPipeline = auto_cast GetDeviceProcAddr(device, "vkDestroyPipeline") - DestroyPipelineCache = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineCache") - DestroyPipelineLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineLayout") - DestroyPrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlot") - DestroyPrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT") - DestroyQueryPool = auto_cast GetDeviceProcAddr(device, "vkDestroyQueryPool") - DestroyRenderPass = auto_cast GetDeviceProcAddr(device, "vkDestroyRenderPass") - DestroySampler = auto_cast GetDeviceProcAddr(device, "vkDestroySampler") - DestroySamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion") - DestroySamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR") - DestroySemaphore = auto_cast GetDeviceProcAddr(device, "vkDestroySemaphore") - DestroyShaderModule = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderModule") - DestroySwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySwapchainKHR") - DestroyValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyValidationCacheEXT") - DeviceWaitIdle = auto_cast GetDeviceProcAddr(device, "vkDeviceWaitIdle") - DisplayPowerControlEXT = auto_cast GetDeviceProcAddr(device, "vkDisplayPowerControlEXT") - EndCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkEndCommandBuffer") - FlushMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkFlushMappedMemoryRanges") - FreeCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkFreeCommandBuffers") - FreeDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkFreeDescriptorSets") - FreeMemory = auto_cast GetDeviceProcAddr(device, "vkFreeMemory") - GetAccelerationStructureBuildSizesKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR") - GetAccelerationStructureDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR") - GetAccelerationStructureHandleNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV") - GetAccelerationStructureMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV") - GetBufferDeviceAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddress") - GetBufferDeviceAddressEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT") - GetBufferDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR") - GetBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements") - GetBufferMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2") - GetBufferMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR") - GetBufferOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress") - GetBufferOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR") - GetCalibratedTimestampsEXT = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT") - GetDeferredOperationMaxConcurrencyKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR") - GetDeferredOperationResultKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR") - GetDescriptorSetHostMappingVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE") - GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") - GetDescriptorSetLayoutSupport = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport") - GetDescriptorSetLayoutSupportKHR = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR") - GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR") - GetDeviceBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements") - GetDeviceBufferMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR") - GetDeviceGroupPeerMemoryFeatures = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures") - GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR") - GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR") - GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT") - GetDeviceGroupSurfacePresentModesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR") - GetDeviceImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements") - GetDeviceImageMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR") - GetDeviceImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements") - GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR") - GetDeviceMemoryCommitment = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment") - GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress") - GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") - GetDeviceProcAddr = auto_cast GetDeviceProcAddr(device, "vkGetDeviceProcAddr") - GetDeviceQueue = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue") - GetDeviceQueue2 = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue2") - GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") - GetEventStatus = auto_cast GetDeviceProcAddr(device, "vkGetEventStatus") - GetFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceFdKHR") - GetFenceStatus = auto_cast GetDeviceProcAddr(device, "vkGetFenceStatus") - GetFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR") - GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV") - GetImageDrmFormatModifierPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT") - GetImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements") - GetImageMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2") - GetImageMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR") - GetImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements") - GetImageSparseMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2") - GetImageSparseMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR") - GetImageSubresourceLayout = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout") - GetImageViewAddressNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewAddressNVX") - GetImageViewHandleNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewHandleNVX") - GetMemoryFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR") - GetMemoryFdPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR") - GetMemoryHostPointerPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT") - GetMemoryRemoteAddressNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV") - GetMemoryWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR") - GetMemoryWin32HandleNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV") - GetMemoryWin32HandlePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR") - GetPastPresentationTimingGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE") - GetPerformanceParameterINTEL = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL") - GetPipelineCacheData = auto_cast GetDeviceProcAddr(device, "vkGetPipelineCacheData") - GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR") - GetPipelineExecutablePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR") - GetPipelineExecutableStatisticsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR") - GetPrivateData = auto_cast GetDeviceProcAddr(device, "vkGetPrivateData") - GetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetPrivateDataEXT") - GetQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkGetQueryPoolResults") - GetQueueCheckpointData2NV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV") - GetQueueCheckpointDataNV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV") - GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") - GetRayTracingShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR") - GetRayTracingShaderGroupHandlesNV = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV") - GetRayTracingShaderGroupStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR") - GetRefreshCycleDurationGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE") - GetRenderAreaGranularity = auto_cast GetDeviceProcAddr(device, "vkGetRenderAreaGranularity") - GetSemaphoreCounterValue = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValue") - GetSemaphoreCounterValueKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR") - GetSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreFdKHR") - GetSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR") - GetShaderInfoAMD = auto_cast GetDeviceProcAddr(device, "vkGetShaderInfoAMD") - GetSwapchainCounterEXT = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainCounterEXT") - GetSwapchainImagesKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainImagesKHR") - GetSwapchainStatusKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainStatusKHR") - GetValidationCacheDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetValidationCacheDataEXT") - ImportFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceFdKHR") - ImportFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR") - ImportSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreFdKHR") - ImportSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR") - InitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL") - InvalidateMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges") - MapMemory = auto_cast GetDeviceProcAddr(device, "vkMapMemory") - MergePipelineCaches = auto_cast GetDeviceProcAddr(device, "vkMergePipelineCaches") - MergeValidationCachesEXT = auto_cast GetDeviceProcAddr(device, "vkMergeValidationCachesEXT") - QueueBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT") - QueueBindSparse = auto_cast GetDeviceProcAddr(device, "vkQueueBindSparse") - QueueEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT") - QueueInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT") - QueuePresentKHR = auto_cast GetDeviceProcAddr(device, "vkQueuePresentKHR") - QueueSetPerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL") - QueueSubmit = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit") - QueueSubmit2 = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2") - QueueSubmit2KHR = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2KHR") - QueueWaitIdle = auto_cast GetDeviceProcAddr(device, "vkQueueWaitIdle") - RegisterDeviceEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDeviceEventEXT") - RegisterDisplayEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDisplayEventEXT") - ReleaseFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT") - ReleasePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL") - ReleaseProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkReleaseProfilingLockKHR") - ResetCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkResetCommandBuffer") - ResetCommandPool = auto_cast GetDeviceProcAddr(device, "vkResetCommandPool") - ResetDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkResetDescriptorPool") - ResetEvent = auto_cast GetDeviceProcAddr(device, "vkResetEvent") - ResetFences = auto_cast GetDeviceProcAddr(device, "vkResetFences") - ResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkResetQueryPool") - ResetQueryPoolEXT = auto_cast GetDeviceProcAddr(device, "vkResetQueryPoolEXT") - SetDebugUtilsObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT") - SetDebugUtilsObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT") - SetDeviceMemoryPriorityEXT = auto_cast GetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT") - SetEvent = auto_cast GetDeviceProcAddr(device, "vkSetEvent") - SetHdrMetadataEXT = auto_cast GetDeviceProcAddr(device, "vkSetHdrMetadataEXT") - SetLocalDimmingAMD = auto_cast GetDeviceProcAddr(device, "vkSetLocalDimmingAMD") - SetPrivateData = auto_cast GetDeviceProcAddr(device, "vkSetPrivateData") - SetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkSetPrivateDataEXT") - SignalSemaphore = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphore") - SignalSemaphoreKHR = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphoreKHR") - TrimCommandPool = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPool") - TrimCommandPoolKHR = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPoolKHR") - UninitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL") - UnmapMemory = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory") - UpdateDescriptorSetWithTemplate = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate") - UpdateDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR") - UpdateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSets") - WaitForFences = auto_cast GetDeviceProcAddr(device, "vkWaitForFences") - WaitForPresentKHR = auto_cast GetDeviceProcAddr(device, "vkWaitForPresentKHR") - WaitSemaphores = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphores") - WaitSemaphoresKHR = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphoresKHR") - WriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR") + AcquireFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT") + AcquireNextImage2KHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImage2KHR") + AcquireNextImageKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireNextImageKHR") + AcquirePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL") + AcquireProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkAcquireProfilingLockKHR") + AllocateCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkAllocateCommandBuffers") + AllocateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkAllocateDescriptorSets") + AllocateMemory = auto_cast GetDeviceProcAddr(device, "vkAllocateMemory") + BeginCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkBeginCommandBuffer") + BindAccelerationStructureMemoryNV = auto_cast GetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV") + BindBufferMemory = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory") + BindBufferMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2") + BindBufferMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindBufferMemory2KHR") + BindImageMemory = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory") + BindImageMemory2 = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2") + BindImageMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkBindImageMemory2KHR") + BindOpticalFlowSessionImageNV = auto_cast GetDeviceProcAddr(device, "vkBindOpticalFlowSessionImageNV") + BindVideoSessionMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkBindVideoSessionMemoryKHR") + BuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR") + BuildMicromapsEXT = auto_cast GetDeviceProcAddr(device, "vkBuildMicromapsEXT") + CmdBeginConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT") + CmdBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT") + CmdBeginQuery = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQuery") + CmdBeginQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT") + CmdBeginRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass") + CmdBeginRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2") + CmdBeginRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR") + CmdBeginRendering = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRendering") + CmdBeginRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginRenderingKHR") + CmdBeginTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT") + CmdBeginVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBeginVideoCodingKHR") + CmdBindDescriptorBufferEmbeddedSamplersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") + CmdBindDescriptorBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorBuffersEXT") + CmdBindDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkCmdBindDescriptorSets") + CmdBindIndexBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdBindIndexBuffer") + CmdBindInvocationMaskHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI") + CmdBindPipeline = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipeline") + CmdBindPipelineShaderGroupNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV") + CmdBindShadersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadersEXT") + CmdBindShadingRateImageNV = auto_cast GetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV") + CmdBindTransformFeedbackBuffersEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT") + CmdBindVertexBuffers = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers") + CmdBindVertexBuffers2 = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2") + CmdBindVertexBuffers2EXT = auto_cast GetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT") + CmdBlitImage = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage") + CmdBlitImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2") + CmdBlitImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdBlitImage2KHR") + CmdBuildAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV") + CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR") + CmdBuildAccelerationStructuresKHR = auto_cast GetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR") + CmdBuildMicromapsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdBuildMicromapsEXT") + CmdClearAttachments = auto_cast GetDeviceProcAddr(device, "vkCmdClearAttachments") + CmdClearColorImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearColorImage") + CmdClearDepthStencilImage = auto_cast GetDeviceProcAddr(device, "vkCmdClearDepthStencilImage") + CmdControlVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR") + CmdCopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR") + CmdCopyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV") + CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR") + CmdCopyBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer") + CmdCopyBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2") + CmdCopyBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR") + CmdCopyBufferToImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage") + CmdCopyBufferToImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2") + CmdCopyBufferToImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR") + CmdCopyImage = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage") + CmdCopyImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2") + CmdCopyImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImage2KHR") + CmdCopyImageToBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer") + CmdCopyImageToBuffer2 = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2") + CmdCopyImageToBuffer2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR") + CmdCopyMemoryIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryIndirectNV") + CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR") + CmdCopyMemoryToImageIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToImageIndirectNV") + CmdCopyMemoryToMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMemoryToMicromapEXT") + CmdCopyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMicromapEXT") + CmdCopyMicromapToMemoryEXT = auto_cast GetDeviceProcAddr(device, "vkCmdCopyMicromapToMemoryEXT") + CmdCopyQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults") + CmdCuLaunchKernelNVX = auto_cast GetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX") + CmdDebugMarkerBeginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT") + CmdDebugMarkerEndEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT") + CmdDebugMarkerInsertEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT") + CmdDecodeVideoKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDecodeVideoKHR") + CmdDecompressMemoryIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDecompressMemoryIndirectCountNV") + CmdDecompressMemoryNV = auto_cast GetDeviceProcAddr(device, "vkCmdDecompressMemoryNV") + CmdDispatch = auto_cast GetDeviceProcAddr(device, "vkCmdDispatch") + CmdDispatchBase = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBase") + CmdDispatchBaseKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchBaseKHR") + CmdDispatchIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDispatchIndirect") + CmdDraw = auto_cast GetDeviceProcAddr(device, "vkCmdDraw") + CmdDrawClusterHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdDrawClusterHUAWEI") + CmdDrawClusterIndirectHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdDrawClusterIndirectHUAWEI") + CmdDrawIndexed = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexed") + CmdDrawIndexedIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect") + CmdDrawIndexedIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount") + CmdDrawIndexedIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD") + CmdDrawIndexedIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR") + CmdDrawIndirect = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirect") + CmdDrawIndirectByteCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT") + CmdDrawIndirectCount = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCount") + CmdDrawIndirectCountAMD = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD") + CmdDrawIndirectCountKHR = auto_cast GetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR") + CmdDrawMeshTasksEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksEXT") + CmdDrawMeshTasksIndirectCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountEXT") + CmdDrawMeshTasksIndirectCountNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV") + CmdDrawMeshTasksIndirectEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectEXT") + CmdDrawMeshTasksIndirectNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV") + CmdDrawMeshTasksNV = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV") + CmdDrawMultiEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiEXT") + CmdDrawMultiIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT") + CmdEndConditionalRenderingEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT") + CmdEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT") + CmdEndQuery = auto_cast GetDeviceProcAddr(device, "vkCmdEndQuery") + CmdEndQueryIndexedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT") + CmdEndRenderPass = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass") + CmdEndRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2") + CmdEndRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR") + CmdEndRendering = auto_cast GetDeviceProcAddr(device, "vkCmdEndRendering") + CmdEndRenderingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndRenderingKHR") + CmdEndTransformFeedbackEXT = auto_cast GetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT") + CmdEndVideoCodingKHR = auto_cast GetDeviceProcAddr(device, "vkCmdEndVideoCodingKHR") + CmdExecuteCommands = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteCommands") + CmdExecuteGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV") + CmdFillBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdFillBuffer") + CmdInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT") + CmdNextSubpass = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass") + CmdNextSubpass2 = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2") + CmdNextSubpass2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdNextSubpass2KHR") + CmdOpticalFlowExecuteNV = auto_cast GetDeviceProcAddr(device, "vkCmdOpticalFlowExecuteNV") + CmdPipelineBarrier = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier") + CmdPipelineBarrier2 = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2") + CmdPipelineBarrier2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR") + CmdPreprocessGeneratedCommandsNV = auto_cast GetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV") + CmdPushConstants = auto_cast GetDeviceProcAddr(device, "vkCmdPushConstants") + CmdPushDescriptorSetKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR") + CmdPushDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR") + CmdResetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent") + CmdResetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2") + CmdResetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResetEvent2KHR") + CmdResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkCmdResetQueryPool") + CmdResolveImage = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage") + CmdResolveImage2 = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2") + CmdResolveImage2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdResolveImage2KHR") + CmdSetAlphaToCoverageEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAlphaToCoverageEnableEXT") + CmdSetAlphaToOneEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAlphaToOneEnableEXT") + CmdSetAttachmentFeedbackLoopEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetAttachmentFeedbackLoopEnableEXT") + CmdSetBlendConstants = auto_cast GetDeviceProcAddr(device, "vkCmdSetBlendConstants") + CmdSetCheckpointNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCheckpointNV") + CmdSetCoarseSampleOrderNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV") + CmdSetColorBlendAdvancedEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendAdvancedEXT") + CmdSetColorBlendEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendEnableEXT") + CmdSetColorBlendEquationEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorBlendEquationEXT") + CmdSetColorWriteMaskEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetColorWriteMaskEXT") + CmdSetConservativeRasterizationModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetConservativeRasterizationModeEXT") + CmdSetCoverageModulationModeNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationModeNV") + CmdSetCoverageModulationTableEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationTableEnableNV") + CmdSetCoverageModulationTableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageModulationTableNV") + CmdSetCoverageReductionModeNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageReductionModeNV") + CmdSetCoverageToColorEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageToColorEnableNV") + CmdSetCoverageToColorLocationNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetCoverageToColorLocationNV") + CmdSetCullMode = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullMode") + CmdSetCullModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetCullModeEXT") + CmdSetDepthBias = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBias") + CmdSetDepthBiasEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable") + CmdSetDepthBiasEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT") + CmdSetDepthBounds = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBounds") + CmdSetDepthBoundsTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable") + CmdSetDepthBoundsTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT") + CmdSetDepthClampEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClampEnableEXT") + CmdSetDepthClipEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClipEnableEXT") + CmdSetDepthClipNegativeOneToOneEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthClipNegativeOneToOneEXT") + CmdSetDepthCompareOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOp") + CmdSetDepthCompareOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT") + CmdSetDepthTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnable") + CmdSetDepthTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT") + CmdSetDepthWriteEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable") + CmdSetDepthWriteEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT") + CmdSetDescriptorBufferOffsetsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDescriptorBufferOffsetsEXT") + CmdSetDeviceMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMask") + CmdSetDeviceMaskKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR") + CmdSetDiscardRectangleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT") + CmdSetDiscardRectangleEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEnableEXT") + CmdSetDiscardRectangleModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetDiscardRectangleModeEXT") + CmdSetEvent = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent") + CmdSetEvent2 = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2") + CmdSetEvent2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetEvent2KHR") + CmdSetExclusiveScissorEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorEnableNV") + CmdSetExclusiveScissorNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV") + CmdSetExtraPrimitiveOverestimationSizeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") + CmdSetFragmentShadingRateEnumNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV") + CmdSetFragmentShadingRateKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR") + CmdSetFrontFace = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFace") + CmdSetFrontFaceEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT") + CmdSetLineRasterizationModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineRasterizationModeEXT") + CmdSetLineStippleEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEXT") + CmdSetLineStippleEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineStippleEnableEXT") + CmdSetLineWidth = auto_cast GetDeviceProcAddr(device, "vkCmdSetLineWidth") + CmdSetLogicOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEXT") + CmdSetLogicOpEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetLogicOpEnableEXT") + CmdSetPatchControlPointsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT") + CmdSetPerformanceMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL") + CmdSetPerformanceOverrideINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL") + CmdSetPerformanceStreamMarkerINTEL = auto_cast GetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL") + CmdSetPolygonModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPolygonModeEXT") + CmdSetPrimitiveRestartEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable") + CmdSetPrimitiveRestartEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT") + CmdSetPrimitiveTopology = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology") + CmdSetPrimitiveTopologyEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT") + CmdSetProvokingVertexModeEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetProvokingVertexModeEXT") + CmdSetRasterizationSamplesEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizationSamplesEXT") + CmdSetRasterizationStreamEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizationStreamEXT") + CmdSetRasterizerDiscardEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable") + CmdSetRasterizerDiscardEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT") + CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR") + CmdSetRepresentativeFragmentTestEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetRepresentativeFragmentTestEnableNV") + CmdSetSampleLocationsEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT") + CmdSetSampleLocationsEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleLocationsEnableEXT") + CmdSetSampleMaskEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetSampleMaskEXT") + CmdSetScissor = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissor") + CmdSetScissorWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCount") + CmdSetScissorWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT") + CmdSetShadingRateImageEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetShadingRateImageEnableNV") + CmdSetStencilCompareMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilCompareMask") + CmdSetStencilOp = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOp") + CmdSetStencilOpEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilOpEXT") + CmdSetStencilReference = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilReference") + CmdSetStencilTestEnable = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnable") + CmdSetStencilTestEnableEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT") + CmdSetStencilWriteMask = auto_cast GetDeviceProcAddr(device, "vkCmdSetStencilWriteMask") + CmdSetTessellationDomainOriginEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetTessellationDomainOriginEXT") + CmdSetVertexInputEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetVertexInputEXT") + CmdSetViewport = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewport") + CmdSetViewportShadingRatePaletteNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV") + CmdSetViewportSwizzleNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportSwizzleNV") + CmdSetViewportWScalingEnableNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingEnableNV") + CmdSetViewportWScalingNV = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV") + CmdSetViewportWithCount = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCount") + CmdSetViewportWithCountEXT = auto_cast GetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT") + CmdSubpassShadingHUAWEI = auto_cast GetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI") + CmdTraceRaysIndirect2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirect2KHR") + CmdTraceRaysIndirectKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR") + CmdTraceRaysKHR = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysKHR") + CmdTraceRaysNV = auto_cast GetDeviceProcAddr(device, "vkCmdTraceRaysNV") + CmdUpdateBuffer = auto_cast GetDeviceProcAddr(device, "vkCmdUpdateBuffer") + CmdWaitEvents = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents") + CmdWaitEvents2 = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2") + CmdWaitEvents2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWaitEvents2KHR") + CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR") + CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV") + CmdWriteBufferMarker2AMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD") + CmdWriteBufferMarkerAMD = auto_cast GetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD") + CmdWriteMicromapsPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkCmdWriteMicromapsPropertiesEXT") + CmdWriteTimestamp = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp") + CmdWriteTimestamp2 = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2") + CmdWriteTimestamp2KHR = auto_cast GetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR") + CompileDeferredNV = auto_cast GetDeviceProcAddr(device, "vkCompileDeferredNV") + CopyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR") + CopyAccelerationStructureToMemoryKHR = auto_cast GetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR") + CopyMemoryToAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR") + CopyMemoryToMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMemoryToMicromapEXT") + CopyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMicromapEXT") + CopyMicromapToMemoryEXT = auto_cast GetDeviceProcAddr(device, "vkCopyMicromapToMemoryEXT") + CreateAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR") + CreateAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkCreateAccelerationStructureNV") + CreateBuffer = auto_cast GetDeviceProcAddr(device, "vkCreateBuffer") + CreateBufferView = auto_cast GetDeviceProcAddr(device, "vkCreateBufferView") + CreateCommandPool = auto_cast GetDeviceProcAddr(device, "vkCreateCommandPool") + CreateComputePipelines = auto_cast GetDeviceProcAddr(device, "vkCreateComputePipelines") + CreateCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuFunctionNVX") + CreateCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkCreateCuModuleNVX") + CreateDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDeferredOperationKHR") + CreateDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorPool") + CreateDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorSetLayout") + CreateDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate") + CreateDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR") + CreateEvent = auto_cast GetDeviceProcAddr(device, "vkCreateEvent") + CreateFence = auto_cast GetDeviceProcAddr(device, "vkCreateFence") + CreateFramebuffer = auto_cast GetDeviceProcAddr(device, "vkCreateFramebuffer") + CreateGraphicsPipelines = auto_cast GetDeviceProcAddr(device, "vkCreateGraphicsPipelines") + CreateImage = auto_cast GetDeviceProcAddr(device, "vkCreateImage") + CreateImageView = auto_cast GetDeviceProcAddr(device, "vkCreateImageView") + CreateIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV") + CreateMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkCreateMicromapEXT") + CreateOpticalFlowSessionNV = auto_cast GetDeviceProcAddr(device, "vkCreateOpticalFlowSessionNV") + CreatePipelineCache = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineCache") + CreatePipelineLayout = auto_cast GetDeviceProcAddr(device, "vkCreatePipelineLayout") + CreatePrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlot") + CreatePrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT") + CreateQueryPool = auto_cast GetDeviceProcAddr(device, "vkCreateQueryPool") + CreateRayTracingPipelinesKHR = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR") + CreateRayTracingPipelinesNV = auto_cast GetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV") + CreateRenderPass = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass") + CreateRenderPass2 = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2") + CreateRenderPass2KHR = auto_cast GetDeviceProcAddr(device, "vkCreateRenderPass2KHR") + CreateSampler = auto_cast GetDeviceProcAddr(device, "vkCreateSampler") + CreateSamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion") + CreateSamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR") + CreateSemaphore = auto_cast GetDeviceProcAddr(device, "vkCreateSemaphore") + CreateShaderModule = auto_cast GetDeviceProcAddr(device, "vkCreateShaderModule") + CreateShadersEXT = auto_cast GetDeviceProcAddr(device, "vkCreateShadersEXT") + CreateSharedSwapchainsKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR") + CreateSwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkCreateSwapchainKHR") + CreateValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkCreateValidationCacheEXT") + CreateVideoSessionKHR = auto_cast GetDeviceProcAddr(device, "vkCreateVideoSessionKHR") + CreateVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkCreateVideoSessionParametersKHR") + DebugMarkerSetObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT") + DebugMarkerSetObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT") + DeferredOperationJoinKHR = auto_cast GetDeviceProcAddr(device, "vkDeferredOperationJoinKHR") + DestroyAccelerationStructureKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR") + DestroyAccelerationStructureNV = auto_cast GetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV") + DestroyBuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyBuffer") + DestroyBufferView = auto_cast GetDeviceProcAddr(device, "vkDestroyBufferView") + DestroyCommandPool = auto_cast GetDeviceProcAddr(device, "vkDestroyCommandPool") + DestroyCuFunctionNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuFunctionNVX") + DestroyCuModuleNVX = auto_cast GetDeviceProcAddr(device, "vkDestroyCuModuleNVX") + DestroyDeferredOperationKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR") + DestroyDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorPool") + DestroyDescriptorSetLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout") + DestroyDescriptorUpdateTemplate = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate") + DestroyDescriptorUpdateTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR") + DestroyDevice = auto_cast GetDeviceProcAddr(device, "vkDestroyDevice") + DestroyEvent = auto_cast GetDeviceProcAddr(device, "vkDestroyEvent") + DestroyFence = auto_cast GetDeviceProcAddr(device, "vkDestroyFence") + DestroyFramebuffer = auto_cast GetDeviceProcAddr(device, "vkDestroyFramebuffer") + DestroyImage = auto_cast GetDeviceProcAddr(device, "vkDestroyImage") + DestroyImageView = auto_cast GetDeviceProcAddr(device, "vkDestroyImageView") + DestroyIndirectCommandsLayoutNV = auto_cast GetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV") + DestroyMicromapEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyMicromapEXT") + DestroyOpticalFlowSessionNV = auto_cast GetDeviceProcAddr(device, "vkDestroyOpticalFlowSessionNV") + DestroyPipeline = auto_cast GetDeviceProcAddr(device, "vkDestroyPipeline") + DestroyPipelineCache = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineCache") + DestroyPipelineLayout = auto_cast GetDeviceProcAddr(device, "vkDestroyPipelineLayout") + DestroyPrivateDataSlot = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlot") + DestroyPrivateDataSlotEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT") + DestroyQueryPool = auto_cast GetDeviceProcAddr(device, "vkDestroyQueryPool") + DestroyRenderPass = auto_cast GetDeviceProcAddr(device, "vkDestroyRenderPass") + DestroySampler = auto_cast GetDeviceProcAddr(device, "vkDestroySampler") + DestroySamplerYcbcrConversion = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion") + DestroySamplerYcbcrConversionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR") + DestroySemaphore = auto_cast GetDeviceProcAddr(device, "vkDestroySemaphore") + DestroyShaderEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderEXT") + DestroyShaderModule = auto_cast GetDeviceProcAddr(device, "vkDestroyShaderModule") + DestroySwapchainKHR = auto_cast GetDeviceProcAddr(device, "vkDestroySwapchainKHR") + DestroyValidationCacheEXT = auto_cast GetDeviceProcAddr(device, "vkDestroyValidationCacheEXT") + DestroyVideoSessionKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyVideoSessionKHR") + DestroyVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkDestroyVideoSessionParametersKHR") + DeviceWaitIdle = auto_cast GetDeviceProcAddr(device, "vkDeviceWaitIdle") + DisplayPowerControlEXT = auto_cast GetDeviceProcAddr(device, "vkDisplayPowerControlEXT") + EndCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkEndCommandBuffer") + ExportMetalObjectsEXT = auto_cast GetDeviceProcAddr(device, "vkExportMetalObjectsEXT") + FlushMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkFlushMappedMemoryRanges") + FreeCommandBuffers = auto_cast GetDeviceProcAddr(device, "vkFreeCommandBuffers") + FreeDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkFreeDescriptorSets") + FreeMemory = auto_cast GetDeviceProcAddr(device, "vkFreeMemory") + GetAccelerationStructureBuildSizesKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR") + GetAccelerationStructureDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR") + GetAccelerationStructureHandleNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV") + GetAccelerationStructureMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV") + GetAccelerationStructureOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") + GetBufferDeviceAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddress") + GetBufferDeviceAddressEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT") + GetBufferDeviceAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR") + GetBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements") + GetBufferMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2") + GetBufferMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR") + GetBufferOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress") + GetBufferOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR") + GetBufferOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT") + GetCalibratedTimestampsEXT = auto_cast GetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT") + GetDeferredOperationMaxConcurrencyKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR") + GetDeferredOperationResultKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR") + GetDescriptorEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorEXT") + GetDescriptorSetHostMappingVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE") + GetDescriptorSetLayoutBindingOffsetEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutBindingOffsetEXT") + GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") + GetDescriptorSetLayoutSizeEXT = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSizeEXT") + GetDescriptorSetLayoutSupport = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport") + GetDescriptorSetLayoutSupportKHR = auto_cast GetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR") + GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR") + GetDeviceBufferMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements") + GetDeviceBufferMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR") + GetDeviceFaultInfoEXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceFaultInfoEXT") + GetDeviceGroupPeerMemoryFeatures = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures") + GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR") + GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR") + GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT") + GetDeviceGroupSurfacePresentModesKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR") + GetDeviceImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements") + GetDeviceImageMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR") + GetDeviceImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements") + GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR") + GetDeviceMemoryCommitment = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment") + GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress") + GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") + GetDeviceMicromapCompatibilityEXT = auto_cast GetDeviceProcAddr(device, "vkGetDeviceMicromapCompatibilityEXT") + GetDeviceProcAddr = auto_cast GetDeviceProcAddr(device, "vkGetDeviceProcAddr") + GetDeviceQueue = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue") + GetDeviceQueue2 = auto_cast GetDeviceProcAddr(device, "vkGetDeviceQueue2") + GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") + GetDynamicRenderingTilePropertiesQCOM = auto_cast GetDeviceProcAddr(device, "vkGetDynamicRenderingTilePropertiesQCOM") + GetEventStatus = auto_cast GetDeviceProcAddr(device, "vkGetEventStatus") + GetFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceFdKHR") + GetFenceStatus = auto_cast GetDeviceProcAddr(device, "vkGetFenceStatus") + GetFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR") + GetFramebufferTilePropertiesQCOM = auto_cast GetDeviceProcAddr(device, "vkGetFramebufferTilePropertiesQCOM") + GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV") + GetImageDrmFormatModifierPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT") + GetImageMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements") + GetImageMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2") + GetImageMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR") + GetImageOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageOpaqueCaptureDescriptorDataEXT") + GetImageSparseMemoryRequirements = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements") + GetImageSparseMemoryRequirements2 = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2") + GetImageSparseMemoryRequirements2KHR = auto_cast GetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR") + GetImageSubresourceLayout = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout") + GetImageSubresourceLayout2EXT = auto_cast GetDeviceProcAddr(device, "vkGetImageSubresourceLayout2EXT") + GetImageViewAddressNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewAddressNVX") + GetImageViewHandleNVX = auto_cast GetDeviceProcAddr(device, "vkGetImageViewHandleNVX") + GetImageViewOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") + GetMemoryFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdKHR") + GetMemoryFdPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR") + GetMemoryHostPointerPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT") + GetMemoryRemoteAddressNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV") + GetMemoryWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR") + GetMemoryWin32HandleNV = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV") + GetMemoryWin32HandlePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR") + GetMicromapBuildSizesEXT = auto_cast GetDeviceProcAddr(device, "vkGetMicromapBuildSizesEXT") + GetPastPresentationTimingGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE") + GetPerformanceParameterINTEL = auto_cast GetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL") + GetPipelineCacheData = auto_cast GetDeviceProcAddr(device, "vkGetPipelineCacheData") + GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR") + GetPipelineExecutablePropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR") + GetPipelineExecutableStatisticsKHR = auto_cast GetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR") + GetPipelinePropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkGetPipelinePropertiesEXT") + GetPrivateData = auto_cast GetDeviceProcAddr(device, "vkGetPrivateData") + GetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetPrivateDataEXT") + GetQueryPoolResults = auto_cast GetDeviceProcAddr(device, "vkGetQueryPoolResults") + GetQueueCheckpointData2NV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV") + GetQueueCheckpointDataNV = auto_cast GetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV") + GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") + GetRayTracingShaderGroupHandlesKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR") + GetRayTracingShaderGroupHandlesNV = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV") + GetRayTracingShaderGroupStackSizeKHR = auto_cast GetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR") + GetRefreshCycleDurationGOOGLE = auto_cast GetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE") + GetRenderAreaGranularity = auto_cast GetDeviceProcAddr(device, "vkGetRenderAreaGranularity") + GetSamplerOpaqueCaptureDescriptorDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") + GetSemaphoreCounterValue = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValue") + GetSemaphoreCounterValueKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR") + GetSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreFdKHR") + GetSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR") + GetShaderBinaryDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderBinaryDataEXT") + GetShaderInfoAMD = auto_cast GetDeviceProcAddr(device, "vkGetShaderInfoAMD") + GetShaderModuleCreateInfoIdentifierEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderModuleCreateInfoIdentifierEXT") + GetShaderModuleIdentifierEXT = auto_cast GetDeviceProcAddr(device, "vkGetShaderModuleIdentifierEXT") + GetSwapchainCounterEXT = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainCounterEXT") + GetSwapchainImagesKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainImagesKHR") + GetSwapchainStatusKHR = auto_cast GetDeviceProcAddr(device, "vkGetSwapchainStatusKHR") + GetValidationCacheDataEXT = auto_cast GetDeviceProcAddr(device, "vkGetValidationCacheDataEXT") + GetVideoSessionMemoryRequirementsKHR = auto_cast GetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR") + ImportFenceFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceFdKHR") + ImportFenceWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR") + ImportSemaphoreFdKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreFdKHR") + ImportSemaphoreWin32HandleKHR = auto_cast GetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR") + InitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL") + InvalidateMappedMemoryRanges = auto_cast GetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges") + MapMemory = auto_cast GetDeviceProcAddr(device, "vkMapMemory") + MapMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkMapMemory2KHR") + MergePipelineCaches = auto_cast GetDeviceProcAddr(device, "vkMergePipelineCaches") + MergeValidationCachesEXT = auto_cast GetDeviceProcAddr(device, "vkMergeValidationCachesEXT") + QueueBeginDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT") + QueueBindSparse = auto_cast GetDeviceProcAddr(device, "vkQueueBindSparse") + QueueEndDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT") + QueueInsertDebugUtilsLabelEXT = auto_cast GetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT") + QueuePresentKHR = auto_cast GetDeviceProcAddr(device, "vkQueuePresentKHR") + QueueSetPerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL") + QueueSubmit = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit") + QueueSubmit2 = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2") + QueueSubmit2KHR = auto_cast GetDeviceProcAddr(device, "vkQueueSubmit2KHR") + QueueWaitIdle = auto_cast GetDeviceProcAddr(device, "vkQueueWaitIdle") + RegisterDeviceEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDeviceEventEXT") + RegisterDisplayEventEXT = auto_cast GetDeviceProcAddr(device, "vkRegisterDisplayEventEXT") + ReleaseFullScreenExclusiveModeEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT") + ReleasePerformanceConfigurationINTEL = auto_cast GetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL") + ReleaseProfilingLockKHR = auto_cast GetDeviceProcAddr(device, "vkReleaseProfilingLockKHR") + ReleaseSwapchainImagesEXT = auto_cast GetDeviceProcAddr(device, "vkReleaseSwapchainImagesEXT") + ResetCommandBuffer = auto_cast GetDeviceProcAddr(device, "vkResetCommandBuffer") + ResetCommandPool = auto_cast GetDeviceProcAddr(device, "vkResetCommandPool") + ResetDescriptorPool = auto_cast GetDeviceProcAddr(device, "vkResetDescriptorPool") + ResetEvent = auto_cast GetDeviceProcAddr(device, "vkResetEvent") + ResetFences = auto_cast GetDeviceProcAddr(device, "vkResetFences") + ResetQueryPool = auto_cast GetDeviceProcAddr(device, "vkResetQueryPool") + ResetQueryPoolEXT = auto_cast GetDeviceProcAddr(device, "vkResetQueryPoolEXT") + SetDebugUtilsObjectNameEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT") + SetDebugUtilsObjectTagEXT = auto_cast GetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT") + SetDeviceMemoryPriorityEXT = auto_cast GetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT") + SetEvent = auto_cast GetDeviceProcAddr(device, "vkSetEvent") + SetHdrMetadataEXT = auto_cast GetDeviceProcAddr(device, "vkSetHdrMetadataEXT") + SetLocalDimmingAMD = auto_cast GetDeviceProcAddr(device, "vkSetLocalDimmingAMD") + SetPrivateData = auto_cast GetDeviceProcAddr(device, "vkSetPrivateData") + SetPrivateDataEXT = auto_cast GetDeviceProcAddr(device, "vkSetPrivateDataEXT") + SignalSemaphore = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphore") + SignalSemaphoreKHR = auto_cast GetDeviceProcAddr(device, "vkSignalSemaphoreKHR") + TrimCommandPool = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPool") + TrimCommandPoolKHR = auto_cast GetDeviceProcAddr(device, "vkTrimCommandPoolKHR") + UninitializePerformanceApiINTEL = auto_cast GetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL") + UnmapMemory = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory") + UnmapMemory2KHR = auto_cast GetDeviceProcAddr(device, "vkUnmapMemory2KHR") + UpdateDescriptorSetWithTemplate = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate") + UpdateDescriptorSetWithTemplateKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR") + UpdateDescriptorSets = auto_cast GetDeviceProcAddr(device, "vkUpdateDescriptorSets") + UpdateVideoSessionParametersKHR = auto_cast GetDeviceProcAddr(device, "vkUpdateVideoSessionParametersKHR") + WaitForFences = auto_cast GetDeviceProcAddr(device, "vkWaitForFences") + WaitForPresentKHR = auto_cast GetDeviceProcAddr(device, "vkWaitForPresentKHR") + WaitSemaphores = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphores") + WaitSemaphoresKHR = auto_cast GetDeviceProcAddr(device, "vkWaitSemaphoresKHR") + WriteAccelerationStructuresPropertiesKHR = auto_cast GetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR") + WriteMicromapsPropertiesEXT = auto_cast GetDeviceProcAddr(device, "vkWriteMicromapsPropertiesEXT") } load_proc_addresses_instance :: proc(instance: Instance) { @@ -2846,6 +3458,7 @@ load_proc_addresses_instance :: proc(instance: Instance) { GetDisplayPlaneCapabilitiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR") GetDisplayPlaneSupportedDisplaysKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR") GetDrmDisplayEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDrmDisplayEXT") + GetInstanceProcAddrLUNARG = auto_cast GetInstanceProcAddr(instance, "vkGetInstanceProcAddrLUNARG") GetPhysicalDeviceCalibrateableTimeDomainsEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT") GetPhysicalDeviceCooperativeMatrixPropertiesNV = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV") GetPhysicalDeviceDisplayPlaneProperties2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") @@ -2873,6 +3486,7 @@ load_proc_addresses_instance :: proc(instance: Instance) { GetPhysicalDeviceMemoryProperties2 = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2") GetPhysicalDeviceMemoryProperties2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR") GetPhysicalDeviceMultisamplePropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT") + GetPhysicalDeviceOpticalFlowImageFormatsNV = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV") GetPhysicalDevicePresentRectanglesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR") GetPhysicalDeviceProperties = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties") GetPhysicalDeviceProperties2 = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2") @@ -2895,6 +3509,8 @@ load_proc_addresses_instance :: proc(instance: Instance) { GetPhysicalDeviceSurfaceSupportKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR") GetPhysicalDeviceToolProperties = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties") GetPhysicalDeviceToolPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT") + GetPhysicalDeviceVideoCapabilitiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR") + GetPhysicalDeviceVideoFormatPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR") GetPhysicalDeviceWaylandPresentationSupportKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR") GetPhysicalDeviceWin32PresentationSupportKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR") GetWinrtDisplayNV = auto_cast GetInstanceProcAddr(instance, "vkGetWinrtDisplayNV") @@ -2902,422 +3518,522 @@ load_proc_addresses_instance :: proc(instance: Instance) { SubmitDebugUtilsMessageEXT = auto_cast GetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT") // Device Procedures (may call into dispatch) - AcquireFullScreenExclusiveModeEXT = auto_cast GetInstanceProcAddr(instance, "vkAcquireFullScreenExclusiveModeEXT") - AcquireNextImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireNextImage2KHR") - AcquireNextImageKHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireNextImageKHR") - AcquirePerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL") - AcquireProfilingLockKHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR") - AllocateCommandBuffers = auto_cast GetInstanceProcAddr(instance, "vkAllocateCommandBuffers") - AllocateDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkAllocateDescriptorSets") - AllocateMemory = auto_cast GetInstanceProcAddr(instance, "vkAllocateMemory") - BeginCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkBeginCommandBuffer") - BindAccelerationStructureMemoryNV = auto_cast GetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV") - BindBufferMemory = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory") - BindBufferMemory2 = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory2") - BindBufferMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory2KHR") - BindImageMemory = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory") - BindImageMemory2 = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory2") - BindImageMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory2KHR") - BuildAccelerationStructuresKHR = auto_cast GetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR") - CmdBeginConditionalRenderingEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT") - CmdBeginDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT") - CmdBeginQuery = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginQuery") - CmdBeginQueryIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT") - CmdBeginRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass") - CmdBeginRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass2") - CmdBeginRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR") - CmdBeginRendering = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRendering") - CmdBeginRenderingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderingKHR") - CmdBeginTransformFeedbackEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT") - CmdBindDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkCmdBindDescriptorSets") - CmdBindIndexBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdBindIndexBuffer") - CmdBindInvocationMaskHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI") - CmdBindPipeline = auto_cast GetInstanceProcAddr(instance, "vkCmdBindPipeline") - CmdBindPipelineShaderGroupNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV") - CmdBindShadingRateImageNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV") - CmdBindTransformFeedbackBuffersEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT") - CmdBindVertexBuffers = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers") - CmdBindVertexBuffers2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2") - CmdBindVertexBuffers2EXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2EXT") - CmdBlitImage = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage") - CmdBlitImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage2") - CmdBlitImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage2KHR") - CmdBuildAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV") - CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR") - CmdBuildAccelerationStructuresKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR") - CmdClearAttachments = auto_cast GetInstanceProcAddr(instance, "vkCmdClearAttachments") - CmdClearColorImage = auto_cast GetInstanceProcAddr(instance, "vkCmdClearColorImage") - CmdClearDepthStencilImage = auto_cast GetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage") - CmdCopyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR") - CmdCopyAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV") - CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR") - CmdCopyBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer") - CmdCopyBuffer2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer2") - CmdCopyBuffer2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer2KHR") - CmdCopyBufferToImage = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage") - CmdCopyBufferToImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2") - CmdCopyBufferToImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2KHR") - CmdCopyImage = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage") - CmdCopyImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage2") - CmdCopyImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage2KHR") - CmdCopyImageToBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer") - CmdCopyImageToBuffer2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2") - CmdCopyImageToBuffer2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2KHR") - CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR") - CmdCopyQueryPoolResults = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults") - CmdCuLaunchKernelNVX = auto_cast GetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX") - CmdDebugMarkerBeginEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerBeginEXT") - CmdDebugMarkerEndEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerEndEXT") - CmdDebugMarkerInsertEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT") - CmdDispatch = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatch") - CmdDispatchBase = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchBase") - CmdDispatchBaseKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR") - CmdDispatchIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchIndirect") - CmdDraw = auto_cast GetInstanceProcAddr(instance, "vkCmdDraw") - CmdDrawIndexed = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexed") - CmdDrawIndexedIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect") - CmdDrawIndexedIndirectCount = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount") - CmdDrawIndexedIndirectCountAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD") - CmdDrawIndexedIndirectCountKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR") - CmdDrawIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirect") - CmdDrawIndirectByteCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT") - CmdDrawIndirectCount = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCount") - CmdDrawIndirectCountAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD") - CmdDrawIndirectCountKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR") - CmdDrawMeshTasksIndirectCountNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV") - CmdDrawMeshTasksIndirectNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV") - CmdDrawMeshTasksNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV") - CmdDrawMultiEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMultiEXT") - CmdDrawMultiIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT") - CmdEndConditionalRenderingEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT") - CmdEndDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT") - CmdEndQuery = auto_cast GetInstanceProcAddr(instance, "vkCmdEndQuery") - CmdEndQueryIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT") - CmdEndRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass") - CmdEndRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass2") - CmdEndRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR") - CmdEndRendering = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRendering") - CmdEndRenderingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderingKHR") - CmdEndTransformFeedbackEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT") - CmdExecuteCommands = auto_cast GetInstanceProcAddr(instance, "vkCmdExecuteCommands") - CmdExecuteGeneratedCommandsNV = auto_cast GetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV") - CmdFillBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdFillBuffer") - CmdInsertDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT") - CmdNextSubpass = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass") - CmdNextSubpass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass2") - CmdNextSubpass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR") - CmdPipelineBarrier = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier") - CmdPipelineBarrier2 = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier2") - CmdPipelineBarrier2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier2KHR") - CmdPreprocessGeneratedCommandsNV = auto_cast GetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV") - CmdPushConstants = auto_cast GetInstanceProcAddr(instance, "vkCmdPushConstants") - CmdPushDescriptorSetKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR") - CmdPushDescriptorSetWithTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR") - CmdResetEvent = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent") - CmdResetEvent2 = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent2") - CmdResetEvent2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent2KHR") - CmdResetQueryPool = auto_cast GetInstanceProcAddr(instance, "vkCmdResetQueryPool") - CmdResolveImage = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage") - CmdResolveImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage2") - CmdResolveImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage2KHR") - CmdSetBlendConstants = auto_cast GetInstanceProcAddr(instance, "vkCmdSetBlendConstants") - CmdSetCheckpointNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCheckpointNV") - CmdSetCoarseSampleOrderNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV") - CmdSetCullMode = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCullMode") - CmdSetCullModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCullModeEXT") - CmdSetDepthBias = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBias") - CmdSetDepthBiasEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable") - CmdSetDepthBiasEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnableEXT") - CmdSetDepthBounds = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBounds") - CmdSetDepthBoundsTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable") - CmdSetDepthBoundsTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnableEXT") - CmdSetDepthCompareOp = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp") - CmdSetDepthCompareOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthCompareOpEXT") - CmdSetDepthTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable") - CmdSetDepthTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthTestEnableEXT") - CmdSetDepthWriteEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable") - CmdSetDepthWriteEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnableEXT") - CmdSetDeviceMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDeviceMask") - CmdSetDeviceMaskKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR") - CmdSetDiscardRectangleEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT") - CmdSetEvent = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent") - CmdSetEvent2 = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent2") - CmdSetEvent2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent2KHR") - CmdSetExclusiveScissorNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV") - CmdSetFragmentShadingRateEnumNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV") - CmdSetFragmentShadingRateKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR") - CmdSetFrontFace = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFrontFace") - CmdSetFrontFaceEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFrontFaceEXT") - CmdSetLineStippleEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT") - CmdSetLineWidth = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineWidth") - CmdSetLogicOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLogicOpEXT") - CmdSetPatchControlPointsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPatchControlPointsEXT") - CmdSetPerformanceMarkerINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL") - CmdSetPerformanceOverrideINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL") - CmdSetPerformanceStreamMarkerINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL") - CmdSetPrimitiveRestartEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable") - CmdSetPrimitiveRestartEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnableEXT") - CmdSetPrimitiveTopology = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology") - CmdSetPrimitiveTopologyEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopologyEXT") - CmdSetRasterizerDiscardEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable") - CmdSetRasterizerDiscardEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnableEXT") - CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR") - CmdSetSampleLocationsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT") - CmdSetScissor = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissor") - CmdSetScissorWithCount = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissorWithCount") - CmdSetScissorWithCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissorWithCountEXT") - CmdSetStencilCompareMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask") - CmdSetStencilOp = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilOp") - CmdSetStencilOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT") - CmdSetStencilReference = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilReference") - CmdSetStencilTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable") - CmdSetStencilTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilTestEnableEXT") - CmdSetStencilWriteMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask") - CmdSetVertexInputEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT") - CmdSetViewport = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewport") - CmdSetViewportShadingRatePaletteNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV") - CmdSetViewportWScalingNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV") - CmdSetViewportWithCount = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWithCount") - CmdSetViewportWithCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWithCountEXT") - CmdSubpassShadingHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI") - CmdTraceRaysIndirectKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR") - CmdTraceRaysKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysKHR") - CmdTraceRaysNV = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysNV") - CmdUpdateBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdUpdateBuffer") - CmdWaitEvents = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents") - CmdWaitEvents2 = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents2") - CmdWaitEvents2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents2KHR") - CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR") - CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV") - CmdWriteBufferMarker2AMD = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteBufferMarker2AMD") - CmdWriteBufferMarkerAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD") - CmdWriteTimestamp = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp") - CmdWriteTimestamp2 = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2") - CmdWriteTimestamp2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2KHR") - CompileDeferredNV = auto_cast GetInstanceProcAddr(instance, "vkCompileDeferredNV") - CopyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR") - CopyAccelerationStructureToMemoryKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR") - CopyMemoryToAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR") - CreateAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR") - CreateAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV") - CreateBuffer = auto_cast GetInstanceProcAddr(instance, "vkCreateBuffer") - CreateBufferView = auto_cast GetInstanceProcAddr(instance, "vkCreateBufferView") - CreateCommandPool = auto_cast GetInstanceProcAddr(instance, "vkCreateCommandPool") - CreateComputePipelines = auto_cast GetInstanceProcAddr(instance, "vkCreateComputePipelines") - CreateCuFunctionNVX = auto_cast GetInstanceProcAddr(instance, "vkCreateCuFunctionNVX") - CreateCuModuleNVX = auto_cast GetInstanceProcAddr(instance, "vkCreateCuModuleNVX") - CreateDeferredOperationKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR") - CreateDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorPool") - CreateDescriptorSetLayout = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout") - CreateDescriptorUpdateTemplate = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate") - CreateDescriptorUpdateTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplateKHR") - CreateEvent = auto_cast GetInstanceProcAddr(instance, "vkCreateEvent") - CreateFence = auto_cast GetInstanceProcAddr(instance, "vkCreateFence") - CreateFramebuffer = auto_cast GetInstanceProcAddr(instance, "vkCreateFramebuffer") - CreateGraphicsPipelines = auto_cast GetInstanceProcAddr(instance, "vkCreateGraphicsPipelines") - CreateImage = auto_cast GetInstanceProcAddr(instance, "vkCreateImage") - CreateImageView = auto_cast GetInstanceProcAddr(instance, "vkCreateImageView") - CreateIndirectCommandsLayoutNV = auto_cast GetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV") - CreatePipelineCache = auto_cast GetInstanceProcAddr(instance, "vkCreatePipelineCache") - CreatePipelineLayout = auto_cast GetInstanceProcAddr(instance, "vkCreatePipelineLayout") - CreatePrivateDataSlot = auto_cast GetInstanceProcAddr(instance, "vkCreatePrivateDataSlot") - CreatePrivateDataSlotEXT = auto_cast GetInstanceProcAddr(instance, "vkCreatePrivateDataSlotEXT") - CreateQueryPool = auto_cast GetInstanceProcAddr(instance, "vkCreateQueryPool") - CreateRayTracingPipelinesKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesKHR") - CreateRayTracingPipelinesNV = auto_cast GetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV") - CreateRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass") - CreateRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass2") - CreateRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass2KHR") - CreateSampler = auto_cast GetInstanceProcAddr(instance, "vkCreateSampler") - CreateSamplerYcbcrConversion = auto_cast GetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion") - CreateSamplerYcbcrConversionKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR") - CreateSemaphore = auto_cast GetInstanceProcAddr(instance, "vkCreateSemaphore") - CreateShaderModule = auto_cast GetInstanceProcAddr(instance, "vkCreateShaderModule") - CreateSharedSwapchainsKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR") - CreateSwapchainKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSwapchainKHR") - CreateValidationCacheEXT = auto_cast GetInstanceProcAddr(instance, "vkCreateValidationCacheEXT") - DebugMarkerSetObjectNameEXT = auto_cast GetInstanceProcAddr(instance, "vkDebugMarkerSetObjectNameEXT") - DebugMarkerSetObjectTagEXT = auto_cast GetInstanceProcAddr(instance, "vkDebugMarkerSetObjectTagEXT") - DeferredOperationJoinKHR = auto_cast GetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR") - DestroyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR") - DestroyAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV") - DestroyBuffer = auto_cast GetInstanceProcAddr(instance, "vkDestroyBuffer") - DestroyBufferView = auto_cast GetInstanceProcAddr(instance, "vkDestroyBufferView") - DestroyCommandPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyCommandPool") - DestroyCuFunctionNVX = auto_cast GetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX") - DestroyCuModuleNVX = auto_cast GetInstanceProcAddr(instance, "vkDestroyCuModuleNVX") - DestroyDeferredOperationKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR") - DestroyDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorPool") - DestroyDescriptorSetLayout = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout") - DestroyDescriptorUpdateTemplate = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate") - DestroyDescriptorUpdateTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplateKHR") - DestroyDevice = auto_cast GetInstanceProcAddr(instance, "vkDestroyDevice") - DestroyEvent = auto_cast GetInstanceProcAddr(instance, "vkDestroyEvent") - DestroyFence = auto_cast GetInstanceProcAddr(instance, "vkDestroyFence") - DestroyFramebuffer = auto_cast GetInstanceProcAddr(instance, "vkDestroyFramebuffer") - DestroyImage = auto_cast GetInstanceProcAddr(instance, "vkDestroyImage") - DestroyImageView = auto_cast GetInstanceProcAddr(instance, "vkDestroyImageView") - DestroyIndirectCommandsLayoutNV = auto_cast GetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV") - DestroyPipeline = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipeline") - DestroyPipelineCache = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipelineCache") - DestroyPipelineLayout = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipelineLayout") - DestroyPrivateDataSlot = auto_cast GetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot") - DestroyPrivateDataSlotEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyPrivateDataSlotEXT") - DestroyQueryPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyQueryPool") - DestroyRenderPass = auto_cast GetInstanceProcAddr(instance, "vkDestroyRenderPass") - DestroySampler = auto_cast GetInstanceProcAddr(instance, "vkDestroySampler") - DestroySamplerYcbcrConversion = auto_cast GetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion") - DestroySamplerYcbcrConversionKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR") - DestroySemaphore = auto_cast GetInstanceProcAddr(instance, "vkDestroySemaphore") - DestroyShaderModule = auto_cast GetInstanceProcAddr(instance, "vkDestroyShaderModule") - DestroySwapchainKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroySwapchainKHR") - DestroyValidationCacheEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT") - DeviceWaitIdle = auto_cast GetInstanceProcAddr(instance, "vkDeviceWaitIdle") - DisplayPowerControlEXT = auto_cast GetInstanceProcAddr(instance, "vkDisplayPowerControlEXT") - EndCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkEndCommandBuffer") - FlushMappedMemoryRanges = auto_cast GetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges") - FreeCommandBuffers = auto_cast GetInstanceProcAddr(instance, "vkFreeCommandBuffers") - FreeDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkFreeDescriptorSets") - FreeMemory = auto_cast GetInstanceProcAddr(instance, "vkFreeMemory") - GetAccelerationStructureBuildSizesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR") - GetAccelerationStructureDeviceAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR") - GetAccelerationStructureHandleNV = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV") - GetAccelerationStructureMemoryRequirementsNV = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV") - GetBufferDeviceAddress = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddress") - GetBufferDeviceAddressEXT = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT") - GetBufferDeviceAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR") - GetBufferMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements") - GetBufferMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2") - GetBufferMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR") - GetBufferOpaqueCaptureAddress = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress") - GetBufferOpaqueCaptureAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR") - GetCalibratedTimestampsEXT = auto_cast GetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT") - GetDeferredOperationMaxConcurrencyKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR") - GetDeferredOperationResultKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR") - GetDescriptorSetHostMappingVALVE = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE") - GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") - GetDescriptorSetLayoutSupport = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport") - GetDescriptorSetLayoutSupportKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR") - GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR") - GetDeviceBufferMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements") - GetDeviceBufferMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirementsKHR") - GetDeviceGroupPeerMemoryFeatures = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures") - GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR") - GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR") - GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModes2EXT") - GetDeviceGroupSurfacePresentModesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR") - GetDeviceImageMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements") - GetDeviceImageMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirementsKHR") - GetDeviceImageSparseMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements") - GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirementsKHR") - GetDeviceMemoryCommitment = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment") - GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress") - GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") - GetDeviceProcAddr = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceProcAddr") - GetDeviceQueue = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceQueue") - GetDeviceQueue2 = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceQueue2") - GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") - GetEventStatus = auto_cast GetInstanceProcAddr(instance, "vkGetEventStatus") - GetFenceFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetFenceFdKHR") - GetFenceStatus = auto_cast GetInstanceProcAddr(instance, "vkGetFenceStatus") - GetFenceWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetFenceWin32HandleKHR") - GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV") - GetImageDrmFormatModifierPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT") - GetImageMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements") - GetImageMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2") - GetImageMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR") - GetImageSparseMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements") - GetImageSparseMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2") - GetImageSparseMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2KHR") - GetImageSubresourceLayout = auto_cast GetInstanceProcAddr(instance, "vkGetImageSubresourceLayout") - GetImageViewAddressNVX = auto_cast GetInstanceProcAddr(instance, "vkGetImageViewAddressNVX") - GetImageViewHandleNVX = auto_cast GetInstanceProcAddr(instance, "vkGetImageViewHandleNVX") - GetMemoryFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdKHR") - GetMemoryFdPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR") - GetMemoryHostPointerPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT") - GetMemoryRemoteAddressNV = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV") - GetMemoryWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleKHR") - GetMemoryWin32HandleNV = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleNV") - GetMemoryWin32HandlePropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandlePropertiesKHR") - GetPastPresentationTimingGOOGLE = auto_cast GetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE") - GetPerformanceParameterINTEL = auto_cast GetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL") - GetPipelineCacheData = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineCacheData") - GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR") - GetPipelineExecutablePropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR") - GetPipelineExecutableStatisticsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR") - GetPrivateData = auto_cast GetInstanceProcAddr(instance, "vkGetPrivateData") - GetPrivateDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPrivateDataEXT") - GetQueryPoolResults = auto_cast GetInstanceProcAddr(instance, "vkGetQueryPoolResults") - GetQueueCheckpointData2NV = auto_cast GetInstanceProcAddr(instance, "vkGetQueueCheckpointData2NV") - GetQueueCheckpointDataNV = auto_cast GetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV") - GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") - GetRayTracingShaderGroupHandlesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR") - GetRayTracingShaderGroupHandlesNV = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesNV") - GetRayTracingShaderGroupStackSizeKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR") - GetRefreshCycleDurationGOOGLE = auto_cast GetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE") - GetRenderAreaGranularity = auto_cast GetInstanceProcAddr(instance, "vkGetRenderAreaGranularity") - GetSemaphoreCounterValue = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue") - GetSemaphoreCounterValueKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR") - GetSemaphoreFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR") - GetSemaphoreWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreWin32HandleKHR") - GetShaderInfoAMD = auto_cast GetInstanceProcAddr(instance, "vkGetShaderInfoAMD") - GetSwapchainCounterEXT = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT") - GetSwapchainImagesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR") - GetSwapchainStatusKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR") - GetValidationCacheDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT") - ImportFenceFdKHR = auto_cast GetInstanceProcAddr(instance, "vkImportFenceFdKHR") - ImportFenceWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkImportFenceWin32HandleKHR") - ImportSemaphoreFdKHR = auto_cast GetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR") - ImportSemaphoreWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkImportSemaphoreWin32HandleKHR") - InitializePerformanceApiINTEL = auto_cast GetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL") - InvalidateMappedMemoryRanges = auto_cast GetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges") - MapMemory = auto_cast GetInstanceProcAddr(instance, "vkMapMemory") - MergePipelineCaches = auto_cast GetInstanceProcAddr(instance, "vkMergePipelineCaches") - MergeValidationCachesEXT = auto_cast GetInstanceProcAddr(instance, "vkMergeValidationCachesEXT") - QueueBeginDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT") - QueueBindSparse = auto_cast GetInstanceProcAddr(instance, "vkQueueBindSparse") - QueueEndDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT") - QueueInsertDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT") - QueuePresentKHR = auto_cast GetInstanceProcAddr(instance, "vkQueuePresentKHR") - QueueSetPerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL") - QueueSubmit = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit") - QueueSubmit2 = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit2") - QueueSubmit2KHR = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit2KHR") - QueueWaitIdle = auto_cast GetInstanceProcAddr(instance, "vkQueueWaitIdle") - RegisterDeviceEventEXT = auto_cast GetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT") - RegisterDisplayEventEXT = auto_cast GetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT") - ReleaseFullScreenExclusiveModeEXT = auto_cast GetInstanceProcAddr(instance, "vkReleaseFullScreenExclusiveModeEXT") - ReleasePerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL") - ReleaseProfilingLockKHR = auto_cast GetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR") - ResetCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkResetCommandBuffer") - ResetCommandPool = auto_cast GetInstanceProcAddr(instance, "vkResetCommandPool") - ResetDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkResetDescriptorPool") - ResetEvent = auto_cast GetInstanceProcAddr(instance, "vkResetEvent") - ResetFences = auto_cast GetInstanceProcAddr(instance, "vkResetFences") - ResetQueryPool = auto_cast GetInstanceProcAddr(instance, "vkResetQueryPool") - ResetQueryPoolEXT = auto_cast GetInstanceProcAddr(instance, "vkResetQueryPoolEXT") - SetDebugUtilsObjectNameEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT") - SetDebugUtilsObjectTagEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT") - SetDeviceMemoryPriorityEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT") - SetEvent = auto_cast GetInstanceProcAddr(instance, "vkSetEvent") - SetHdrMetadataEXT = auto_cast GetInstanceProcAddr(instance, "vkSetHdrMetadataEXT") - SetLocalDimmingAMD = auto_cast GetInstanceProcAddr(instance, "vkSetLocalDimmingAMD") - SetPrivateData = auto_cast GetInstanceProcAddr(instance, "vkSetPrivateData") - SetPrivateDataEXT = auto_cast GetInstanceProcAddr(instance, "vkSetPrivateDataEXT") - SignalSemaphore = auto_cast GetInstanceProcAddr(instance, "vkSignalSemaphore") - SignalSemaphoreKHR = auto_cast GetInstanceProcAddr(instance, "vkSignalSemaphoreKHR") - TrimCommandPool = auto_cast GetInstanceProcAddr(instance, "vkTrimCommandPool") - TrimCommandPoolKHR = auto_cast GetInstanceProcAddr(instance, "vkTrimCommandPoolKHR") - UninitializePerformanceApiINTEL = auto_cast GetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL") - UnmapMemory = auto_cast GetInstanceProcAddr(instance, "vkUnmapMemory") - UpdateDescriptorSetWithTemplate = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate") - UpdateDescriptorSetWithTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplateKHR") - UpdateDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSets") - WaitForFences = auto_cast GetInstanceProcAddr(instance, "vkWaitForFences") - WaitForPresentKHR = auto_cast GetInstanceProcAddr(instance, "vkWaitForPresentKHR") - WaitSemaphores = auto_cast GetInstanceProcAddr(instance, "vkWaitSemaphores") - WaitSemaphoresKHR = auto_cast GetInstanceProcAddr(instance, "vkWaitSemaphoresKHR") - WriteAccelerationStructuresPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkWriteAccelerationStructuresPropertiesKHR") + AcquireFullScreenExclusiveModeEXT = auto_cast GetInstanceProcAddr(instance, "vkAcquireFullScreenExclusiveModeEXT") + AcquireNextImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireNextImage2KHR") + AcquireNextImageKHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireNextImageKHR") + AcquirePerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL") + AcquireProfilingLockKHR = auto_cast GetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR") + AllocateCommandBuffers = auto_cast GetInstanceProcAddr(instance, "vkAllocateCommandBuffers") + AllocateDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkAllocateDescriptorSets") + AllocateMemory = auto_cast GetInstanceProcAddr(instance, "vkAllocateMemory") + BeginCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkBeginCommandBuffer") + BindAccelerationStructureMemoryNV = auto_cast GetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV") + BindBufferMemory = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory") + BindBufferMemory2 = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory2") + BindBufferMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkBindBufferMemory2KHR") + BindImageMemory = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory") + BindImageMemory2 = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory2") + BindImageMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkBindImageMemory2KHR") + BindOpticalFlowSessionImageNV = auto_cast GetInstanceProcAddr(instance, "vkBindOpticalFlowSessionImageNV") + BindVideoSessionMemoryKHR = auto_cast GetInstanceProcAddr(instance, "vkBindVideoSessionMemoryKHR") + BuildAccelerationStructuresKHR = auto_cast GetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR") + BuildMicromapsEXT = auto_cast GetInstanceProcAddr(instance, "vkBuildMicromapsEXT") + CmdBeginConditionalRenderingEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT") + CmdBeginDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT") + CmdBeginQuery = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginQuery") + CmdBeginQueryIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT") + CmdBeginRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass") + CmdBeginRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass2") + CmdBeginRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR") + CmdBeginRendering = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRendering") + CmdBeginRenderingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginRenderingKHR") + CmdBeginTransformFeedbackEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT") + CmdBeginVideoCodingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBeginVideoCodingKHR") + CmdBindDescriptorBufferEmbeddedSamplersEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") + CmdBindDescriptorBuffersEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindDescriptorBuffersEXT") + CmdBindDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkCmdBindDescriptorSets") + CmdBindIndexBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdBindIndexBuffer") + CmdBindInvocationMaskHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI") + CmdBindPipeline = auto_cast GetInstanceProcAddr(instance, "vkCmdBindPipeline") + CmdBindPipelineShaderGroupNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV") + CmdBindShadersEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindShadersEXT") + CmdBindShadingRateImageNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV") + CmdBindTransformFeedbackBuffersEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT") + CmdBindVertexBuffers = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers") + CmdBindVertexBuffers2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2") + CmdBindVertexBuffers2EXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2EXT") + CmdBlitImage = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage") + CmdBlitImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage2") + CmdBlitImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBlitImage2KHR") + CmdBuildAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV") + CmdBuildAccelerationStructuresIndirectKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR") + CmdBuildAccelerationStructuresKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR") + CmdBuildMicromapsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdBuildMicromapsEXT") + CmdClearAttachments = auto_cast GetInstanceProcAddr(instance, "vkCmdClearAttachments") + CmdClearColorImage = auto_cast GetInstanceProcAddr(instance, "vkCmdClearColorImage") + CmdClearDepthStencilImage = auto_cast GetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage") + CmdControlVideoCodingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdControlVideoCodingKHR") + CmdCopyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR") + CmdCopyAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV") + CmdCopyAccelerationStructureToMemoryKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR") + CmdCopyBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer") + CmdCopyBuffer2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer2") + CmdCopyBuffer2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBuffer2KHR") + CmdCopyBufferToImage = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage") + CmdCopyBufferToImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2") + CmdCopyBufferToImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2KHR") + CmdCopyImage = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage") + CmdCopyImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage2") + CmdCopyImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImage2KHR") + CmdCopyImageToBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer") + CmdCopyImageToBuffer2 = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2") + CmdCopyImageToBuffer2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2KHR") + CmdCopyMemoryIndirectNV = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMemoryIndirectNV") + CmdCopyMemoryToAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR") + CmdCopyMemoryToImageIndirectNV = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMemoryToImageIndirectNV") + CmdCopyMemoryToMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMemoryToMicromapEXT") + CmdCopyMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMicromapEXT") + CmdCopyMicromapToMemoryEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyMicromapToMemoryEXT") + CmdCopyQueryPoolResults = auto_cast GetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults") + CmdCuLaunchKernelNVX = auto_cast GetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX") + CmdDebugMarkerBeginEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerBeginEXT") + CmdDebugMarkerEndEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerEndEXT") + CmdDebugMarkerInsertEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT") + CmdDecodeVideoKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDecodeVideoKHR") + CmdDecompressMemoryIndirectCountNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDecompressMemoryIndirectCountNV") + CmdDecompressMemoryNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDecompressMemoryNV") + CmdDispatch = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatch") + CmdDispatchBase = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchBase") + CmdDispatchBaseKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR") + CmdDispatchIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDispatchIndirect") + CmdDraw = auto_cast GetInstanceProcAddr(instance, "vkCmdDraw") + CmdDrawClusterHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawClusterHUAWEI") + CmdDrawClusterIndirectHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawClusterIndirectHUAWEI") + CmdDrawIndexed = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexed") + CmdDrawIndexedIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect") + CmdDrawIndexedIndirectCount = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount") + CmdDrawIndexedIndirectCountAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD") + CmdDrawIndexedIndirectCountKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR") + CmdDrawIndirect = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirect") + CmdDrawIndirectByteCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT") + CmdDrawIndirectCount = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCount") + CmdDrawIndirectCountAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD") + CmdDrawIndirectCountKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR") + CmdDrawMeshTasksEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksEXT") + CmdDrawMeshTasksIndirectCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountEXT") + CmdDrawMeshTasksIndirectCountNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV") + CmdDrawMeshTasksIndirectEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectEXT") + CmdDrawMeshTasksIndirectNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV") + CmdDrawMeshTasksNV = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV") + CmdDrawMultiEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMultiEXT") + CmdDrawMultiIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT") + CmdEndConditionalRenderingEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT") + CmdEndDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT") + CmdEndQuery = auto_cast GetInstanceProcAddr(instance, "vkCmdEndQuery") + CmdEndQueryIndexedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT") + CmdEndRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass") + CmdEndRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass2") + CmdEndRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR") + CmdEndRendering = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRendering") + CmdEndRenderingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdEndRenderingKHR") + CmdEndTransformFeedbackEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT") + CmdEndVideoCodingKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdEndVideoCodingKHR") + CmdExecuteCommands = auto_cast GetInstanceProcAddr(instance, "vkCmdExecuteCommands") + CmdExecuteGeneratedCommandsNV = auto_cast GetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV") + CmdFillBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdFillBuffer") + CmdInsertDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT") + CmdNextSubpass = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass") + CmdNextSubpass2 = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass2") + CmdNextSubpass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR") + CmdOpticalFlowExecuteNV = auto_cast GetInstanceProcAddr(instance, "vkCmdOpticalFlowExecuteNV") + CmdPipelineBarrier = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier") + CmdPipelineBarrier2 = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier2") + CmdPipelineBarrier2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPipelineBarrier2KHR") + CmdPreprocessGeneratedCommandsNV = auto_cast GetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV") + CmdPushConstants = auto_cast GetInstanceProcAddr(instance, "vkCmdPushConstants") + CmdPushDescriptorSetKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR") + CmdPushDescriptorSetWithTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR") + CmdResetEvent = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent") + CmdResetEvent2 = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent2") + CmdResetEvent2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdResetEvent2KHR") + CmdResetQueryPool = auto_cast GetInstanceProcAddr(instance, "vkCmdResetQueryPool") + CmdResolveImage = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage") + CmdResolveImage2 = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage2") + CmdResolveImage2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdResolveImage2KHR") + CmdSetAlphaToCoverageEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetAlphaToCoverageEnableEXT") + CmdSetAlphaToOneEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetAlphaToOneEnableEXT") + CmdSetAttachmentFeedbackLoopEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT") + CmdSetBlendConstants = auto_cast GetInstanceProcAddr(instance, "vkCmdSetBlendConstants") + CmdSetCheckpointNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCheckpointNV") + CmdSetCoarseSampleOrderNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV") + CmdSetColorBlendAdvancedEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetColorBlendAdvancedEXT") + CmdSetColorBlendEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetColorBlendEnableEXT") + CmdSetColorBlendEquationEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetColorBlendEquationEXT") + CmdSetColorWriteMaskEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetColorWriteMaskEXT") + CmdSetConservativeRasterizationModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetConservativeRasterizationModeEXT") + CmdSetCoverageModulationModeNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageModulationModeNV") + CmdSetCoverageModulationTableEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableEnableNV") + CmdSetCoverageModulationTableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageModulationTableNV") + CmdSetCoverageReductionModeNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageReductionModeNV") + CmdSetCoverageToColorEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageToColorEnableNV") + CmdSetCoverageToColorLocationNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCoverageToColorLocationNV") + CmdSetCullMode = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCullMode") + CmdSetCullModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetCullModeEXT") + CmdSetDepthBias = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBias") + CmdSetDepthBiasEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable") + CmdSetDepthBiasEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnableEXT") + CmdSetDepthBounds = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBounds") + CmdSetDepthBoundsTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable") + CmdSetDepthBoundsTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnableEXT") + CmdSetDepthClampEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthClampEnableEXT") + CmdSetDepthClipEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthClipEnableEXT") + CmdSetDepthClipNegativeOneToOneEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthClipNegativeOneToOneEXT") + CmdSetDepthCompareOp = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp") + CmdSetDepthCompareOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthCompareOpEXT") + CmdSetDepthTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable") + CmdSetDepthTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthTestEnableEXT") + CmdSetDepthWriteEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable") + CmdSetDepthWriteEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnableEXT") + CmdSetDescriptorBufferOffsetsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDescriptorBufferOffsetsEXT") + CmdSetDeviceMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDeviceMask") + CmdSetDeviceMaskKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR") + CmdSetDiscardRectangleEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT") + CmdSetDiscardRectangleEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEnableEXT") + CmdSetDiscardRectangleModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleModeEXT") + CmdSetEvent = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent") + CmdSetEvent2 = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent2") + CmdSetEvent2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetEvent2KHR") + CmdSetExclusiveScissorEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorEnableNV") + CmdSetExclusiveScissorNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV") + CmdSetExtraPrimitiveOverestimationSizeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") + CmdSetFragmentShadingRateEnumNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV") + CmdSetFragmentShadingRateKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR") + CmdSetFrontFace = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFrontFace") + CmdSetFrontFaceEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetFrontFaceEXT") + CmdSetLineRasterizationModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineRasterizationModeEXT") + CmdSetLineStippleEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT") + CmdSetLineStippleEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineStippleEnableEXT") + CmdSetLineWidth = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLineWidth") + CmdSetLogicOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLogicOpEXT") + CmdSetLogicOpEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetLogicOpEnableEXT") + CmdSetPatchControlPointsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPatchControlPointsEXT") + CmdSetPerformanceMarkerINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL") + CmdSetPerformanceOverrideINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL") + CmdSetPerformanceStreamMarkerINTEL = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL") + CmdSetPolygonModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPolygonModeEXT") + CmdSetPrimitiveRestartEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable") + CmdSetPrimitiveRestartEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnableEXT") + CmdSetPrimitiveTopology = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology") + CmdSetPrimitiveTopologyEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopologyEXT") + CmdSetProvokingVertexModeEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetProvokingVertexModeEXT") + CmdSetRasterizationSamplesEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizationSamplesEXT") + CmdSetRasterizationStreamEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizationStreamEXT") + CmdSetRasterizerDiscardEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable") + CmdSetRasterizerDiscardEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnableEXT") + CmdSetRayTracingPipelineStackSizeKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR") + CmdSetRepresentativeFragmentTestEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetRepresentativeFragmentTestEnableNV") + CmdSetSampleLocationsEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT") + CmdSetSampleLocationsEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEnableEXT") + CmdSetSampleMaskEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetSampleMaskEXT") + CmdSetScissor = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissor") + CmdSetScissorWithCount = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissorWithCount") + CmdSetScissorWithCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetScissorWithCountEXT") + CmdSetShadingRateImageEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetShadingRateImageEnableNV") + CmdSetStencilCompareMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask") + CmdSetStencilOp = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilOp") + CmdSetStencilOpEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT") + CmdSetStencilReference = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilReference") + CmdSetStencilTestEnable = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable") + CmdSetStencilTestEnableEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilTestEnableEXT") + CmdSetStencilWriteMask = auto_cast GetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask") + CmdSetTessellationDomainOriginEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetTessellationDomainOriginEXT") + CmdSetVertexInputEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT") + CmdSetViewport = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewport") + CmdSetViewportShadingRatePaletteNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV") + CmdSetViewportSwizzleNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportSwizzleNV") + CmdSetViewportWScalingEnableNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWScalingEnableNV") + CmdSetViewportWScalingNV = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV") + CmdSetViewportWithCount = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWithCount") + CmdSetViewportWithCountEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdSetViewportWithCountEXT") + CmdSubpassShadingHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI") + CmdTraceRaysIndirect2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysIndirect2KHR") + CmdTraceRaysIndirectKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR") + CmdTraceRaysKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysKHR") + CmdTraceRaysNV = auto_cast GetInstanceProcAddr(instance, "vkCmdTraceRaysNV") + CmdUpdateBuffer = auto_cast GetInstanceProcAddr(instance, "vkCmdUpdateBuffer") + CmdWaitEvents = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents") + CmdWaitEvents2 = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents2") + CmdWaitEvents2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWaitEvents2KHR") + CmdWriteAccelerationStructuresPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR") + CmdWriteAccelerationStructuresPropertiesNV = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV") + CmdWriteBufferMarker2AMD = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteBufferMarker2AMD") + CmdWriteBufferMarkerAMD = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD") + CmdWriteMicromapsPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteMicromapsPropertiesEXT") + CmdWriteTimestamp = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp") + CmdWriteTimestamp2 = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2") + CmdWriteTimestamp2KHR = auto_cast GetInstanceProcAddr(instance, "vkCmdWriteTimestamp2KHR") + CompileDeferredNV = auto_cast GetInstanceProcAddr(instance, "vkCompileDeferredNV") + CopyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR") + CopyAccelerationStructureToMemoryKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR") + CopyMemoryToAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR") + CopyMemoryToMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkCopyMemoryToMicromapEXT") + CopyMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkCopyMicromapEXT") + CopyMicromapToMemoryEXT = auto_cast GetInstanceProcAddr(instance, "vkCopyMicromapToMemoryEXT") + CreateAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR") + CreateAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV") + CreateBuffer = auto_cast GetInstanceProcAddr(instance, "vkCreateBuffer") + CreateBufferView = auto_cast GetInstanceProcAddr(instance, "vkCreateBufferView") + CreateCommandPool = auto_cast GetInstanceProcAddr(instance, "vkCreateCommandPool") + CreateComputePipelines = auto_cast GetInstanceProcAddr(instance, "vkCreateComputePipelines") + CreateCuFunctionNVX = auto_cast GetInstanceProcAddr(instance, "vkCreateCuFunctionNVX") + CreateCuModuleNVX = auto_cast GetInstanceProcAddr(instance, "vkCreateCuModuleNVX") + CreateDeferredOperationKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR") + CreateDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorPool") + CreateDescriptorSetLayout = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout") + CreateDescriptorUpdateTemplate = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate") + CreateDescriptorUpdateTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplateKHR") + CreateEvent = auto_cast GetInstanceProcAddr(instance, "vkCreateEvent") + CreateFence = auto_cast GetInstanceProcAddr(instance, "vkCreateFence") + CreateFramebuffer = auto_cast GetInstanceProcAddr(instance, "vkCreateFramebuffer") + CreateGraphicsPipelines = auto_cast GetInstanceProcAddr(instance, "vkCreateGraphicsPipelines") + CreateImage = auto_cast GetInstanceProcAddr(instance, "vkCreateImage") + CreateImageView = auto_cast GetInstanceProcAddr(instance, "vkCreateImageView") + CreateIndirectCommandsLayoutNV = auto_cast GetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV") + CreateMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkCreateMicromapEXT") + CreateOpticalFlowSessionNV = auto_cast GetInstanceProcAddr(instance, "vkCreateOpticalFlowSessionNV") + CreatePipelineCache = auto_cast GetInstanceProcAddr(instance, "vkCreatePipelineCache") + CreatePipelineLayout = auto_cast GetInstanceProcAddr(instance, "vkCreatePipelineLayout") + CreatePrivateDataSlot = auto_cast GetInstanceProcAddr(instance, "vkCreatePrivateDataSlot") + CreatePrivateDataSlotEXT = auto_cast GetInstanceProcAddr(instance, "vkCreatePrivateDataSlotEXT") + CreateQueryPool = auto_cast GetInstanceProcAddr(instance, "vkCreateQueryPool") + CreateRayTracingPipelinesKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesKHR") + CreateRayTracingPipelinesNV = auto_cast GetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV") + CreateRenderPass = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass") + CreateRenderPass2 = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass2") + CreateRenderPass2KHR = auto_cast GetInstanceProcAddr(instance, "vkCreateRenderPass2KHR") + CreateSampler = auto_cast GetInstanceProcAddr(instance, "vkCreateSampler") + CreateSamplerYcbcrConversion = auto_cast GetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion") + CreateSamplerYcbcrConversionKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR") + CreateSemaphore = auto_cast GetInstanceProcAddr(instance, "vkCreateSemaphore") + CreateShaderModule = auto_cast GetInstanceProcAddr(instance, "vkCreateShaderModule") + CreateShadersEXT = auto_cast GetInstanceProcAddr(instance, "vkCreateShadersEXT") + CreateSharedSwapchainsKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR") + CreateSwapchainKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateSwapchainKHR") + CreateValidationCacheEXT = auto_cast GetInstanceProcAddr(instance, "vkCreateValidationCacheEXT") + CreateVideoSessionKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateVideoSessionKHR") + CreateVideoSessionParametersKHR = auto_cast GetInstanceProcAddr(instance, "vkCreateVideoSessionParametersKHR") + DebugMarkerSetObjectNameEXT = auto_cast GetInstanceProcAddr(instance, "vkDebugMarkerSetObjectNameEXT") + DebugMarkerSetObjectTagEXT = auto_cast GetInstanceProcAddr(instance, "vkDebugMarkerSetObjectTagEXT") + DeferredOperationJoinKHR = auto_cast GetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR") + DestroyAccelerationStructureKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR") + DestroyAccelerationStructureNV = auto_cast GetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV") + DestroyBuffer = auto_cast GetInstanceProcAddr(instance, "vkDestroyBuffer") + DestroyBufferView = auto_cast GetInstanceProcAddr(instance, "vkDestroyBufferView") + DestroyCommandPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyCommandPool") + DestroyCuFunctionNVX = auto_cast GetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX") + DestroyCuModuleNVX = auto_cast GetInstanceProcAddr(instance, "vkDestroyCuModuleNVX") + DestroyDeferredOperationKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR") + DestroyDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorPool") + DestroyDescriptorSetLayout = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout") + DestroyDescriptorUpdateTemplate = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate") + DestroyDescriptorUpdateTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplateKHR") + DestroyDevice = auto_cast GetInstanceProcAddr(instance, "vkDestroyDevice") + DestroyEvent = auto_cast GetInstanceProcAddr(instance, "vkDestroyEvent") + DestroyFence = auto_cast GetInstanceProcAddr(instance, "vkDestroyFence") + DestroyFramebuffer = auto_cast GetInstanceProcAddr(instance, "vkDestroyFramebuffer") + DestroyImage = auto_cast GetInstanceProcAddr(instance, "vkDestroyImage") + DestroyImageView = auto_cast GetInstanceProcAddr(instance, "vkDestroyImageView") + DestroyIndirectCommandsLayoutNV = auto_cast GetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV") + DestroyMicromapEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyMicromapEXT") + DestroyOpticalFlowSessionNV = auto_cast GetInstanceProcAddr(instance, "vkDestroyOpticalFlowSessionNV") + DestroyPipeline = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipeline") + DestroyPipelineCache = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipelineCache") + DestroyPipelineLayout = auto_cast GetInstanceProcAddr(instance, "vkDestroyPipelineLayout") + DestroyPrivateDataSlot = auto_cast GetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot") + DestroyPrivateDataSlotEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyPrivateDataSlotEXT") + DestroyQueryPool = auto_cast GetInstanceProcAddr(instance, "vkDestroyQueryPool") + DestroyRenderPass = auto_cast GetInstanceProcAddr(instance, "vkDestroyRenderPass") + DestroySampler = auto_cast GetInstanceProcAddr(instance, "vkDestroySampler") + DestroySamplerYcbcrConversion = auto_cast GetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion") + DestroySamplerYcbcrConversionKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR") + DestroySemaphore = auto_cast GetInstanceProcAddr(instance, "vkDestroySemaphore") + DestroyShaderEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyShaderEXT") + DestroyShaderModule = auto_cast GetInstanceProcAddr(instance, "vkDestroyShaderModule") + DestroySwapchainKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroySwapchainKHR") + DestroyValidationCacheEXT = auto_cast GetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT") + DestroyVideoSessionKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyVideoSessionKHR") + DestroyVideoSessionParametersKHR = auto_cast GetInstanceProcAddr(instance, "vkDestroyVideoSessionParametersKHR") + DeviceWaitIdle = auto_cast GetInstanceProcAddr(instance, "vkDeviceWaitIdle") + DisplayPowerControlEXT = auto_cast GetInstanceProcAddr(instance, "vkDisplayPowerControlEXT") + EndCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkEndCommandBuffer") + ExportMetalObjectsEXT = auto_cast GetInstanceProcAddr(instance, "vkExportMetalObjectsEXT") + FlushMappedMemoryRanges = auto_cast GetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges") + FreeCommandBuffers = auto_cast GetInstanceProcAddr(instance, "vkFreeCommandBuffers") + FreeDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkFreeDescriptorSets") + FreeMemory = auto_cast GetInstanceProcAddr(instance, "vkFreeMemory") + GetAccelerationStructureBuildSizesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR") + GetAccelerationStructureDeviceAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR") + GetAccelerationStructureHandleNV = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV") + GetAccelerationStructureMemoryRequirementsNV = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV") + GetAccelerationStructureOpaqueCaptureDescriptorDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") + GetBufferDeviceAddress = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddress") + GetBufferDeviceAddressEXT = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT") + GetBufferDeviceAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR") + GetBufferMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements") + GetBufferMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2") + GetBufferMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR") + GetBufferOpaqueCaptureAddress = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress") + GetBufferOpaqueCaptureAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR") + GetBufferOpaqueCaptureDescriptorDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT") + GetCalibratedTimestampsEXT = auto_cast GetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT") + GetDeferredOperationMaxConcurrencyKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR") + GetDeferredOperationResultKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR") + GetDescriptorEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorEXT") + GetDescriptorSetHostMappingVALVE = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE") + GetDescriptorSetLayoutBindingOffsetEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutBindingOffsetEXT") + GetDescriptorSetLayoutHostMappingInfoVALVE = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") + GetDescriptorSetLayoutSizeEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSizeEXT") + GetDescriptorSetLayoutSupport = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport") + GetDescriptorSetLayoutSupportKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR") + GetDeviceAccelerationStructureCompatibilityKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR") + GetDeviceBufferMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements") + GetDeviceBufferMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirementsKHR") + GetDeviceFaultInfoEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceFaultInfoEXT") + GetDeviceGroupPeerMemoryFeatures = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures") + GetDeviceGroupPeerMemoryFeaturesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR") + GetDeviceGroupPresentCapabilitiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR") + GetDeviceGroupSurfacePresentModes2EXT = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModes2EXT") + GetDeviceGroupSurfacePresentModesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR") + GetDeviceImageMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements") + GetDeviceImageMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirementsKHR") + GetDeviceImageSparseMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements") + GetDeviceImageSparseMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirementsKHR") + GetDeviceMemoryCommitment = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment") + GetDeviceMemoryOpaqueCaptureAddress = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress") + GetDeviceMemoryOpaqueCaptureAddressKHR = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") + GetDeviceMicromapCompatibilityEXT = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceMicromapCompatibilityEXT") + GetDeviceProcAddr = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceProcAddr") + GetDeviceQueue = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceQueue") + GetDeviceQueue2 = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceQueue2") + GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = auto_cast GetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") + GetDynamicRenderingTilePropertiesQCOM = auto_cast GetInstanceProcAddr(instance, "vkGetDynamicRenderingTilePropertiesQCOM") + GetEventStatus = auto_cast GetInstanceProcAddr(instance, "vkGetEventStatus") + GetFenceFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetFenceFdKHR") + GetFenceStatus = auto_cast GetInstanceProcAddr(instance, "vkGetFenceStatus") + GetFenceWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetFenceWin32HandleKHR") + GetFramebufferTilePropertiesQCOM = auto_cast GetInstanceProcAddr(instance, "vkGetFramebufferTilePropertiesQCOM") + GetGeneratedCommandsMemoryRequirementsNV = auto_cast GetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV") + GetImageDrmFormatModifierPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT") + GetImageMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements") + GetImageMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2") + GetImageMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR") + GetImageOpaqueCaptureDescriptorDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetImageOpaqueCaptureDescriptorDataEXT") + GetImageSparseMemoryRequirements = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements") + GetImageSparseMemoryRequirements2 = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2") + GetImageSparseMemoryRequirements2KHR = auto_cast GetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2KHR") + GetImageSubresourceLayout = auto_cast GetInstanceProcAddr(instance, "vkGetImageSubresourceLayout") + GetImageSubresourceLayout2EXT = auto_cast GetInstanceProcAddr(instance, "vkGetImageSubresourceLayout2EXT") + GetImageViewAddressNVX = auto_cast GetInstanceProcAddr(instance, "vkGetImageViewAddressNVX") + GetImageViewHandleNVX = auto_cast GetInstanceProcAddr(instance, "vkGetImageViewHandleNVX") + GetImageViewOpaqueCaptureDescriptorDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") + GetMemoryFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdKHR") + GetMemoryFdPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR") + GetMemoryHostPointerPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT") + GetMemoryRemoteAddressNV = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV") + GetMemoryWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleKHR") + GetMemoryWin32HandleNV = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandleNV") + GetMemoryWin32HandlePropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetMemoryWin32HandlePropertiesKHR") + GetMicromapBuildSizesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetMicromapBuildSizesEXT") + GetPastPresentationTimingGOOGLE = auto_cast GetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE") + GetPerformanceParameterINTEL = auto_cast GetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL") + GetPipelineCacheData = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineCacheData") + GetPipelineExecutableInternalRepresentationsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR") + GetPipelineExecutablePropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR") + GetPipelineExecutableStatisticsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR") + GetPipelinePropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPipelinePropertiesEXT") + GetPrivateData = auto_cast GetInstanceProcAddr(instance, "vkGetPrivateData") + GetPrivateDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetPrivateDataEXT") + GetQueryPoolResults = auto_cast GetInstanceProcAddr(instance, "vkGetQueryPoolResults") + GetQueueCheckpointData2NV = auto_cast GetInstanceProcAddr(instance, "vkGetQueueCheckpointData2NV") + GetQueueCheckpointDataNV = auto_cast GetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV") + GetRayTracingCaptureReplayShaderGroupHandlesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") + GetRayTracingShaderGroupHandlesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR") + GetRayTracingShaderGroupHandlesNV = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesNV") + GetRayTracingShaderGroupStackSizeKHR = auto_cast GetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR") + GetRefreshCycleDurationGOOGLE = auto_cast GetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE") + GetRenderAreaGranularity = auto_cast GetInstanceProcAddr(instance, "vkGetRenderAreaGranularity") + GetSamplerOpaqueCaptureDescriptorDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") + GetSemaphoreCounterValue = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue") + GetSemaphoreCounterValueKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR") + GetSemaphoreFdKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR") + GetSemaphoreWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSemaphoreWin32HandleKHR") + GetShaderBinaryDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetShaderBinaryDataEXT") + GetShaderInfoAMD = auto_cast GetInstanceProcAddr(instance, "vkGetShaderInfoAMD") + GetShaderModuleCreateInfoIdentifierEXT = auto_cast GetInstanceProcAddr(instance, "vkGetShaderModuleCreateInfoIdentifierEXT") + GetShaderModuleIdentifierEXT = auto_cast GetInstanceProcAddr(instance, "vkGetShaderModuleIdentifierEXT") + GetSwapchainCounterEXT = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT") + GetSwapchainImagesKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR") + GetSwapchainStatusKHR = auto_cast GetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR") + GetValidationCacheDataEXT = auto_cast GetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT") + GetVideoSessionMemoryRequirementsKHR = auto_cast GetInstanceProcAddr(instance, "vkGetVideoSessionMemoryRequirementsKHR") + ImportFenceFdKHR = auto_cast GetInstanceProcAddr(instance, "vkImportFenceFdKHR") + ImportFenceWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkImportFenceWin32HandleKHR") + ImportSemaphoreFdKHR = auto_cast GetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR") + ImportSemaphoreWin32HandleKHR = auto_cast GetInstanceProcAddr(instance, "vkImportSemaphoreWin32HandleKHR") + InitializePerformanceApiINTEL = auto_cast GetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL") + InvalidateMappedMemoryRanges = auto_cast GetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges") + MapMemory = auto_cast GetInstanceProcAddr(instance, "vkMapMemory") + MapMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkMapMemory2KHR") + MergePipelineCaches = auto_cast GetInstanceProcAddr(instance, "vkMergePipelineCaches") + MergeValidationCachesEXT = auto_cast GetInstanceProcAddr(instance, "vkMergeValidationCachesEXT") + QueueBeginDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT") + QueueBindSparse = auto_cast GetInstanceProcAddr(instance, "vkQueueBindSparse") + QueueEndDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT") + QueueInsertDebugUtilsLabelEXT = auto_cast GetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT") + QueuePresentKHR = auto_cast GetInstanceProcAddr(instance, "vkQueuePresentKHR") + QueueSetPerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL") + QueueSubmit = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit") + QueueSubmit2 = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit2") + QueueSubmit2KHR = auto_cast GetInstanceProcAddr(instance, "vkQueueSubmit2KHR") + QueueWaitIdle = auto_cast GetInstanceProcAddr(instance, "vkQueueWaitIdle") + RegisterDeviceEventEXT = auto_cast GetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT") + RegisterDisplayEventEXT = auto_cast GetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT") + ReleaseFullScreenExclusiveModeEXT = auto_cast GetInstanceProcAddr(instance, "vkReleaseFullScreenExclusiveModeEXT") + ReleasePerformanceConfigurationINTEL = auto_cast GetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL") + ReleaseProfilingLockKHR = auto_cast GetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR") + ReleaseSwapchainImagesEXT = auto_cast GetInstanceProcAddr(instance, "vkReleaseSwapchainImagesEXT") + ResetCommandBuffer = auto_cast GetInstanceProcAddr(instance, "vkResetCommandBuffer") + ResetCommandPool = auto_cast GetInstanceProcAddr(instance, "vkResetCommandPool") + ResetDescriptorPool = auto_cast GetInstanceProcAddr(instance, "vkResetDescriptorPool") + ResetEvent = auto_cast GetInstanceProcAddr(instance, "vkResetEvent") + ResetFences = auto_cast GetInstanceProcAddr(instance, "vkResetFences") + ResetQueryPool = auto_cast GetInstanceProcAddr(instance, "vkResetQueryPool") + ResetQueryPoolEXT = auto_cast GetInstanceProcAddr(instance, "vkResetQueryPoolEXT") + SetDebugUtilsObjectNameEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT") + SetDebugUtilsObjectTagEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT") + SetDeviceMemoryPriorityEXT = auto_cast GetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT") + SetEvent = auto_cast GetInstanceProcAddr(instance, "vkSetEvent") + SetHdrMetadataEXT = auto_cast GetInstanceProcAddr(instance, "vkSetHdrMetadataEXT") + SetLocalDimmingAMD = auto_cast GetInstanceProcAddr(instance, "vkSetLocalDimmingAMD") + SetPrivateData = auto_cast GetInstanceProcAddr(instance, "vkSetPrivateData") + SetPrivateDataEXT = auto_cast GetInstanceProcAddr(instance, "vkSetPrivateDataEXT") + SignalSemaphore = auto_cast GetInstanceProcAddr(instance, "vkSignalSemaphore") + SignalSemaphoreKHR = auto_cast GetInstanceProcAddr(instance, "vkSignalSemaphoreKHR") + TrimCommandPool = auto_cast GetInstanceProcAddr(instance, "vkTrimCommandPool") + TrimCommandPoolKHR = auto_cast GetInstanceProcAddr(instance, "vkTrimCommandPoolKHR") + UninitializePerformanceApiINTEL = auto_cast GetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL") + UnmapMemory = auto_cast GetInstanceProcAddr(instance, "vkUnmapMemory") + UnmapMemory2KHR = auto_cast GetInstanceProcAddr(instance, "vkUnmapMemory2KHR") + UpdateDescriptorSetWithTemplate = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate") + UpdateDescriptorSetWithTemplateKHR = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplateKHR") + UpdateDescriptorSets = auto_cast GetInstanceProcAddr(instance, "vkUpdateDescriptorSets") + UpdateVideoSessionParametersKHR = auto_cast GetInstanceProcAddr(instance, "vkUpdateVideoSessionParametersKHR") + WaitForFences = auto_cast GetInstanceProcAddr(instance, "vkWaitForFences") + WaitForPresentKHR = auto_cast GetInstanceProcAddr(instance, "vkWaitForPresentKHR") + WaitSemaphores = auto_cast GetInstanceProcAddr(instance, "vkWaitSemaphores") + WaitSemaphoresKHR = auto_cast GetInstanceProcAddr(instance, "vkWaitSemaphoresKHR") + WriteAccelerationStructuresPropertiesKHR = auto_cast GetInstanceProcAddr(instance, "vkWriteAccelerationStructuresPropertiesKHR") + WriteMicromapsPropertiesEXT = auto_cast GetInstanceProcAddr(instance, "vkWriteMicromapsPropertiesEXT") } load_proc_addresses_global :: proc(vk_get_instance_proc_addr: rawptr) { diff --git a/vendor/vulkan/structs.odin b/vendor/vulkan/structs.odin index 76b14a492..5d3231ccc 100644 --- a/vendor/vulkan/structs.odin +++ b/vendor/vulkan/structs.odin @@ -34,6 +34,12 @@ when ODIN_OS == .Windows { CAMetalLayer :: struct {} +MTLBuffer_id :: rawptr +MTLTexture_id :: rawptr +MTLSharedEvent_id :: rawptr +MTLDevice_id :: rawptr +MTLCommandQueue_id :: rawptr + /********************************/ Extent2D :: struct { @@ -2860,6 +2866,217 @@ DisplayPresentInfoKHR :: struct { persistent: b32, } +QueueFamilyQueryResultStatusPropertiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + queryResultStatusSupport: b32, +} + +QueueFamilyVideoPropertiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + videoCodecOperations: VideoCodecOperationFlagsKHR, +} + +VideoProfileInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + videoCodecOperation: VideoCodecOperationFlagsKHR, + chromaSubsampling: VideoChromaSubsamplingFlagsKHR, + lumaBitDepth: VideoComponentBitDepthFlagsKHR, + chromaBitDepth: VideoComponentBitDepthFlagsKHR, +} + +VideoProfileListInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + profileCount: u32, + pProfiles: [^]VideoProfileInfoKHR, +} + +VideoCapabilitiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoCapabilityFlagsKHR, + minBitstreamBufferOffsetAlignment: DeviceSize, + minBitstreamBufferSizeAlignment: DeviceSize, + pictureAccessGranularity: Extent2D, + minCodedExtent: Extent2D, + maxCodedExtent: Extent2D, + maxDpbSlots: u32, + maxActiveReferencePictures: u32, + stdHeaderVersion: ExtensionProperties, +} + +PhysicalDeviceVideoFormatInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + imageUsage: ImageUsageFlags, +} + +VideoFormatPropertiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + format: Format, + componentMapping: ComponentMapping, + imageCreateFlags: ImageCreateFlags, + imageType: ImageType, + imageTiling: ImageTiling, + imageUsageFlags: ImageUsageFlags, +} + +VideoPictureResourceInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + codedOffset: Offset2D, + codedExtent: Extent2D, + baseArrayLayer: u32, + imageViewBinding: ImageView, +} + +VideoReferenceSlotInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + slotIndex: i32, + pPictureResource: ^VideoPictureResourceInfoKHR, +} + +VideoSessionMemoryRequirementsKHR :: struct { + sType: StructureType, + pNext: rawptr, + memoryBindIndex: u32, + memoryRequirements: MemoryRequirements, +} + +BindVideoSessionMemoryInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + memoryBindIndex: u32, + memory: DeviceMemory, + memoryOffset: DeviceSize, + memorySize: DeviceSize, +} + +VideoSessionCreateInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + queueFamilyIndex: u32, + flags: VideoSessionCreateFlagsKHR, + pVideoProfile: ^VideoProfileInfoKHR, + pictureFormat: Format, + maxCodedExtent: Extent2D, + referencePictureFormat: Format, + maxDpbSlots: u32, + maxActiveReferencePictures: u32, + pStdHeaderVersion: ^ExtensionProperties, +} + +VideoSessionParametersCreateInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoSessionParametersCreateFlagsKHR, + videoSessionParametersTemplate: VideoSessionParametersKHR, + videoSession: VideoSessionKHR, +} + +VideoSessionParametersUpdateInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + updateSequenceCount: u32, +} + +VideoBeginCodingInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoBeginCodingFlagsKHR, + videoSession: VideoSessionKHR, + videoSessionParameters: VideoSessionParametersKHR, + referenceSlotCount: u32, + pReferenceSlots: [^]VideoReferenceSlotInfoKHR, +} + +VideoEndCodingInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoEndCodingFlagsKHR, +} + +VideoCodingControlInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoCodingControlFlagsKHR, +} + +VideoDecodeCapabilitiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoDecodeCapabilityFlagsKHR, +} + +VideoDecodeUsageInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + videoUsageHints: VideoDecodeUsageFlagsKHR, +} + +VideoDecodeInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: VideoDecodeFlagsKHR, + srcBuffer: Buffer, + srcBufferOffset: DeviceSize, + srcBufferRange: DeviceSize, + dstPictureResource: VideoPictureResourceInfoKHR, + pSetupReferenceSlot: ^VideoReferenceSlotInfoKHR, + referenceSlotCount: u32, + pReferenceSlots: [^]VideoReferenceSlotInfoKHR, +} + +VideoDecodeH264ProfileInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + stdProfileIdc: VideoH264ProfileIdc, + pictureLayout: VideoDecodeH264PictureLayoutFlagsKHR, +} + +VideoDecodeH264CapabilitiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + maxLevelIdc: VideoH264LevelIdc, + fieldOffsetGranularity: Offset2D, +} + +VideoDecodeH264SessionParametersAddInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + stdSPSCount: u32, + pStdSPSs: [^]VideoH264SequenceParameterSet, + stdPPSCount: u32, + pStdPPSs: [^]VideoH264PictureParameterSet, +} + +VideoDecodeH264SessionParametersCreateInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + maxStdSPSCount: u32, + maxStdPPSCount: u32, + pParametersAddInfo: ^VideoDecodeH264SessionParametersAddInfoKHR, +} + +VideoDecodeH264PictureInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + pStdPictureInfo: ^VideoDecodeH264PictureInfo, + sliceCount: u32, + pSliceOffsets: [^]u32, +} + +VideoDecodeH264DpbSlotInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + pStdReferenceInfo: ^VideoDecodeH264ReferenceInfo, +} + RenderingFragmentShadingRateAttachmentInfoKHR :: struct { sType: StructureType, pNext: rawptr, @@ -3089,6 +3306,52 @@ PhysicalDeviceShaderClockFeaturesKHR :: struct { shaderDeviceClock: b32, } +VideoDecodeH265ProfileInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + stdProfileIdc: VideoH265ProfileIdc, +} + +VideoDecodeH265CapabilitiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + maxLevelIdc: VideoH265LevelIdc, +} + +VideoDecodeH265SessionParametersAddInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + stdVPSCount: u32, + pStdVPSs: [^]VideoH265VideoParameterSet, + stdSPSCount: u32, + pStdSPSs: [^]VideoH265SequenceParameterSet, + stdPPSCount: u32, + pStdPPSs: [^]VideoH265PictureParameterSet, +} + +VideoDecodeH265SessionParametersCreateInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + maxStdVPSCount: u32, + maxStdSPSCount: u32, + maxStdPPSCount: u32, + pParametersAddInfo: ^VideoDecodeH265SessionParametersAddInfoKHR, +} + +VideoDecodeH265PictureInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + pStdPictureInfo: ^VideoDecodeH265PictureInfo, + sliceSegmentCount: u32, + pSliceSegmentOffsets: [^]u32, +} + +VideoDecodeH265DpbSlotInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + pStdReferenceInfo: ^VideoDecodeH265ReferenceInfo, +} + DeviceQueueGlobalPriorityCreateInfoKHR :: struct { sType: StructureType, pNext: rawptr, @@ -3225,6 +3488,22 @@ PipelineExecutableInternalRepresentationKHR :: struct { pData: rawptr, } +MemoryMapInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: MemoryMapFlags, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, +} + +MemoryUnmapInfoKHR :: struct { + sType: StructureType, + pNext: rawptr, + flags: MemoryUnmapFlagsKHR, + memory: DeviceMemory, +} + PipelineLibraryCreateInfoKHR :: struct { sType: StructureType, pNext: rawptr, @@ -3258,6 +3537,18 @@ CheckpointData2NV :: struct { pCheckpointMarker: rawptr, } +PhysicalDeviceFragmentShaderBarycentricFeaturesKHR :: struct { + sType: StructureType, + pNext: rawptr, + fragmentShaderBarycentric: b32, +} + +PhysicalDeviceFragmentShaderBarycentricPropertiesKHR :: struct { + sType: StructureType, + pNext: rawptr, + triStripVertexOrderIndependentOfProvokingVertex: b32, +} + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR :: struct { sType: StructureType, pNext: rawptr, @@ -3273,6 +3564,36 @@ PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR :: struct { workgroupMemoryExplicitLayout16BitAccess: b32, } +PhysicalDeviceRayTracingMaintenance1FeaturesKHR :: struct { + sType: StructureType, + pNext: rawptr, + rayTracingMaintenance1: b32, + rayTracingPipelineTraceRaysIndirect2: b32, +} + +TraceRaysIndirectCommand2KHR :: struct { + raygenShaderRecordAddress: DeviceAddress, + raygenShaderRecordSize: DeviceSize, + missShaderBindingTableAddress: DeviceAddress, + missShaderBindingTableSize: DeviceSize, + missShaderBindingTableStride: DeviceSize, + hitShaderBindingTableAddress: DeviceAddress, + hitShaderBindingTableSize: DeviceSize, + hitShaderBindingTableStride: DeviceSize, + callableShaderBindingTableAddress: DeviceAddress, + callableShaderBindingTableSize: DeviceSize, + callableShaderBindingTableStride: DeviceSize, + width: u32, + height: u32, + depth: u32, +} + +PhysicalDeviceRayTracingPositionFetchFeaturesKHR :: struct { + sType: StructureType, + pNext: rawptr, + rayTracingPositionFetch: b32, +} + DebugReportCallbackCreateInfoEXT :: struct { sType: StructureType, pNext: rawptr, @@ -3474,6 +3795,30 @@ PhysicalDeviceASTCDecodeFeaturesEXT :: struct { decodeModeSharedExponent: b32, } +PhysicalDevicePipelineRobustnessFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + pipelineRobustness: b32, +} + +PhysicalDevicePipelineRobustnessPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + defaultRobustnessStorageBuffers: PipelineRobustnessBufferBehaviorEXT, + defaultRobustnessUniformBuffers: PipelineRobustnessBufferBehaviorEXT, + defaultRobustnessVertexInputs: PipelineRobustnessBufferBehaviorEXT, + defaultRobustnessImages: PipelineRobustnessImageBehaviorEXT, +} + +PipelineRobustnessCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + storageBuffers: PipelineRobustnessBufferBehaviorEXT, + uniformBuffers: PipelineRobustnessBufferBehaviorEXT, + vertexInputs: PipelineRobustnessBufferBehaviorEXT, + images: PipelineRobustnessImageBehaviorEXT, +} + ConditionalRenderingBeginInfoEXT :: struct { sType: StructureType, pNext: rawptr, @@ -4219,12 +4564,6 @@ DrawMeshTasksIndirectCommandNV :: struct { firstTask: u32, } -PhysicalDeviceFragmentShaderBarycentricFeaturesNV :: struct { - sType: StructureType, - pNext: rawptr, - fragmentShaderBarycentric: b32, -} - PhysicalDeviceShaderImageFootprintFeaturesNV :: struct { sType: StructureType, pNext: rawptr, @@ -4585,6 +4924,72 @@ PhysicalDeviceShaderAtomicFloat2FeaturesEXT :: struct { sparseImageFloat32AtomicMinMax: b32, } +SurfacePresentModeEXT :: struct { + sType: StructureType, + pNext: rawptr, + presentMode: PresentModeKHR, +} + +SurfacePresentScalingCapabilitiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + supportedPresentScaling: PresentScalingFlagsEXT, + supportedPresentGravityX: PresentGravityFlagsEXT, + supportedPresentGravityY: PresentGravityFlagsEXT, + minScaledImageExtent: Extent2D, + maxScaledImageExtent: Extent2D, +} + +SurfacePresentModeCompatibilityEXT :: struct { + sType: StructureType, + pNext: rawptr, + presentModeCount: u32, + pPresentModes: [^]PresentModeKHR, +} + +PhysicalDeviceSwapchainMaintenance1FeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + swapchainMaintenance1: b32, +} + +SwapchainPresentFenceInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + swapchainCount: u32, + pFences: [^]Fence, +} + +SwapchainPresentModesCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + presentModeCount: u32, + pPresentModes: [^]PresentModeKHR, +} + +SwapchainPresentModeInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + swapchainCount: u32, + pPresentModes: [^]PresentModeKHR, +} + +SwapchainPresentScalingCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + scalingBehavior: PresentScalingFlagsEXT, + presentGravityX: PresentGravityFlagsEXT, + presentGravityY: PresentGravityFlagsEXT, +} + +ReleaseSwapchainImagesInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + swapchain: SwapchainKHR, + imageIndexCount: u32, + pImageIndices: [^]u32, +} + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV :: struct { sType: StructureType, pNext: rawptr, @@ -4798,6 +5203,24 @@ PhysicalDeviceCustomBorderColorFeaturesEXT :: struct { customBorderColorWithoutFormat: b32, } +PhysicalDevicePresentBarrierFeaturesNV :: struct { + sType: StructureType, + pNext: rawptr, + presentBarrier: b32, +} + +SurfaceCapabilitiesPresentBarrierNV :: struct { + sType: StructureType, + pNext: rawptr, + presentBarrierSupported: b32, +} + +SwapchainPresentBarrierCreateInfoNV :: struct { + sType: StructureType, + pNext: rawptr, + presentBarrierEnable: b32, +} + PhysicalDeviceDiagnosticsConfigFeaturesNV :: struct { sType: StructureType, pNext: rawptr, @@ -4810,6 +5233,143 @@ DeviceDiagnosticsConfigCreateInfoNV :: struct { flags: DeviceDiagnosticsConfigFlagsNV, } +QueryLowLatencySupportNV :: struct { + sType: StructureType, + pNext: rawptr, + pQueriedLowLatencyData: rawptr, +} + +PhysicalDeviceDescriptorBufferPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + combinedImageSamplerDescriptorSingleArray: b32, + bufferlessPushDescriptors: b32, + allowSamplerImageViewPostSubmitCreation: b32, + descriptorBufferOffsetAlignment: DeviceSize, + maxDescriptorBufferBindings: u32, + maxResourceDescriptorBufferBindings: u32, + maxSamplerDescriptorBufferBindings: u32, + maxEmbeddedImmutableSamplerBindings: u32, + maxEmbeddedImmutableSamplers: u32, + bufferCaptureReplayDescriptorDataSize: int, + imageCaptureReplayDescriptorDataSize: int, + imageViewCaptureReplayDescriptorDataSize: int, + samplerCaptureReplayDescriptorDataSize: int, + accelerationStructureCaptureReplayDescriptorDataSize: int, + samplerDescriptorSize: int, + combinedImageSamplerDescriptorSize: int, + sampledImageDescriptorSize: int, + storageImageDescriptorSize: int, + uniformTexelBufferDescriptorSize: int, + robustUniformTexelBufferDescriptorSize: int, + storageTexelBufferDescriptorSize: int, + robustStorageTexelBufferDescriptorSize: int, + uniformBufferDescriptorSize: int, + robustUniformBufferDescriptorSize: int, + storageBufferDescriptorSize: int, + robustStorageBufferDescriptorSize: int, + inputAttachmentDescriptorSize: int, + accelerationStructureDescriptorSize: int, + maxSamplerDescriptorBufferRange: DeviceSize, + maxResourceDescriptorBufferRange: DeviceSize, + samplerDescriptorBufferAddressSpaceSize: DeviceSize, + resourceDescriptorBufferAddressSpaceSize: DeviceSize, + descriptorBufferAddressSpaceSize: DeviceSize, +} + +PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + combinedImageSamplerDensityMapDescriptorSize: int, +} + +PhysicalDeviceDescriptorBufferFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + descriptorBuffer: b32, + descriptorBufferCaptureReplay: b32, + descriptorBufferImageLayoutIgnored: b32, + descriptorBufferPushDescriptors: b32, +} + +DescriptorAddressInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + address: DeviceAddress, + range: DeviceSize, + format: Format, +} + +DescriptorBufferBindingInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + address: DeviceAddress, + usage: BufferUsageFlags, +} + +DescriptorBufferBindingPushDescriptorBufferHandleEXT :: struct { + sType: StructureType, + pNext: rawptr, + buffer: Buffer, +} + +DescriptorDataEXT :: struct #raw_union { + pSampler: ^Sampler, + pCombinedImageSampler: ^DescriptorImageInfo, + pInputAttachmentImage: ^DescriptorImageInfo, + pSampledImage: ^DescriptorImageInfo, + pStorageImage: ^DescriptorImageInfo, + pUniformTexelBuffer: ^DescriptorAddressInfoEXT, + pStorageTexelBuffer: ^DescriptorAddressInfoEXT, + pUniformBuffer: ^DescriptorAddressInfoEXT, + pStorageBuffer: ^DescriptorAddressInfoEXT, + accelerationStructure: DeviceAddress, +} + +DescriptorGetInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + type: DescriptorType, + data: DescriptorDataEXT, +} + +BufferCaptureDescriptorDataInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + buffer: Buffer, +} + +ImageCaptureDescriptorDataInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + image: Image, +} + +ImageViewCaptureDescriptorDataInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + imageView: ImageView, +} + +SamplerCaptureDescriptorDataInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + sampler: Sampler, +} + +OpaqueCaptureDescriptorDataCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + opaqueCaptureDescriptorData: rawptr, +} + +AccelerationStructureCaptureDescriptorDataInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + accelerationStructure: AccelerationStructureKHR, + accelerationStructureNV: AccelerationStructureNV, +} + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, @@ -4829,6 +5389,12 @@ GraphicsPipelineLibraryCreateInfoEXT :: struct { flags: GraphicsPipelineLibraryFlagsEXT, } +PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD :: struct { + sType: StructureType, + pNext: rawptr, + shaderEarlyAndLateFragmentTests: b32, +} + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV :: struct { sType: StructureType, pNext: rawptr, @@ -4946,6 +5512,45 @@ CopyCommandTransformInfoQCOM :: struct { transform: SurfaceTransformFlagsKHR, } +PhysicalDeviceImageCompressionControlFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + imageCompressionControl: b32, +} + +ImageCompressionControlEXT :: struct { + sType: StructureType, + pNext: rawptr, + flags: ImageCompressionFlagsEXT, + compressionControlPlaneCount: u32, + pFixedRateFlags: [^]ImageCompressionFixedRateFlagsEXT, +} + +SubresourceLayout2EXT :: struct { + sType: StructureType, + pNext: rawptr, + subresourceLayout: SubresourceLayout, +} + +ImageSubresource2EXT :: struct { + sType: StructureType, + pNext: rawptr, + imageSubresource: ImageSubresource, +} + +ImageCompressionPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + imageCompressionFlags: ImageCompressionFlagsEXT, + imageCompressionFixedRateFlags: ImageCompressionFixedRateFlagsEXT, +} + +PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + attachmentFeedbackLoopLayout: b32, +} + PhysicalDevice4444FormatsFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, @@ -4953,7 +5558,57 @@ PhysicalDevice4444FormatsFeaturesEXT :: struct { formatA4B4G4R4: b32, } -PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM :: struct { +PhysicalDeviceFaultFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + deviceFault: b32, + deviceFaultVendorBinary: b32, +} + +DeviceFaultCountsEXT :: struct { + sType: StructureType, + pNext: rawptr, + addressInfoCount: u32, + vendorInfoCount: u32, + vendorBinarySize: DeviceSize, +} + +DeviceFaultAddressInfoEXT :: struct { + addressType: DeviceFaultAddressTypeEXT, + reportedAddress: DeviceAddress, + addressPrecision: DeviceSize, +} + +DeviceFaultVendorInfoEXT :: struct { + description: [MAX_DESCRIPTION_SIZE]byte, + vendorFaultCode: u64, + vendorFaultData: u64, +} + +DeviceFaultInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + description: [MAX_DESCRIPTION_SIZE]byte, + pAddressInfos: [^]DeviceFaultAddressInfoEXT, + pVendorInfos: [^]DeviceFaultVendorInfoEXT, + pVendorBinaryData: rawptr, +} + +DeviceFaultVendorBinaryHeaderVersionOneEXT :: struct { + headerSize: u32, + headerVersion: DeviceFaultVendorBinaryHeaderVersionEXT, + vendorID: u32, + deviceID: u32, + driverVersion: u32, + pipelineCacheUUID: [UUID_SIZE]u8, + applicationNameOffset: u32, + applicationVersion: u32, + engineNameOffset: u32, + engineVersion: u32, + apiVersion: u32, +} + +PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, rasterizationOrderColorAttachmentAccess: b32, @@ -4967,22 +5622,22 @@ PhysicalDeviceRGBA10X6FormatsFeaturesEXT :: struct { formatRgba10x6WithoutYCbCrSampler: b32, } -PhysicalDeviceMutableDescriptorTypeFeaturesVALVE :: struct { +PhysicalDeviceMutableDescriptorTypeFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, mutableDescriptorType: b32, } -MutableDescriptorTypeListVALVE :: struct { +MutableDescriptorTypeListEXT :: struct { descriptorTypeCount: u32, pDescriptorTypes: [^]DescriptorType, } -MutableDescriptorTypeCreateInfoVALVE :: struct { +MutableDescriptorTypeCreateInfoEXT :: struct { sType: StructureType, pNext: rawptr, mutableDescriptorTypeListCount: u32, - pMutableDescriptorTypeLists: [^]MutableDescriptorTypeListVALVE, + pMutableDescriptorTypeLists: [^]MutableDescriptorTypeListEXT, } PhysicalDeviceVertexInputDynamicStateFeaturesEXT :: struct { @@ -5020,6 +5675,21 @@ PhysicalDeviceDrmPropertiesEXT :: struct { renderMinor: i64, } +PhysicalDeviceAddressBindingReportFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + reportAddressBinding: b32, +} + +DeviceAddressBindingCallbackDataEXT :: struct { + sType: StructureType, + pNext: rawptr, + flags: DeviceAddressBindingFlagsEXT, + baseAddress: DeviceAddress, + size: DeviceSize, + bindingType: DeviceAddressBindingTypeEXT, +} + PhysicalDeviceDepthClipControlFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, @@ -5077,6 +5747,37 @@ PhysicalDeviceExternalMemoryRDMAFeaturesNV :: struct { externalMemoryRDMA: b32, } +PipelinePropertiesIdentifierEXT :: struct { + sType: StructureType, + pNext: rawptr, + pipelineIdentifier: [UUID_SIZE]u8, +} + +PhysicalDevicePipelinePropertiesFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + pipelinePropertiesIdentifier: b32, +} + +PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + multisampledRenderToSingleSampled: b32, +} + +SubpassResolvePerformanceQueryEXT :: struct { + sType: StructureType, + pNext: rawptr, + optimal: b32, +} + +MultisampledRenderToSingleSampledInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + multisampledRenderToSingleSampledEnable: b32, + rasterizationSamples: SampleCountFlags, +} + PhysicalDeviceExtendedDynamicState2FeaturesEXT :: struct { sType: StructureType, pNext: rawptr, @@ -5148,6 +5849,148 @@ PhysicalDeviceImage2DViewOf3DFeaturesEXT :: struct { sampler2DViewOf3D: b32, } +PhysicalDeviceShaderTileImageFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderTileImageColorReadAccess: b32, + shaderTileImageDepthReadAccess: b32, + shaderTileImageStencilReadAccess: b32, +} + +PhysicalDeviceShaderTileImagePropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderTileImageCoherentReadAccelerated: b32, + shaderTileImageReadSampleFromPixelRateInvocation: b32, + shaderTileImageReadFromHelperInvocation: b32, +} + +MicromapUsageEXT :: struct { + count: u32, + subdivisionLevel: u32, + format: u32, +} + +DeviceOrHostAddressKHR :: struct #raw_union { + deviceAddress: DeviceAddress, + hostAddress: rawptr, +} + +MicromapBuildInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + type: MicromapTypeEXT, + flags: BuildMicromapFlagsEXT, + mode: BuildMicromapModeEXT, + dstMicromap: MicromapEXT, + usageCountsCount: u32, + pUsageCounts: [^]MicromapUsageEXT, + ppUsageCounts: ^[^]MicromapUsageEXT, + data: DeviceOrHostAddressConstKHR, + scratchData: DeviceOrHostAddressKHR, + triangleArray: DeviceOrHostAddressConstKHR, + triangleArrayStride: DeviceSize, +} + +MicromapCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + createFlags: MicromapCreateFlagsEXT, + buffer: Buffer, + offset: DeviceSize, + size: DeviceSize, + type: MicromapTypeEXT, + deviceAddress: DeviceAddress, +} + +PhysicalDeviceOpacityMicromapFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + micromap: b32, + micromapCaptureReplay: b32, + micromapHostCommands: b32, +} + +PhysicalDeviceOpacityMicromapPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + maxOpacity2StateSubdivisionLevel: u32, + maxOpacity4StateSubdivisionLevel: u32, +} + +MicromapVersionInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + pVersionData: ^u8, +} + +CopyMicromapToMemoryInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + src: MicromapEXT, + dst: DeviceOrHostAddressKHR, + mode: CopyMicromapModeEXT, +} + +CopyMemoryToMicromapInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + src: DeviceOrHostAddressConstKHR, + dst: MicromapEXT, + mode: CopyMicromapModeEXT, +} + +CopyMicromapInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + src: MicromapEXT, + dst: MicromapEXT, + mode: CopyMicromapModeEXT, +} + +MicromapBuildSizesInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + micromapSize: DeviceSize, + buildScratchSize: DeviceSize, + discardable: b32, +} + +AccelerationStructureTrianglesOpacityMicromapEXT :: struct { + sType: StructureType, + pNext: rawptr, + indexType: IndexType, + indexBuffer: DeviceOrHostAddressConstKHR, + indexStride: DeviceSize, + baseTriangle: u32, + usageCountsCount: u32, + pUsageCounts: [^]MicromapUsageEXT, + ppUsageCounts: ^[^]MicromapUsageEXT, + micromap: MicromapEXT, +} + +MicromapTriangleEXT :: struct { + dataOffset: u32, + subdivisionLevel: u16, + format: u16, +} + +PhysicalDeviceClusterCullingShaderFeaturesHUAWEI :: struct { + sType: StructureType, + pNext: rawptr, + clustercullingShader: b32, + multiviewClusterCullingShader: b32, +} + +PhysicalDeviceClusterCullingShaderPropertiesHUAWEI :: struct { + sType: StructureType, + pNext: rawptr, + maxWorkGroupCount: [3]u32, + maxWorkGroupSize: [3]u32, + maxOutputClusterCount: u32, + indirectBufferOffsetAlignment: DeviceSize, +} + PhysicalDeviceBorderColorSwizzleFeaturesEXT :: struct { sType: StructureType, pNext: rawptr, @@ -5168,6 +6011,27 @@ PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT :: struct { pageableDeviceLocalMemory: b32, } +PhysicalDeviceShaderCorePropertiesARM :: struct { + sType: StructureType, + pNext: rawptr, + pixelRate: u32, + texelRate: u32, + fmaRate: u32, +} + +PhysicalDeviceImageSlicedViewOf3DFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + imageSlicedViewOf3D: b32, +} + +ImageViewSlicedCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + sliceOffset: u32, + sliceCount: u32, +} + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE :: struct { sType: StructureType, pNext: rawptr, @@ -5188,6 +6052,18 @@ DescriptorSetLayoutHostMappingInfoVALVE :: struct { descriptorSize: u32, } +PhysicalDeviceDepthClampZeroOneFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + depthClampZeroOne: b32, +} + +PhysicalDeviceNonSeamlessCubeMapFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + nonSeamlessCubeMap: b32, +} + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM :: struct { sType: StructureType, pNext: rawptr, @@ -5207,15 +6083,413 @@ SubpassFragmentDensityMapOffsetEndInfoQCOM :: struct { pFragmentDensityOffsets: [^]Offset2D, } +CopyMemoryIndirectCommandNV :: struct { + srcAddress: DeviceAddress, + dstAddress: DeviceAddress, + size: DeviceSize, +} + +CopyMemoryToImageIndirectCommandNV :: struct { + srcAddress: DeviceAddress, + bufferRowLength: u32, + bufferImageHeight: u32, + imageSubresource: ImageSubresourceLayers, + imageOffset: Offset3D, + imageExtent: Extent3D, +} + +PhysicalDeviceCopyMemoryIndirectFeaturesNV :: struct { + sType: StructureType, + pNext: rawptr, + indirectCopy: b32, +} + +PhysicalDeviceCopyMemoryIndirectPropertiesNV :: struct { + sType: StructureType, + pNext: rawptr, + supportedQueues: QueueFlags, +} + +DecompressMemoryRegionNV :: struct { + srcAddress: DeviceAddress, + dstAddress: DeviceAddress, + compressedSize: DeviceSize, + decompressedSize: DeviceSize, + decompressionMethod: MemoryDecompressionMethodFlagsNV, +} + +PhysicalDeviceMemoryDecompressionFeaturesNV :: struct { + sType: StructureType, + pNext: rawptr, + memoryDecompression: b32, +} + +PhysicalDeviceMemoryDecompressionPropertiesNV :: struct { + sType: StructureType, + pNext: rawptr, + decompressionMethods: MemoryDecompressionMethodFlagsNV, + maxDecompressionIndirectCount: u64, +} + PhysicalDeviceLinearColorAttachmentFeaturesNV :: struct { sType: StructureType, pNext: rawptr, linearColorAttachment: b32, } -DeviceOrHostAddressKHR :: struct #raw_union { - deviceAddress: DeviceAddress, - hostAddress: rawptr, +PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + imageCompressionControlSwapchain: b32, +} + +ImageViewSampleWeightCreateInfoQCOM :: struct { + sType: StructureType, + pNext: rawptr, + filterCenter: Offset2D, + filterSize: Extent2D, + numPhases: u32, +} + +PhysicalDeviceImageProcessingFeaturesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + textureSampleWeighted: b32, + textureBoxFilter: b32, + textureBlockMatch: b32, +} + +PhysicalDeviceImageProcessingPropertiesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + maxWeightFilterPhases: u32, + maxWeightFilterDimension: Extent2D, + maxBlockMatchRegion: Extent2D, + maxBoxFilterBlockSize: Extent2D, +} + +PhysicalDeviceExtendedDynamicState3FeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + extendedDynamicState3TessellationDomainOrigin: b32, + extendedDynamicState3DepthClampEnable: b32, + extendedDynamicState3PolygonMode: b32, + extendedDynamicState3RasterizationSamples: b32, + extendedDynamicState3SampleMask: b32, + extendedDynamicState3AlphaToCoverageEnable: b32, + extendedDynamicState3AlphaToOneEnable: b32, + extendedDynamicState3LogicOpEnable: b32, + extendedDynamicState3ColorBlendEnable: b32, + extendedDynamicState3ColorBlendEquation: b32, + extendedDynamicState3ColorWriteMask: b32, + extendedDynamicState3RasterizationStream: b32, + extendedDynamicState3ConservativeRasterizationMode: b32, + extendedDynamicState3ExtraPrimitiveOverestimationSize: b32, + extendedDynamicState3DepthClipEnable: b32, + extendedDynamicState3SampleLocationsEnable: b32, + extendedDynamicState3ColorBlendAdvanced: b32, + extendedDynamicState3ProvokingVertexMode: b32, + extendedDynamicState3LineRasterizationMode: b32, + extendedDynamicState3LineStippleEnable: b32, + extendedDynamicState3DepthClipNegativeOneToOne: b32, + extendedDynamicState3ViewportWScalingEnable: b32, + extendedDynamicState3ViewportSwizzle: b32, + extendedDynamicState3CoverageToColorEnable: b32, + extendedDynamicState3CoverageToColorLocation: b32, + extendedDynamicState3CoverageModulationMode: b32, + extendedDynamicState3CoverageModulationTableEnable: b32, + extendedDynamicState3CoverageModulationTable: b32, + extendedDynamicState3CoverageReductionMode: b32, + extendedDynamicState3RepresentativeFragmentTestEnable: b32, + extendedDynamicState3ShadingRateImageEnable: b32, +} + +PhysicalDeviceExtendedDynamicState3PropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + dynamicPrimitiveTopologyUnrestricted: b32, +} + +ColorBlendEquationEXT :: struct { + srcColorBlendFactor: BlendFactor, + dstColorBlendFactor: BlendFactor, + colorBlendOp: BlendOp, + srcAlphaBlendFactor: BlendFactor, + dstAlphaBlendFactor: BlendFactor, + alphaBlendOp: BlendOp, +} + +ColorBlendAdvancedEXT :: struct { + advancedBlendOp: BlendOp, + srcPremultiplied: b32, + dstPremultiplied: b32, + blendOverlap: BlendOverlapEXT, + clampResults: b32, +} + +PhysicalDeviceSubpassMergeFeedbackFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + subpassMergeFeedback: b32, +} + +RenderPassCreationControlEXT :: struct { + sType: StructureType, + pNext: rawptr, + disallowMerging: b32, +} + +RenderPassCreationFeedbackInfoEXT :: struct { + postMergeSubpassCount: u32, +} + +RenderPassCreationFeedbackCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + pRenderPassFeedback: ^RenderPassCreationFeedbackInfoEXT, +} + +RenderPassSubpassFeedbackInfoEXT :: struct { + subpassMergeStatus: SubpassMergeStatusEXT, + description: [MAX_DESCRIPTION_SIZE]byte, + postMergeIndex: u32, +} + +RenderPassSubpassFeedbackCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + pSubpassFeedback: ^RenderPassSubpassFeedbackInfoEXT, +} + +DirectDriverLoadingInfoLUNARG :: struct { + sType: StructureType, + pNext: rawptr, + flags: DirectDriverLoadingFlagsLUNARG, + pfnGetInstanceProcAddr: ProcGetInstanceProcAddrLUNARG, +} + +DirectDriverLoadingListLUNARG :: struct { + sType: StructureType, + pNext: rawptr, + mode: DirectDriverLoadingModeLUNARG, + driverCount: u32, + pDrivers: [^]DirectDriverLoadingInfoLUNARG, +} + +PhysicalDeviceShaderModuleIdentifierFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderModuleIdentifier: b32, +} + +PhysicalDeviceShaderModuleIdentifierPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderModuleIdentifierAlgorithmUUID: [UUID_SIZE]u8, +} + +PipelineShaderStageModuleIdentifierCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + identifierSize: u32, + pIdentifier: ^u8, +} + +ShaderModuleIdentifierEXT :: struct { + sType: StructureType, + pNext: rawptr, + identifierSize: u32, + identifier: [MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]u8, +} + +PhysicalDeviceOpticalFlowFeaturesNV :: struct { + sType: StructureType, + pNext: rawptr, + opticalFlow: b32, +} + +PhysicalDeviceOpticalFlowPropertiesNV :: struct { + sType: StructureType, + pNext: rawptr, + supportedOutputGridSizes: OpticalFlowGridSizeFlagsNV, + supportedHintGridSizes: OpticalFlowGridSizeFlagsNV, + hintSupported: b32, + costSupported: b32, + bidirectionalFlowSupported: b32, + globalFlowSupported: b32, + minWidth: u32, + minHeight: u32, + maxWidth: u32, + maxHeight: u32, + maxNumRegionsOfInterest: u32, +} + +OpticalFlowImageFormatInfoNV :: struct { + sType: StructureType, + pNext: rawptr, + usage: OpticalFlowUsageFlagsNV, +} + +OpticalFlowImageFormatPropertiesNV :: struct { + sType: StructureType, + pNext: rawptr, + format: Format, +} + +OpticalFlowSessionCreateInfoNV :: struct { + sType: StructureType, + pNext: rawptr, + width: u32, + height: u32, + imageFormat: Format, + flowVectorFormat: Format, + costFormat: Format, + outputGridSize: OpticalFlowGridSizeFlagsNV, + hintGridSize: OpticalFlowGridSizeFlagsNV, + performanceLevel: OpticalFlowPerformanceLevelNV, + flags: OpticalFlowSessionCreateFlagsNV, +} + +OpticalFlowSessionCreatePrivateDataInfoNV :: struct { + sType: StructureType, + pNext: rawptr, + id: u32, + size: u32, + pPrivateData: rawptr, +} + +OpticalFlowExecuteInfoNV :: struct { + sType: StructureType, + pNext: rawptr, + flags: OpticalFlowExecuteFlagsNV, + regionCount: u32, + pRegions: [^]Rect2D, +} + +PhysicalDeviceLegacyDitheringFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + legacyDithering: b32, +} + +PhysicalDevicePipelineProtectedAccessFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + pipelineProtectedAccess: b32, +} + +PhysicalDeviceShaderObjectFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderObject: b32, +} + +PhysicalDeviceShaderObjectPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + shaderBinaryUUID: [UUID_SIZE]u8, + shaderBinaryVersion: u32, +} + +ShaderCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + flags: ShaderCreateFlagsEXT, + stage: ShaderStageFlags, + nextStage: ShaderStageFlags, + codeType: ShaderCodeTypeEXT, + codeSize: int, + pCode: rawptr, + pName: cstring, + setLayoutCount: u32, + pSetLayouts: [^]DescriptorSetLayout, + pushConstantRangeCount: u32, + pPushConstantRanges: [^]PushConstantRange, + pSpecializationInfo: ^SpecializationInfo, +} + +PhysicalDeviceTilePropertiesFeaturesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + tileProperties: b32, +} + +TilePropertiesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + tileSize: Extent3D, + apronSize: Extent2D, + origin: Offset2D, +} + +PhysicalDeviceAmigoProfilingFeaturesSEC :: struct { + sType: StructureType, + pNext: rawptr, + amigoProfiling: b32, +} + +AmigoProfilingSubmitInfoSEC :: struct { + sType: StructureType, + pNext: rawptr, + firstDrawTimestamp: u64, + swapBufferTimestamp: u64, +} + +PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + multiviewPerViewViewports: b32, +} + +PhysicalDeviceRayTracingInvocationReorderPropertiesNV :: struct { + sType: StructureType, + pNext: rawptr, + rayTracingInvocationReorderReorderingHint: RayTracingInvocationReorderModeNV, +} + +PhysicalDeviceRayTracingInvocationReorderFeaturesNV :: struct { + sType: StructureType, + pNext: rawptr, + rayTracingInvocationReorder: b32, +} + +PhysicalDeviceShaderCoreBuiltinsFeaturesARM :: struct { + sType: StructureType, + pNext: rawptr, + shaderCoreBuiltins: b32, +} + +PhysicalDeviceShaderCoreBuiltinsPropertiesARM :: struct { + sType: StructureType, + pNext: rawptr, + shaderCoreMask: u64, + shaderCoreCount: u32, + shaderWarpsPerCore: u32, +} + +PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + pipelineLibraryGroupHandles: b32, +} + +PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM :: struct { + sType: StructureType, + pNext: rawptr, + multiviewPerViewRenderAreas: b32, +} + +MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM :: struct { + sType: StructureType, + pNext: rawptr, + perViewRenderAreaCount: u32, + pPerViewRenderAreas: [^]Rect2D, +} + +PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + attachmentFeedbackLoopDynamicState: b32, } AccelerationStructureBuildRangeInfoKHR :: struct { @@ -5440,6 +6714,55 @@ PhysicalDeviceRayQueryFeaturesKHR :: struct { rayQuery: b32, } +PhysicalDeviceMeshShaderFeaturesEXT :: struct { + sType: StructureType, + pNext: rawptr, + taskShader: b32, + meshShader: b32, + multiviewMeshShader: b32, + primitiveFragmentShadingRateMeshShader: b32, + meshShaderQueries: b32, +} + +PhysicalDeviceMeshShaderPropertiesEXT :: struct { + sType: StructureType, + pNext: rawptr, + maxTaskWorkGroupTotalCount: u32, + maxTaskWorkGroupCount: [3]u32, + maxTaskWorkGroupInvocations: u32, + maxTaskWorkGroupSize: [3]u32, + maxTaskPayloadSize: u32, + maxTaskSharedMemorySize: u32, + maxTaskPayloadAndSharedMemorySize: u32, + maxMeshWorkGroupTotalCount: u32, + maxMeshWorkGroupCount: [3]u32, + maxMeshWorkGroupInvocations: u32, + maxMeshWorkGroupSize: [3]u32, + maxMeshSharedMemorySize: u32, + maxMeshPayloadAndSharedMemorySize: u32, + maxMeshOutputMemorySize: u32, + maxMeshPayloadAndOutputMemorySize: u32, + maxMeshOutputComponents: u32, + maxMeshOutputVertices: u32, + maxMeshOutputPrimitives: u32, + maxMeshOutputLayers: u32, + maxMeshMultiviewViewCount: u32, + meshOutputPerVertexGranularity: u32, + meshOutputPerPrimitiveGranularity: u32, + maxPreferredTaskWorkGroupInvocations: u32, + maxPreferredMeshWorkGroupInvocations: u32, + prefersLocalInvocationVertexOutput: b32, + prefersLocalInvocationPrimitiveOutput: b32, + prefersCompactVertexOutput: b32, + prefersCompactPrimitiveOutput: b32, +} + +DrawMeshTasksIndirectCommandEXT :: struct { + groupCountX: u32, + groupCountY: u32, + groupCountZ: u32, +} + Win32SurfaceCreateInfoKHR :: struct { sType: StructureType, pNext: rawptr, @@ -5599,6 +6922,87 @@ MetalSurfaceCreateInfoEXT :: struct { pLayer: ^CAMetalLayer, } +ExportMetalObjectCreateInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + exportObjectType: ExportMetalObjectTypeFlagsEXT, +} + +ExportMetalObjectsInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, +} + +ExportMetalDeviceInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + mtlDevice: MTLDevice_id, +} + +ExportMetalCommandQueueInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + queue: Queue, + mtlCommandQueue: MTLCommandQueue_id, +} + +ExportMetalBufferInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + memory: DeviceMemory, + mtlBuffer: MTLBuffer_id, +} + +ImportMetalBufferInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + mtlBuffer: MTLBuffer_id, +} + +ExportMetalTextureInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + image: Image, + imageView: ImageView, + bufferView: BufferView, + plane: ImageAspectFlags, + mtlTexture: MTLTexture_id, +} + +ImportMetalTextureInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + plane: ImageAspectFlags, + mtlTexture: MTLTexture_id, +} + +ExportMetalIOSurfaceInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + image: Image, + ioSurface: IOSurfaceRef, +} + +ImportMetalIOSurfaceInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + ioSurface: IOSurfaceRef, +} + +ExportMetalSharedEventInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + semaphore: Semaphore, + event: Event, + mtlSharedEvent: MTLSharedEvent_id, +} + +ImportMetalSharedEventInfoEXT :: struct { + sType: StructureType, + pNext: rawptr, + mtlSharedEvent: MTLSharedEvent_id, +} + MacOSSurfaceCreateInfoMVK :: struct { sType: StructureType, pNext: rawptr, @@ -5621,257 +7025,640 @@ WaylandSurfaceCreateInfoKHR :: struct { surface: ^wl_surface, } +VideoH264SpsVuiFlags :: struct { + bit_field: u32, +} + +VideoH264HrdParameters :: struct { + cpb_cnt_minus1: u8, + bit_rate_scale: u8, + cpb_size_scale: u8, + reserved1: u8, + bit_rate_value_minus1: [VIDEO_H264_CPB_CNT_LIST_SIZE]u32, + cpb_size_value_minus1: [VIDEO_H264_CPB_CNT_LIST_SIZE]u32, + cbr_flag: [VIDEO_H264_CPB_CNT_LIST_SIZE]u8, + initial_cpb_removal_delay_length_minus1: u32, + cpb_removal_delay_length_minus1: u32, + dpb_output_delay_length_minus1: u32, + time_offset_length: u32, +} + +VideoH264SequenceParameterSetVui :: struct { + flags: VideoH264SpsVuiFlags, + aspect_ratio_idc: VideoH264AspectRatioIdc, + sar_width: u16, + sar_height: u16, + video_format: u8, + colour_primaries: u8, + transfer_characteristics: u8, + matrix_coefficients: u8, + num_units_in_tick: u32, + time_scale: u32, + max_num_reorder_frames: u8, + max_dec_frame_buffering: u8, + chroma_sample_loc_type_top_field: u8, + chroma_sample_loc_type_bottom_field: u8, + reserved1: u32, + pHrdParameters: [^]VideoH264HrdParameters, +} + +VideoH264SpsFlags :: struct { + bit_field: u32, +} + +VideoH264ScalingLists :: struct { + scaling_list_present_mask: u16, + use_default_scaling_matrix_mask: u16, + ScalingList4x4: [VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]u8, + ScalingList8x8: [VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]u8, +} + +VideoH264SequenceParameterSet :: struct { + flags: VideoH264SpsFlags, + profile_idc: VideoH264ProfileIdc, + level_idc: VideoH264LevelIdc, + chroma_format_idc: VideoH264ChromaFormatIdc, + seq_parameter_set_id: u8, + bit_depth_luma_minus8: u8, + bit_depth_chroma_minus8: u8, + log2_max_frame_num_minus4: u8, + pic_order_cnt_type: VideoH264PocType, + offset_for_non_ref_pic: i32, + offset_for_top_to_bottom_field: i32, + log2_max_pic_order_cnt_lsb_minus4: u8, + num_ref_frames_in_pic_order_cnt_cycle: u8, + max_num_ref_frames: u8, + reserved1: u8, + pic_width_in_mbs_minus1: u32, + pic_height_in_map_units_minus1: u32, + frame_crop_left_offset: u32, + frame_crop_right_offset: u32, + frame_crop_top_offset: u32, + frame_crop_bottom_offset: u32, + reserved2: u32, + pOffsetForRefFrame: ^i32, + pScalingLists: [^]VideoH264ScalingLists, + pSequenceParameterSetVui: ^VideoH264SequenceParameterSetVui, +} + +VideoH264PpsFlags :: struct { + bit_field: u32, +} + +VideoH264PictureParameterSet :: struct { + flags: VideoH264PpsFlags, + seq_parameter_set_id: u8, + pic_parameter_set_id: u8, + num_ref_idx_l0_default_active_minus1: u8, + num_ref_idx_l1_default_active_minus1: u8, + weighted_bipred_idc: VideoH264WeightedBipredIdc, + pic_init_qp_minus26: i8, + pic_init_qs_minus26: i8, + chroma_qp_index_offset: i8, + second_chroma_qp_index_offset: i8, + pScalingLists: [^]VideoH264ScalingLists, +} + +VideoH265DecPicBufMgr :: struct { + max_latency_increase_plus1: [VIDEO_H265_SUBLAYERS_LIST_SIZE]u32, + max_dec_pic_buffering_minus1: [VIDEO_H265_SUBLAYERS_LIST_SIZE]u8, + max_num_reorder_pics: [VIDEO_H265_SUBLAYERS_LIST_SIZE]u8, +} + +VideoH265SubLayerHrdParameters :: struct { + bit_rate_value_minus1: [VIDEO_H265_CPB_CNT_LIST_SIZE]u32, + cpb_size_value_minus1: [VIDEO_H265_CPB_CNT_LIST_SIZE]u32, + cpb_size_du_value_minus1: [VIDEO_H265_CPB_CNT_LIST_SIZE]u32, + bit_rate_du_value_minus1: [VIDEO_H265_CPB_CNT_LIST_SIZE]u32, + cbr_flag: u32, +} + +VideoH265HrdFlags :: struct { + bit_field: u32, +} + +VideoH265HrdParameters :: struct { + flags: VideoH265HrdFlags, + tick_divisor_minus2: u8, + du_cpb_removal_delay_increment_length_minus1: u8, + dpb_output_delay_du_length_minus1: u8, + bit_rate_scale: u8, + cpb_size_scale: u8, + cpb_size_du_scale: u8, + initial_cpb_removal_delay_length_minus1: u8, + au_cpb_removal_delay_length_minus1: u8, + dpb_output_delay_length_minus1: u8, + cpb_cnt_minus1: [VIDEO_H265_SUBLAYERS_LIST_SIZE]u8, + elemental_duration_in_tc_minus1: [VIDEO_H265_SUBLAYERS_LIST_SIZE]u16, + reserved: [3]u16, + pSubLayerHrdParametersNal: ^VideoH265SubLayerHrdParameters, + pSubLayerHrdParametersVcl: ^VideoH265SubLayerHrdParameters, +} + +VideoH265VpsFlags :: struct { + bit_field: u32, +} + +VideoH265ProfileTierLevelFlags :: struct { + bit_field: u32, +} + +VideoH265ProfileTierLevel :: struct { + flags: VideoH265ProfileTierLevelFlags, + general_profile_idc: VideoH265ProfileIdc, + general_level_idc: VideoH265LevelIdc, +} + +VideoH265VideoParameterSet :: struct { + flags: VideoH265VpsFlags, + vps_video_parameter_set_id: u8, + vps_max_sub_layers_minus1: u8, + reserved1: u8, + reserved2: u8, + vps_num_units_in_tick: u32, + vps_time_scale: u32, + vps_num_ticks_poc_diff_one_minus1: u32, + reserved3: u32, + pDecPicBufMgr: ^VideoH265DecPicBufMgr, + pHrdParameters: [^]VideoH265HrdParameters, + pProfileTierLevel: ^VideoH265ProfileTierLevel, +} + +VideoH265ScalingLists :: struct { + ScalingList4x4: [VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]u8, + ScalingList8x8: [VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]u8, + ScalingList16x16: [VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]u8, + ScalingList32x32: [VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]u8, + ScalingListDCCoef16x16: [VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]u8, + ScalingListDCCoef32x32: [VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]u8, +} + +VideoH265SpsVuiFlags :: struct { + bit_field: u32, +} + +VideoH265SequenceParameterSetVui :: struct { + flags: VideoH265SpsVuiFlags, + aspect_ratio_idc: VideoH265AspectRatioIdc, + sar_width: u16, + sar_height: u16, + video_format: u8, + colour_primaries: u8, + transfer_characteristics: u8, + matrix_coeffs: u8, + chroma_sample_loc_type_top_field: u8, + chroma_sample_loc_type_bottom_field: u8, + reserved1: u8, + reserved2: u8, + def_disp_win_left_offset: u16, + def_disp_win_right_offset: u16, + def_disp_win_top_offset: u16, + def_disp_win_bottom_offset: u16, + vui_num_units_in_tick: u32, + vui_time_scale: u32, + vui_num_ticks_poc_diff_one_minus1: u32, + min_spatial_segmentation_idc: u16, + reserved3: u16, + max_bytes_per_pic_denom: u8, + max_bits_per_min_cu_denom: u8, + log2_max_mv_length_horizontal: u8, + log2_max_mv_length_vertical: u8, + pHrdParameters: [^]VideoH265HrdParameters, +} + +VideoH265PredictorPaletteEntries :: struct { + PredictorPaletteEntries: [VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]u16, +} + +VideoH265SpsFlags :: struct { + bit_field: u32, +} + +VideoH265ShortTermRefPicSetFlags :: struct { + bit_field: u32, +} + +VideoH265ShortTermRefPicSet :: struct { + flags: VideoH265ShortTermRefPicSetFlags, + delta_idx_minus1: u32, + use_delta_flag: u16, + abs_delta_rps_minus1: u16, + used_by_curr_pic_flag: u16, + used_by_curr_pic_s0_flag: u16, + used_by_curr_pic_s1_flag: u16, + reserved1: u16, + reserved2: u8, + reserved3: u8, + num_negative_pics: u8, + num_positive_pics: u8, + delta_poc_s0_minus1: [VIDEO_H265_MAX_DPB_SIZE]u16, + delta_poc_s1_minus1: [VIDEO_H265_MAX_DPB_SIZE]u16, +} + +VideoH265LongTermRefPicsSps :: struct { + used_by_curr_pic_lt_sps_flag: u32, + lt_ref_pic_poc_lsb_sps: [VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]u32, +} + +VideoH265SequenceParameterSet :: struct { + flags: VideoH265SpsFlags, + chroma_format_idc: VideoH265ChromaFormatIdc, + pic_width_in_luma_samples: u32, + pic_height_in_luma_samples: u32, + sps_video_parameter_set_id: u8, + sps_max_sub_layers_minus1: u8, + sps_seq_parameter_set_id: u8, + bit_depth_luma_minus8: u8, + bit_depth_chroma_minus8: u8, + log2_max_pic_order_cnt_lsb_minus4: u8, + log2_min_luma_coding_block_size_minus3: u8, + log2_diff_max_min_luma_coding_block_size: u8, + log2_min_luma_transform_block_size_minus2: u8, + log2_diff_max_min_luma_transform_block_size: u8, + max_transform_hierarchy_depth_inter: u8, + max_transform_hierarchy_depth_intra: u8, + num_short_term_ref_pic_sets: u8, + num_long_term_ref_pics_sps: u8, + pcm_sample_bit_depth_luma_minus1: u8, + pcm_sample_bit_depth_chroma_minus1: u8, + log2_min_pcm_luma_coding_block_size_minus3: u8, + log2_diff_max_min_pcm_luma_coding_block_size: u8, + reserved1: u8, + reserved2: u8, + palette_max_size: u8, + delta_palette_max_predictor_size: u8, + motion_vector_resolution_control_idc: u8, + sps_num_palette_predictor_initializers_minus1: u8, + conf_win_left_offset: u32, + conf_win_right_offset: u32, + conf_win_top_offset: u32, + conf_win_bottom_offset: u32, + pProfileTierLevel: ^VideoH265ProfileTierLevel, + pDecPicBufMgr: ^VideoH265DecPicBufMgr, + pScalingLists: [^]VideoH265ScalingLists, + pShortTermRefPicSet: ^VideoH265ShortTermRefPicSet, + pLongTermRefPicsSps: [^]VideoH265LongTermRefPicsSps, + pSequenceParameterSetVui: ^VideoH265SequenceParameterSetVui, + pPredictorPaletteEntries: [^]VideoH265PredictorPaletteEntries, +} + +VideoH265PpsFlags :: struct { + bit_field: u32, +} + +VideoH265PictureParameterSet :: struct { + flags: VideoH265PpsFlags, + pps_pic_parameter_set_id: u8, + pps_seq_parameter_set_id: u8, + sps_video_parameter_set_id: u8, + num_extra_slice_header_bits: u8, + num_ref_idx_l0_default_active_minus1: u8, + num_ref_idx_l1_default_active_minus1: u8, + init_qp_minus26: i8, + diff_cu_qp_delta_depth: u8, + pps_cb_qp_offset: i8, + pps_cr_qp_offset: i8, + pps_beta_offset_div2: i8, + pps_tc_offset_div2: i8, + log2_parallel_merge_level_minus2: u8, + log2_max_transform_skip_block_size_minus2: u8, + diff_cu_chroma_qp_offset_depth: u8, + chroma_qp_offset_list_len_minus1: u8, + cb_qp_offset_list: [VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]i8, + cr_qp_offset_list: [VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]i8, + log2_sao_offset_scale_luma: u8, + log2_sao_offset_scale_chroma: u8, + pps_act_y_qp_offset_plus5: i8, + pps_act_cb_qp_offset_plus5: i8, + pps_act_cr_qp_offset_plus3: i8, + pps_num_palette_predictor_initializers: u8, + luma_bit_depth_entry_minus8: u8, + chroma_bit_depth_entry_minus8: u8, + num_tile_columns_minus1: u8, + num_tile_rows_minus1: u8, + reserved1: u8, + reserved2: u8, + column_width_minus1: [VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]u16, + row_height_minus1: [VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]u16, + reserved3: u32, + pScalingLists: [^]VideoH265ScalingLists, + pPredictorPaletteEntries: [^]VideoH265PredictorPaletteEntries, +} + +VideoDecodeH264PictureInfoFlags :: struct { + bit_field: u32, +} + +VideoDecodeH264PictureInfo :: struct { + flags: VideoDecodeH264PictureInfoFlags, + seq_parameter_set_id: u8, + pic_parameter_set_id: u8, + reserved1: u8, + reserved2: u8, + frame_num: u16, + idr_pic_id: u16, + PicOrderCnt: [VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]i32, +} + +VideoDecodeH264ReferenceInfoFlags :: struct { + bit_field: u32, +} + +VideoDecodeH264ReferenceInfo :: struct { + flags: VideoDecodeH264ReferenceInfoFlags, + FrameNum: u16, + reserved: u16, + PicOrderCnt: [VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]i32, +} + +VideoDecodeH265PictureInfoFlags :: struct { + bit_field: u32, +} + +VideoDecodeH265PictureInfo :: struct { + flags: VideoDecodeH265PictureInfoFlags, + sps_video_parameter_set_id: u8, + pps_seq_parameter_set_id: u8, + pps_pic_parameter_set_id: u8, + NumDeltaPocsOfRefRpsIdx: u8, + PicOrderCntVal: i32, + NumBitsForSTRefPicSetInSlice: u16, + reserved: u16, + RefPicSetStCurrBefore: [VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]u8, + RefPicSetStCurrAfter: [VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]u8, + RefPicSetLtCurr: [VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]u8, +} + +VideoDecodeH265ReferenceInfoFlags :: struct { + bit_field: u32, +} + +VideoDecodeH265ReferenceInfo :: struct { + flags: VideoDecodeH265ReferenceInfoFlags, + PicOrderCntVal: i32, +} + // Opaque structs -wl_surface :: struct {} // Opaque struct defined by Wayland -wl_display :: struct {} // Opaque struct defined by Wayland +wl_surface :: struct {} // Opaque struct defined by Wayland +wl_display :: struct {} // Opaque struct defined by Wayland +IOSurfaceRef :: struct {} // Opaque struct defined by Apple’s CoreGraphics framework // Aliases -PhysicalDeviceVariablePointerFeatures :: PhysicalDeviceVariablePointersFeatures -PhysicalDeviceShaderDrawParameterFeatures :: PhysicalDeviceShaderDrawParametersFeatures -PipelineStageFlags2 :: Flags64 -PipelineStageFlag2 :: Flags64 -AccessFlags2 :: Flags64 -AccessFlag2 :: Flags64 -FormatFeatureFlags2 :: Flags64 -FormatFeatureFlag2 :: Flags64 -RenderingFlagsKHR :: RenderingFlags -RenderingFlagKHR :: RenderingFlag -RenderingInfoKHR :: RenderingInfo -RenderingAttachmentInfoKHR :: RenderingAttachmentInfo -PipelineRenderingCreateInfoKHR :: PipelineRenderingCreateInfo -PhysicalDeviceDynamicRenderingFeaturesKHR :: PhysicalDeviceDynamicRenderingFeatures -CommandBufferInheritanceRenderingInfoKHR :: CommandBufferInheritanceRenderingInfo -AttachmentSampleCountInfoNV :: AttachmentSampleCountInfoAMD -RenderPassMultiviewCreateInfoKHR :: RenderPassMultiviewCreateInfo -PhysicalDeviceMultiviewFeaturesKHR :: PhysicalDeviceMultiviewFeatures -PhysicalDeviceMultiviewPropertiesKHR :: PhysicalDeviceMultiviewProperties -PhysicalDeviceFeatures2KHR :: PhysicalDeviceFeatures2 -PhysicalDeviceProperties2KHR :: PhysicalDeviceProperties2 -FormatProperties2KHR :: FormatProperties2 -ImageFormatProperties2KHR :: ImageFormatProperties2 -PhysicalDeviceImageFormatInfo2KHR :: PhysicalDeviceImageFormatInfo2 -QueueFamilyProperties2KHR :: QueueFamilyProperties2 -PhysicalDeviceMemoryProperties2KHR :: PhysicalDeviceMemoryProperties2 -SparseImageFormatProperties2KHR :: SparseImageFormatProperties2 -PhysicalDeviceSparseImageFormatInfo2KHR :: PhysicalDeviceSparseImageFormatInfo2 -PeerMemoryFeatureFlagsKHR :: PeerMemoryFeatureFlags -PeerMemoryFeatureFlagKHR :: PeerMemoryFeatureFlag -MemoryAllocateFlagsKHR :: MemoryAllocateFlags -MemoryAllocateFlagKHR :: MemoryAllocateFlag -MemoryAllocateFlagsInfoKHR :: MemoryAllocateFlagsInfo -DeviceGroupRenderPassBeginInfoKHR :: DeviceGroupRenderPassBeginInfo -DeviceGroupCommandBufferBeginInfoKHR :: DeviceGroupCommandBufferBeginInfo -DeviceGroupSubmitInfoKHR :: DeviceGroupSubmitInfo -DeviceGroupBindSparseInfoKHR :: DeviceGroupBindSparseInfo -BindBufferMemoryDeviceGroupInfoKHR :: BindBufferMemoryDeviceGroupInfo -BindImageMemoryDeviceGroupInfoKHR :: BindImageMemoryDeviceGroupInfo -CommandPoolTrimFlagsKHR :: CommandPoolTrimFlags -PhysicalDeviceGroupPropertiesKHR :: PhysicalDeviceGroupProperties -DeviceGroupDeviceCreateInfoKHR :: DeviceGroupDeviceCreateInfo -ExternalMemoryHandleTypeFlagsKHR :: ExternalMemoryHandleTypeFlags -ExternalMemoryHandleTypeFlagKHR :: ExternalMemoryHandleTypeFlag -ExternalMemoryFeatureFlagsKHR :: ExternalMemoryFeatureFlags -ExternalMemoryFeatureFlagKHR :: ExternalMemoryFeatureFlag -ExternalMemoryPropertiesKHR :: ExternalMemoryProperties -PhysicalDeviceExternalImageFormatInfoKHR :: PhysicalDeviceExternalImageFormatInfo -ExternalImageFormatPropertiesKHR :: ExternalImageFormatProperties -PhysicalDeviceExternalBufferInfoKHR :: PhysicalDeviceExternalBufferInfo -ExternalBufferPropertiesKHR :: ExternalBufferProperties -PhysicalDeviceIDPropertiesKHR :: PhysicalDeviceIDProperties -ExternalMemoryImageCreateInfoKHR :: ExternalMemoryImageCreateInfo -ExternalMemoryBufferCreateInfoKHR :: ExternalMemoryBufferCreateInfo -ExportMemoryAllocateInfoKHR :: ExportMemoryAllocateInfo -ExternalSemaphoreHandleTypeFlagsKHR :: ExternalSemaphoreHandleTypeFlags -ExternalSemaphoreHandleTypeFlagKHR :: ExternalSemaphoreHandleTypeFlag -ExternalSemaphoreFeatureFlagsKHR :: ExternalSemaphoreFeatureFlags -ExternalSemaphoreFeatureFlagKHR :: ExternalSemaphoreFeatureFlag -PhysicalDeviceExternalSemaphoreInfoKHR :: PhysicalDeviceExternalSemaphoreInfo -ExternalSemaphorePropertiesKHR :: ExternalSemaphoreProperties -SemaphoreImportFlagsKHR :: SemaphoreImportFlags -SemaphoreImportFlagKHR :: SemaphoreImportFlag -ExportSemaphoreCreateInfoKHR :: ExportSemaphoreCreateInfo -PhysicalDeviceShaderFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features -PhysicalDeviceFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features -PhysicalDevice16BitStorageFeaturesKHR :: PhysicalDevice16BitStorageFeatures -DescriptorUpdateTemplateKHR :: DescriptorUpdateTemplate -DescriptorUpdateTemplateTypeKHR :: DescriptorUpdateTemplateType -DescriptorUpdateTemplateCreateFlagsKHR :: DescriptorUpdateTemplateCreateFlags -DescriptorUpdateTemplateEntryKHR :: DescriptorUpdateTemplateEntry -DescriptorUpdateTemplateCreateInfoKHR :: DescriptorUpdateTemplateCreateInfo -PhysicalDeviceImagelessFramebufferFeaturesKHR :: PhysicalDeviceImagelessFramebufferFeatures -FramebufferAttachmentsCreateInfoKHR :: FramebufferAttachmentsCreateInfo -FramebufferAttachmentImageInfoKHR :: FramebufferAttachmentImageInfo -RenderPassAttachmentBeginInfoKHR :: RenderPassAttachmentBeginInfo -RenderPassCreateInfo2KHR :: RenderPassCreateInfo2 -AttachmentDescription2KHR :: AttachmentDescription2 -AttachmentReference2KHR :: AttachmentReference2 -SubpassDescription2KHR :: SubpassDescription2 -SubpassDependency2KHR :: SubpassDependency2 -SubpassBeginInfoKHR :: SubpassBeginInfo -SubpassEndInfoKHR :: SubpassEndInfo -ExternalFenceHandleTypeFlagsKHR :: ExternalFenceHandleTypeFlags -ExternalFenceHandleTypeFlagKHR :: ExternalFenceHandleTypeFlag -ExternalFenceFeatureFlagsKHR :: ExternalFenceFeatureFlags -ExternalFenceFeatureFlagKHR :: ExternalFenceFeatureFlag -PhysicalDeviceExternalFenceInfoKHR :: PhysicalDeviceExternalFenceInfo -ExternalFencePropertiesKHR :: ExternalFenceProperties -FenceImportFlagsKHR :: FenceImportFlags -FenceImportFlagKHR :: FenceImportFlag -ExportFenceCreateInfoKHR :: ExportFenceCreateInfo -PointClippingBehaviorKHR :: PointClippingBehavior -TessellationDomainOriginKHR :: TessellationDomainOrigin -PhysicalDevicePointClippingPropertiesKHR :: PhysicalDevicePointClippingProperties -RenderPassInputAttachmentAspectCreateInfoKHR :: RenderPassInputAttachmentAspectCreateInfo -InputAttachmentAspectReferenceKHR :: InputAttachmentAspectReference -ImageViewUsageCreateInfoKHR :: ImageViewUsageCreateInfo -PipelineTessellationDomainOriginStateCreateInfoKHR :: PipelineTessellationDomainOriginStateCreateInfo -PhysicalDeviceVariablePointerFeaturesKHR :: PhysicalDeviceVariablePointersFeatures -PhysicalDeviceVariablePointersFeaturesKHR :: PhysicalDeviceVariablePointersFeatures -MemoryDedicatedRequirementsKHR :: MemoryDedicatedRequirements -MemoryDedicatedAllocateInfoKHR :: MemoryDedicatedAllocateInfo -BufferMemoryRequirementsInfo2KHR :: BufferMemoryRequirementsInfo2 -ImageMemoryRequirementsInfo2KHR :: ImageMemoryRequirementsInfo2 -ImageSparseMemoryRequirementsInfo2KHR :: ImageSparseMemoryRequirementsInfo2 -MemoryRequirements2KHR :: MemoryRequirements2 -SparseImageMemoryRequirements2KHR :: SparseImageMemoryRequirements2 -ImageFormatListCreateInfoKHR :: ImageFormatListCreateInfo -SamplerYcbcrConversionKHR :: SamplerYcbcrConversion -SamplerYcbcrModelConversionKHR :: SamplerYcbcrModelConversion -SamplerYcbcrRangeKHR :: SamplerYcbcrRange -ChromaLocationKHR :: ChromaLocation -SamplerYcbcrConversionCreateInfoKHR :: SamplerYcbcrConversionCreateInfo -SamplerYcbcrConversionInfoKHR :: SamplerYcbcrConversionInfo -BindImagePlaneMemoryInfoKHR :: BindImagePlaneMemoryInfo -ImagePlaneMemoryRequirementsInfoKHR :: ImagePlaneMemoryRequirementsInfo -PhysicalDeviceSamplerYcbcrConversionFeaturesKHR :: PhysicalDeviceSamplerYcbcrConversionFeatures -SamplerYcbcrConversionImageFormatPropertiesKHR :: SamplerYcbcrConversionImageFormatProperties -BindBufferMemoryInfoKHR :: BindBufferMemoryInfo -BindImageMemoryInfoKHR :: BindImageMemoryInfo -PhysicalDeviceMaintenance3PropertiesKHR :: PhysicalDeviceMaintenance3Properties -DescriptorSetLayoutSupportKHR :: DescriptorSetLayoutSupport -PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR :: PhysicalDeviceShaderSubgroupExtendedTypesFeatures -PhysicalDevice8BitStorageFeaturesKHR :: PhysicalDevice8BitStorageFeatures -PhysicalDeviceShaderAtomicInt64FeaturesKHR :: PhysicalDeviceShaderAtomicInt64Features -DriverIdKHR :: DriverId -ConformanceVersionKHR :: ConformanceVersion -PhysicalDeviceDriverPropertiesKHR :: PhysicalDeviceDriverProperties -ShaderFloatControlsIndependenceKHR :: ShaderFloatControlsIndependence -PhysicalDeviceFloatControlsPropertiesKHR :: PhysicalDeviceFloatControlsProperties -ResolveModeFlagKHR :: ResolveModeFlag -ResolveModeFlagsKHR :: ResolveModeFlags -SubpassDescriptionDepthStencilResolveKHR :: SubpassDescriptionDepthStencilResolve -PhysicalDeviceDepthStencilResolvePropertiesKHR :: PhysicalDeviceDepthStencilResolveProperties -SemaphoreTypeKHR :: SemaphoreType -SemaphoreWaitFlagKHR :: SemaphoreWaitFlag -SemaphoreWaitFlagsKHR :: SemaphoreWaitFlags -PhysicalDeviceTimelineSemaphoreFeaturesKHR :: PhysicalDeviceTimelineSemaphoreFeatures -PhysicalDeviceTimelineSemaphorePropertiesKHR :: PhysicalDeviceTimelineSemaphoreProperties -SemaphoreTypeCreateInfoKHR :: SemaphoreTypeCreateInfo -TimelineSemaphoreSubmitInfoKHR :: TimelineSemaphoreSubmitInfo -SemaphoreWaitInfoKHR :: SemaphoreWaitInfo -SemaphoreSignalInfoKHR :: SemaphoreSignalInfo -PhysicalDeviceVulkanMemoryModelFeaturesKHR :: PhysicalDeviceVulkanMemoryModelFeatures -PhysicalDeviceShaderTerminateInvocationFeaturesKHR :: PhysicalDeviceShaderTerminateInvocationFeatures -PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR :: PhysicalDeviceSeparateDepthStencilLayoutsFeatures -AttachmentReferenceStencilLayoutKHR :: AttachmentReferenceStencilLayout -AttachmentDescriptionStencilLayoutKHR :: AttachmentDescriptionStencilLayout -PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR :: PhysicalDeviceUniformBufferStandardLayoutFeatures -PhysicalDeviceBufferDeviceAddressFeaturesKHR :: PhysicalDeviceBufferDeviceAddressFeatures -BufferDeviceAddressInfoKHR :: BufferDeviceAddressInfo -BufferOpaqueCaptureAddressCreateInfoKHR :: BufferOpaqueCaptureAddressCreateInfo -MemoryOpaqueCaptureAddressAllocateInfoKHR :: MemoryOpaqueCaptureAddressAllocateInfo -DeviceMemoryOpaqueCaptureAddressInfoKHR :: DeviceMemoryOpaqueCaptureAddressInfo -PhysicalDeviceShaderIntegerDotProductFeaturesKHR :: PhysicalDeviceShaderIntegerDotProductFeatures -PhysicalDeviceShaderIntegerDotProductPropertiesKHR :: PhysicalDeviceShaderIntegerDotProductProperties -PipelineStageFlags2KHR :: PipelineStageFlags2 -PipelineStageFlag2KHR :: PipelineStageFlag2 -AccessFlags2KHR :: AccessFlags2 -AccessFlag2KHR :: AccessFlag2 -SubmitFlagKHR :: SubmitFlag -SubmitFlagsKHR :: SubmitFlags -MemoryBarrier2KHR :: MemoryBarrier2 -BufferMemoryBarrier2KHR :: BufferMemoryBarrier2 -ImageMemoryBarrier2KHR :: ImageMemoryBarrier2 -DependencyInfoKHR :: DependencyInfo -SubmitInfo2KHR :: SubmitInfo2 -SemaphoreSubmitInfoKHR :: SemaphoreSubmitInfo -CommandBufferSubmitInfoKHR :: CommandBufferSubmitInfo -PhysicalDeviceSynchronization2FeaturesKHR :: PhysicalDeviceSynchronization2Features -PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR :: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures -CopyBufferInfo2KHR :: CopyBufferInfo2 -CopyImageInfo2KHR :: CopyImageInfo2 -CopyBufferToImageInfo2KHR :: CopyBufferToImageInfo2 -CopyImageToBufferInfo2KHR :: CopyImageToBufferInfo2 -BlitImageInfo2KHR :: BlitImageInfo2 -ResolveImageInfo2KHR :: ResolveImageInfo2 -BufferCopy2KHR :: BufferCopy2 -ImageCopy2KHR :: ImageCopy2 -ImageBlit2KHR :: ImageBlit2 -BufferImageCopy2KHR :: BufferImageCopy2 -ImageResolve2KHR :: ImageResolve2 -FormatFeatureFlags2KHR :: FormatFeatureFlags2 -FormatFeatureFlag2KHR :: FormatFeatureFlag2 -FormatProperties3KHR :: FormatProperties3 -PhysicalDeviceMaintenance4FeaturesKHR :: PhysicalDeviceMaintenance4Features -PhysicalDeviceMaintenance4PropertiesKHR :: PhysicalDeviceMaintenance4Properties -DeviceBufferMemoryRequirementsKHR :: DeviceBufferMemoryRequirements -DeviceImageMemoryRequirementsKHR :: DeviceImageMemoryRequirements -PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT :: PhysicalDeviceTextureCompressionASTCHDRFeatures -SamplerReductionModeEXT :: SamplerReductionMode -SamplerReductionModeCreateInfoEXT :: SamplerReductionModeCreateInfo -PhysicalDeviceSamplerFilterMinmaxPropertiesEXT :: PhysicalDeviceSamplerFilterMinmaxProperties -PhysicalDeviceInlineUniformBlockFeaturesEXT :: PhysicalDeviceInlineUniformBlockFeatures -PhysicalDeviceInlineUniformBlockPropertiesEXT :: PhysicalDeviceInlineUniformBlockProperties -WriteDescriptorSetInlineUniformBlockEXT :: WriteDescriptorSetInlineUniformBlock -DescriptorPoolInlineUniformBlockCreateInfoEXT :: DescriptorPoolInlineUniformBlockCreateInfo -DescriptorBindingFlagEXT :: DescriptorBindingFlag -DescriptorBindingFlagsEXT :: DescriptorBindingFlags -DescriptorSetLayoutBindingFlagsCreateInfoEXT :: DescriptorSetLayoutBindingFlagsCreateInfo -PhysicalDeviceDescriptorIndexingFeaturesEXT :: PhysicalDeviceDescriptorIndexingFeatures -PhysicalDeviceDescriptorIndexingPropertiesEXT :: PhysicalDeviceDescriptorIndexingProperties -DescriptorSetVariableDescriptorCountAllocateInfoEXT :: DescriptorSetVariableDescriptorCountAllocateInfo -DescriptorSetVariableDescriptorCountLayoutSupportEXT :: DescriptorSetVariableDescriptorCountLayoutSupport -RayTracingShaderGroupTypeNV :: RayTracingShaderGroupTypeKHR -GeometryTypeNV :: GeometryTypeKHR -AccelerationStructureTypeNV :: AccelerationStructureTypeKHR -CopyAccelerationStructureModeNV :: CopyAccelerationStructureModeKHR -GeometryFlagsNV :: GeometryFlagsKHR -GeometryFlagNV :: GeometryFlagKHR -GeometryInstanceFlagsNV :: GeometryInstanceFlagsKHR -GeometryInstanceFlagNV :: GeometryInstanceFlagKHR -BuildAccelerationStructureFlagsNV :: BuildAccelerationStructureFlagsKHR -BuildAccelerationStructureFlagNV :: BuildAccelerationStructureFlagKHR -TransformMatrixNV :: TransformMatrixKHR -AabbPositionsNV :: AabbPositionsKHR -AccelerationStructureInstanceNV :: AccelerationStructureInstanceKHR -QueueGlobalPriorityEXT :: QueueGlobalPriorityKHR -DeviceQueueGlobalPriorityCreateInfoEXT :: DeviceQueueGlobalPriorityCreateInfoKHR -PipelineCreationFeedbackFlagEXT :: PipelineCreationFeedbackFlag -PipelineCreationFeedbackFlagsEXT :: PipelineCreationFeedbackFlags -PipelineCreationFeedbackCreateInfoEXT :: PipelineCreationFeedbackCreateInfo -PipelineCreationFeedbackEXT :: PipelineCreationFeedback -QueryPoolCreateInfoINTEL :: QueryPoolPerformanceQueryCreateInfoINTEL -PhysicalDeviceScalarBlockLayoutFeaturesEXT :: PhysicalDeviceScalarBlockLayoutFeatures -PhysicalDeviceSubgroupSizeControlFeaturesEXT :: PhysicalDeviceSubgroupSizeControlFeatures -PhysicalDeviceSubgroupSizeControlPropertiesEXT :: PhysicalDeviceSubgroupSizeControlProperties -PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT :: PipelineShaderStageRequiredSubgroupSizeCreateInfo -PhysicalDeviceBufferAddressFeaturesEXT :: PhysicalDeviceBufferDeviceAddressFeaturesEXT -BufferDeviceAddressInfoEXT :: BufferDeviceAddressInfo -ToolPurposeFlagEXT :: ToolPurposeFlag -ToolPurposeFlagsEXT :: ToolPurposeFlags -PhysicalDeviceToolPropertiesEXT :: PhysicalDeviceToolProperties -ImageStencilUsageCreateInfoEXT :: ImageStencilUsageCreateInfo -PhysicalDeviceHostQueryResetFeaturesEXT :: PhysicalDeviceHostQueryResetFeatures -PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT :: PhysicalDeviceShaderDemoteToHelperInvocationFeatures -PhysicalDeviceTexelBufferAlignmentPropertiesEXT :: PhysicalDeviceTexelBufferAlignmentProperties -PrivateDataSlotEXT :: PrivateDataSlot -PrivateDataSlotCreateFlagsEXT :: PrivateDataSlotCreateFlags -PhysicalDevicePrivateDataFeaturesEXT :: PhysicalDevicePrivateDataFeatures -DevicePrivateDataCreateInfoEXT :: DevicePrivateDataCreateInfo -PrivateDataSlotCreateInfoEXT :: PrivateDataSlotCreateInfo -PhysicalDevicePipelineCreationCacheControlFeaturesEXT :: PhysicalDevicePipelineCreationCacheControlFeatures -PhysicalDeviceImageRobustnessFeaturesEXT :: PhysicalDeviceImageRobustnessFeatures -PhysicalDeviceGlobalPriorityQueryFeaturesEXT :: PhysicalDeviceGlobalPriorityQueryFeaturesKHR -QueueFamilyGlobalPriorityPropertiesEXT :: QueueFamilyGlobalPriorityPropertiesKHR +PhysicalDeviceVariablePointerFeatures :: PhysicalDeviceVariablePointersFeatures +PhysicalDeviceShaderDrawParameterFeatures :: PhysicalDeviceShaderDrawParametersFeatures +PipelineStageFlags2 :: Flags64 +PipelineStageFlag2 :: Flags64 +AccessFlags2 :: Flags64 +AccessFlag2 :: Flags64 +FormatFeatureFlags2 :: Flags64 +FormatFeatureFlag2 :: Flags64 +RenderingFlagsKHR :: RenderingFlags +RenderingFlagKHR :: RenderingFlag +RenderingInfoKHR :: RenderingInfo +RenderingAttachmentInfoKHR :: RenderingAttachmentInfo +PipelineRenderingCreateInfoKHR :: PipelineRenderingCreateInfo +PhysicalDeviceDynamicRenderingFeaturesKHR :: PhysicalDeviceDynamicRenderingFeatures +CommandBufferInheritanceRenderingInfoKHR :: CommandBufferInheritanceRenderingInfo +AttachmentSampleCountInfoNV :: AttachmentSampleCountInfoAMD +RenderPassMultiviewCreateInfoKHR :: RenderPassMultiviewCreateInfo +PhysicalDeviceMultiviewFeaturesKHR :: PhysicalDeviceMultiviewFeatures +PhysicalDeviceMultiviewPropertiesKHR :: PhysicalDeviceMultiviewProperties +PhysicalDeviceFeatures2KHR :: PhysicalDeviceFeatures2 +PhysicalDeviceProperties2KHR :: PhysicalDeviceProperties2 +FormatProperties2KHR :: FormatProperties2 +ImageFormatProperties2KHR :: ImageFormatProperties2 +PhysicalDeviceImageFormatInfo2KHR :: PhysicalDeviceImageFormatInfo2 +QueueFamilyProperties2KHR :: QueueFamilyProperties2 +PhysicalDeviceMemoryProperties2KHR :: PhysicalDeviceMemoryProperties2 +SparseImageFormatProperties2KHR :: SparseImageFormatProperties2 +PhysicalDeviceSparseImageFormatInfo2KHR :: PhysicalDeviceSparseImageFormatInfo2 +PeerMemoryFeatureFlagsKHR :: PeerMemoryFeatureFlags +PeerMemoryFeatureFlagKHR :: PeerMemoryFeatureFlag +MemoryAllocateFlagsKHR :: MemoryAllocateFlags +MemoryAllocateFlagKHR :: MemoryAllocateFlag +MemoryAllocateFlagsInfoKHR :: MemoryAllocateFlagsInfo +DeviceGroupRenderPassBeginInfoKHR :: DeviceGroupRenderPassBeginInfo +DeviceGroupCommandBufferBeginInfoKHR :: DeviceGroupCommandBufferBeginInfo +DeviceGroupSubmitInfoKHR :: DeviceGroupSubmitInfo +DeviceGroupBindSparseInfoKHR :: DeviceGroupBindSparseInfo +BindBufferMemoryDeviceGroupInfoKHR :: BindBufferMemoryDeviceGroupInfo +BindImageMemoryDeviceGroupInfoKHR :: BindImageMemoryDeviceGroupInfo +CommandPoolTrimFlagsKHR :: CommandPoolTrimFlags +PhysicalDeviceGroupPropertiesKHR :: PhysicalDeviceGroupProperties +DeviceGroupDeviceCreateInfoKHR :: DeviceGroupDeviceCreateInfo +ExternalMemoryHandleTypeFlagsKHR :: ExternalMemoryHandleTypeFlags +ExternalMemoryHandleTypeFlagKHR :: ExternalMemoryHandleTypeFlag +ExternalMemoryFeatureFlagsKHR :: ExternalMemoryFeatureFlags +ExternalMemoryFeatureFlagKHR :: ExternalMemoryFeatureFlag +ExternalMemoryPropertiesKHR :: ExternalMemoryProperties +PhysicalDeviceExternalImageFormatInfoKHR :: PhysicalDeviceExternalImageFormatInfo +ExternalImageFormatPropertiesKHR :: ExternalImageFormatProperties +PhysicalDeviceExternalBufferInfoKHR :: PhysicalDeviceExternalBufferInfo +ExternalBufferPropertiesKHR :: ExternalBufferProperties +PhysicalDeviceIDPropertiesKHR :: PhysicalDeviceIDProperties +ExternalMemoryImageCreateInfoKHR :: ExternalMemoryImageCreateInfo +ExternalMemoryBufferCreateInfoKHR :: ExternalMemoryBufferCreateInfo +ExportMemoryAllocateInfoKHR :: ExportMemoryAllocateInfo +ExternalSemaphoreHandleTypeFlagsKHR :: ExternalSemaphoreHandleTypeFlags +ExternalSemaphoreHandleTypeFlagKHR :: ExternalSemaphoreHandleTypeFlag +ExternalSemaphoreFeatureFlagsKHR :: ExternalSemaphoreFeatureFlags +ExternalSemaphoreFeatureFlagKHR :: ExternalSemaphoreFeatureFlag +PhysicalDeviceExternalSemaphoreInfoKHR :: PhysicalDeviceExternalSemaphoreInfo +ExternalSemaphorePropertiesKHR :: ExternalSemaphoreProperties +SemaphoreImportFlagsKHR :: SemaphoreImportFlags +SemaphoreImportFlagKHR :: SemaphoreImportFlag +ExportSemaphoreCreateInfoKHR :: ExportSemaphoreCreateInfo +PhysicalDeviceShaderFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features +PhysicalDeviceFloat16Int8FeaturesKHR :: PhysicalDeviceShaderFloat16Int8Features +PhysicalDevice16BitStorageFeaturesKHR :: PhysicalDevice16BitStorageFeatures +DescriptorUpdateTemplateKHR :: DescriptorUpdateTemplate +DescriptorUpdateTemplateTypeKHR :: DescriptorUpdateTemplateType +DescriptorUpdateTemplateCreateFlagsKHR :: DescriptorUpdateTemplateCreateFlags +DescriptorUpdateTemplateEntryKHR :: DescriptorUpdateTemplateEntry +DescriptorUpdateTemplateCreateInfoKHR :: DescriptorUpdateTemplateCreateInfo +PhysicalDeviceImagelessFramebufferFeaturesKHR :: PhysicalDeviceImagelessFramebufferFeatures +FramebufferAttachmentsCreateInfoKHR :: FramebufferAttachmentsCreateInfo +FramebufferAttachmentImageInfoKHR :: FramebufferAttachmentImageInfo +RenderPassAttachmentBeginInfoKHR :: RenderPassAttachmentBeginInfo +RenderPassCreateInfo2KHR :: RenderPassCreateInfo2 +AttachmentDescription2KHR :: AttachmentDescription2 +AttachmentReference2KHR :: AttachmentReference2 +SubpassDescription2KHR :: SubpassDescription2 +SubpassDependency2KHR :: SubpassDependency2 +SubpassBeginInfoKHR :: SubpassBeginInfo +SubpassEndInfoKHR :: SubpassEndInfo +ExternalFenceHandleTypeFlagsKHR :: ExternalFenceHandleTypeFlags +ExternalFenceHandleTypeFlagKHR :: ExternalFenceHandleTypeFlag +ExternalFenceFeatureFlagsKHR :: ExternalFenceFeatureFlags +ExternalFenceFeatureFlagKHR :: ExternalFenceFeatureFlag +PhysicalDeviceExternalFenceInfoKHR :: PhysicalDeviceExternalFenceInfo +ExternalFencePropertiesKHR :: ExternalFenceProperties +FenceImportFlagsKHR :: FenceImportFlags +FenceImportFlagKHR :: FenceImportFlag +ExportFenceCreateInfoKHR :: ExportFenceCreateInfo +PointClippingBehaviorKHR :: PointClippingBehavior +TessellationDomainOriginKHR :: TessellationDomainOrigin +PhysicalDevicePointClippingPropertiesKHR :: PhysicalDevicePointClippingProperties +RenderPassInputAttachmentAspectCreateInfoKHR :: RenderPassInputAttachmentAspectCreateInfo +InputAttachmentAspectReferenceKHR :: InputAttachmentAspectReference +ImageViewUsageCreateInfoKHR :: ImageViewUsageCreateInfo +PipelineTessellationDomainOriginStateCreateInfoKHR :: PipelineTessellationDomainOriginStateCreateInfo +PhysicalDeviceVariablePointerFeaturesKHR :: PhysicalDeviceVariablePointersFeatures +PhysicalDeviceVariablePointersFeaturesKHR :: PhysicalDeviceVariablePointersFeatures +MemoryDedicatedRequirementsKHR :: MemoryDedicatedRequirements +MemoryDedicatedAllocateInfoKHR :: MemoryDedicatedAllocateInfo +BufferMemoryRequirementsInfo2KHR :: BufferMemoryRequirementsInfo2 +ImageMemoryRequirementsInfo2KHR :: ImageMemoryRequirementsInfo2 +ImageSparseMemoryRequirementsInfo2KHR :: ImageSparseMemoryRequirementsInfo2 +MemoryRequirements2KHR :: MemoryRequirements2 +SparseImageMemoryRequirements2KHR :: SparseImageMemoryRequirements2 +ImageFormatListCreateInfoKHR :: ImageFormatListCreateInfo +SamplerYcbcrConversionKHR :: SamplerYcbcrConversion +SamplerYcbcrModelConversionKHR :: SamplerYcbcrModelConversion +SamplerYcbcrRangeKHR :: SamplerYcbcrRange +ChromaLocationKHR :: ChromaLocation +SamplerYcbcrConversionCreateInfoKHR :: SamplerYcbcrConversionCreateInfo +SamplerYcbcrConversionInfoKHR :: SamplerYcbcrConversionInfo +BindImagePlaneMemoryInfoKHR :: BindImagePlaneMemoryInfo +ImagePlaneMemoryRequirementsInfoKHR :: ImagePlaneMemoryRequirementsInfo +PhysicalDeviceSamplerYcbcrConversionFeaturesKHR :: PhysicalDeviceSamplerYcbcrConversionFeatures +SamplerYcbcrConversionImageFormatPropertiesKHR :: SamplerYcbcrConversionImageFormatProperties +BindBufferMemoryInfoKHR :: BindBufferMemoryInfo +BindImageMemoryInfoKHR :: BindImageMemoryInfo +PhysicalDeviceMaintenance3PropertiesKHR :: PhysicalDeviceMaintenance3Properties +DescriptorSetLayoutSupportKHR :: DescriptorSetLayoutSupport +PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR :: PhysicalDeviceShaderSubgroupExtendedTypesFeatures +PhysicalDevice8BitStorageFeaturesKHR :: PhysicalDevice8BitStorageFeatures +PhysicalDeviceShaderAtomicInt64FeaturesKHR :: PhysicalDeviceShaderAtomicInt64Features +DriverIdKHR :: DriverId +ConformanceVersionKHR :: ConformanceVersion +PhysicalDeviceDriverPropertiesKHR :: PhysicalDeviceDriverProperties +ShaderFloatControlsIndependenceKHR :: ShaderFloatControlsIndependence +PhysicalDeviceFloatControlsPropertiesKHR :: PhysicalDeviceFloatControlsProperties +ResolveModeFlagKHR :: ResolveModeFlag +ResolveModeFlagsKHR :: ResolveModeFlags +SubpassDescriptionDepthStencilResolveKHR :: SubpassDescriptionDepthStencilResolve +PhysicalDeviceDepthStencilResolvePropertiesKHR :: PhysicalDeviceDepthStencilResolveProperties +SemaphoreTypeKHR :: SemaphoreType +SemaphoreWaitFlagKHR :: SemaphoreWaitFlag +SemaphoreWaitFlagsKHR :: SemaphoreWaitFlags +PhysicalDeviceTimelineSemaphoreFeaturesKHR :: PhysicalDeviceTimelineSemaphoreFeatures +PhysicalDeviceTimelineSemaphorePropertiesKHR :: PhysicalDeviceTimelineSemaphoreProperties +SemaphoreTypeCreateInfoKHR :: SemaphoreTypeCreateInfo +TimelineSemaphoreSubmitInfoKHR :: TimelineSemaphoreSubmitInfo +SemaphoreWaitInfoKHR :: SemaphoreWaitInfo +SemaphoreSignalInfoKHR :: SemaphoreSignalInfo +PhysicalDeviceVulkanMemoryModelFeaturesKHR :: PhysicalDeviceVulkanMemoryModelFeatures +PhysicalDeviceShaderTerminateInvocationFeaturesKHR :: PhysicalDeviceShaderTerminateInvocationFeatures +PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR :: PhysicalDeviceSeparateDepthStencilLayoutsFeatures +AttachmentReferenceStencilLayoutKHR :: AttachmentReferenceStencilLayout +AttachmentDescriptionStencilLayoutKHR :: AttachmentDescriptionStencilLayout +PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR :: PhysicalDeviceUniformBufferStandardLayoutFeatures +PhysicalDeviceBufferDeviceAddressFeaturesKHR :: PhysicalDeviceBufferDeviceAddressFeatures +BufferDeviceAddressInfoKHR :: BufferDeviceAddressInfo +BufferOpaqueCaptureAddressCreateInfoKHR :: BufferOpaqueCaptureAddressCreateInfo +MemoryOpaqueCaptureAddressAllocateInfoKHR :: MemoryOpaqueCaptureAddressAllocateInfo +DeviceMemoryOpaqueCaptureAddressInfoKHR :: DeviceMemoryOpaqueCaptureAddressInfo +PhysicalDeviceShaderIntegerDotProductFeaturesKHR :: PhysicalDeviceShaderIntegerDotProductFeatures +PhysicalDeviceShaderIntegerDotProductPropertiesKHR :: PhysicalDeviceShaderIntegerDotProductProperties +PipelineStageFlags2KHR :: PipelineStageFlags2 +PipelineStageFlag2KHR :: PipelineStageFlag2 +AccessFlags2KHR :: AccessFlags2 +AccessFlag2KHR :: AccessFlag2 +SubmitFlagKHR :: SubmitFlag +SubmitFlagsKHR :: SubmitFlags +MemoryBarrier2KHR :: MemoryBarrier2 +BufferMemoryBarrier2KHR :: BufferMemoryBarrier2 +ImageMemoryBarrier2KHR :: ImageMemoryBarrier2 +DependencyInfoKHR :: DependencyInfo +SubmitInfo2KHR :: SubmitInfo2 +SemaphoreSubmitInfoKHR :: SemaphoreSubmitInfo +CommandBufferSubmitInfoKHR :: CommandBufferSubmitInfo +PhysicalDeviceSynchronization2FeaturesKHR :: PhysicalDeviceSynchronization2Features +PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR :: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures +CopyBufferInfo2KHR :: CopyBufferInfo2 +CopyImageInfo2KHR :: CopyImageInfo2 +CopyBufferToImageInfo2KHR :: CopyBufferToImageInfo2 +CopyImageToBufferInfo2KHR :: CopyImageToBufferInfo2 +BlitImageInfo2KHR :: BlitImageInfo2 +ResolveImageInfo2KHR :: ResolveImageInfo2 +BufferCopy2KHR :: BufferCopy2 +ImageCopy2KHR :: ImageCopy2 +ImageBlit2KHR :: ImageBlit2 +BufferImageCopy2KHR :: BufferImageCopy2 +ImageResolve2KHR :: ImageResolve2 +FormatFeatureFlags2KHR :: FormatFeatureFlags2 +FormatFeatureFlag2KHR :: FormatFeatureFlag2 +FormatProperties3KHR :: FormatProperties3 +PhysicalDeviceMaintenance4FeaturesKHR :: PhysicalDeviceMaintenance4Features +PhysicalDeviceMaintenance4PropertiesKHR :: PhysicalDeviceMaintenance4Properties +DeviceBufferMemoryRequirementsKHR :: DeviceBufferMemoryRequirements +DeviceImageMemoryRequirementsKHR :: DeviceImageMemoryRequirements +PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT :: PhysicalDeviceTextureCompressionASTCHDRFeatures +SamplerReductionModeEXT :: SamplerReductionMode +SamplerReductionModeCreateInfoEXT :: SamplerReductionModeCreateInfo +PhysicalDeviceSamplerFilterMinmaxPropertiesEXT :: PhysicalDeviceSamplerFilterMinmaxProperties +PhysicalDeviceInlineUniformBlockFeaturesEXT :: PhysicalDeviceInlineUniformBlockFeatures +PhysicalDeviceInlineUniformBlockPropertiesEXT :: PhysicalDeviceInlineUniformBlockProperties +WriteDescriptorSetInlineUniformBlockEXT :: WriteDescriptorSetInlineUniformBlock +DescriptorPoolInlineUniformBlockCreateInfoEXT :: DescriptorPoolInlineUniformBlockCreateInfo +DescriptorBindingFlagEXT :: DescriptorBindingFlag +DescriptorBindingFlagsEXT :: DescriptorBindingFlags +DescriptorSetLayoutBindingFlagsCreateInfoEXT :: DescriptorSetLayoutBindingFlagsCreateInfo +PhysicalDeviceDescriptorIndexingFeaturesEXT :: PhysicalDeviceDescriptorIndexingFeatures +PhysicalDeviceDescriptorIndexingPropertiesEXT :: PhysicalDeviceDescriptorIndexingProperties +DescriptorSetVariableDescriptorCountAllocateInfoEXT :: DescriptorSetVariableDescriptorCountAllocateInfo +DescriptorSetVariableDescriptorCountLayoutSupportEXT :: DescriptorSetVariableDescriptorCountLayoutSupport +RayTracingShaderGroupTypeNV :: RayTracingShaderGroupTypeKHR +GeometryTypeNV :: GeometryTypeKHR +AccelerationStructureTypeNV :: AccelerationStructureTypeKHR +CopyAccelerationStructureModeNV :: CopyAccelerationStructureModeKHR +GeometryFlagsNV :: GeometryFlagsKHR +GeometryFlagNV :: GeometryFlagKHR +GeometryInstanceFlagsNV :: GeometryInstanceFlagsKHR +GeometryInstanceFlagNV :: GeometryInstanceFlagKHR +BuildAccelerationStructureFlagsNV :: BuildAccelerationStructureFlagsKHR +BuildAccelerationStructureFlagNV :: BuildAccelerationStructureFlagKHR +TransformMatrixNV :: TransformMatrixKHR +AabbPositionsNV :: AabbPositionsKHR +AccelerationStructureInstanceNV :: AccelerationStructureInstanceKHR +QueueGlobalPriorityEXT :: QueueGlobalPriorityKHR +DeviceQueueGlobalPriorityCreateInfoEXT :: DeviceQueueGlobalPriorityCreateInfoKHR +PipelineCreationFeedbackFlagEXT :: PipelineCreationFeedbackFlag +PipelineCreationFeedbackFlagsEXT :: PipelineCreationFeedbackFlags +PipelineCreationFeedbackCreateInfoEXT :: PipelineCreationFeedbackCreateInfo +PipelineCreationFeedbackEXT :: PipelineCreationFeedback +PhysicalDeviceFragmentShaderBarycentricFeaturesNV :: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR +QueryPoolCreateInfoINTEL :: QueryPoolPerformanceQueryCreateInfoINTEL +PhysicalDeviceScalarBlockLayoutFeaturesEXT :: PhysicalDeviceScalarBlockLayoutFeatures +PhysicalDeviceSubgroupSizeControlFeaturesEXT :: PhysicalDeviceSubgroupSizeControlFeatures +PhysicalDeviceSubgroupSizeControlPropertiesEXT :: PhysicalDeviceSubgroupSizeControlProperties +PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT :: PipelineShaderStageRequiredSubgroupSizeCreateInfo +PhysicalDeviceBufferAddressFeaturesEXT :: PhysicalDeviceBufferDeviceAddressFeaturesEXT +BufferDeviceAddressInfoEXT :: BufferDeviceAddressInfo +ToolPurposeFlagEXT :: ToolPurposeFlag +ToolPurposeFlagsEXT :: ToolPurposeFlags +PhysicalDeviceToolPropertiesEXT :: PhysicalDeviceToolProperties +ImageStencilUsageCreateInfoEXT :: ImageStencilUsageCreateInfo +PhysicalDeviceHostQueryResetFeaturesEXT :: PhysicalDeviceHostQueryResetFeatures +PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT :: PhysicalDeviceShaderDemoteToHelperInvocationFeatures +PhysicalDeviceTexelBufferAlignmentPropertiesEXT :: PhysicalDeviceTexelBufferAlignmentProperties +PrivateDataSlotEXT :: PrivateDataSlot +PrivateDataSlotCreateFlagsEXT :: PrivateDataSlotCreateFlags +PhysicalDevicePrivateDataFeaturesEXT :: PhysicalDevicePrivateDataFeatures +DevicePrivateDataCreateInfoEXT :: DevicePrivateDataCreateInfo +PrivateDataSlotCreateInfoEXT :: PrivateDataSlotCreateInfo +PhysicalDevicePipelineCreationCacheControlFeaturesEXT :: PhysicalDevicePipelineCreationCacheControlFeatures +PhysicalDeviceImageRobustnessFeaturesEXT :: PhysicalDeviceImageRobustnessFeatures +PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM :: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT +PhysicalDeviceMutableDescriptorTypeFeaturesVALVE :: PhysicalDeviceMutableDescriptorTypeFeaturesEXT +MutableDescriptorTypeListVALVE :: MutableDescriptorTypeListEXT +MutableDescriptorTypeCreateInfoVALVE :: MutableDescriptorTypeCreateInfoEXT +PipelineInfoEXT :: PipelineInfoKHR +PhysicalDeviceGlobalPriorityQueryFeaturesEXT :: PhysicalDeviceGlobalPriorityQueryFeaturesKHR +QueueFamilyGlobalPriorityPropertiesEXT :: QueueFamilyGlobalPriorityPropertiesKHR +MemoryDecompressionMethodFlagNV :: Flags64 +MemoryDecompressionMethodFlagsNV :: Flags64 +ShaderRequiredSubgroupSizeCreateInfoEXT :: PipelineShaderStageRequiredSubgroupSizeCreateInfo From 72980549744e22e6b4ed8c1fbdd3ea273c0d22a2 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 11:19:13 +0100 Subject: [PATCH 041/108] Add require_results to make builtin procedures --- core/runtime/core_builtin.odin | 20 +++++++------- core/runtime/core_builtin_matrix.odin | 38 +++++++++++++-------------- core/runtime/core_builtin_soa.odin | 12 +++++---- 3 files changed, 37 insertions(+), 33 deletions(-) diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin index bd919247e..82b28ae6d 100644 --- a/core/runtime/core_builtin.odin +++ b/core/runtime/core_builtin.odin @@ -6,7 +6,7 @@ import "core:intrinsics" Maybe :: union($T: typeid) {T} -@builtin +@(builtin, require_results) container_of :: #force_inline proc "contextless" (ptr: $P/^$Field_Type, $T: typeid, $field_name: string) -> ^T where intrinsics.type_has_field(T, field_name), intrinsics.type_field_type(T, field_name) == Field_Type { @@ -179,17 +179,18 @@ delete :: proc{ // The new built-in procedure allocates memory. The first argument is a type, not a value, and the value // return is a pointer to a newly allocated value of that type using the specified allocator, default is context.allocator -@builtin +@(builtin, require_results) new :: proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> (^T, Allocator_Error) #optional_allocator_error { return new_aligned(T, align_of(T), allocator, loc) } +@(require_results) new_aligned :: proc($T: typeid, alignment: int, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) { data := mem_alloc_bytes(size_of(T), alignment, allocator, loc) or_return t = (^T)(raw_data(data)) return } -@builtin +@(builtin, require_results) new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) #optional_allocator_error { t_data := mem_alloc_bytes(size_of(T), align_of(T), allocator, loc) or_return t = (^T)(raw_data(t_data)) @@ -201,6 +202,7 @@ new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_locat DEFAULT_RESERVE_CAPACITY :: 16 +@(require_results) make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { make_slice_error_loc(loc, len) data, err := mem_alloc_bytes(size_of(E)*len, alignment, allocator, loc) @@ -211,19 +213,19 @@ make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocat return transmute(T)s, err } -@(builtin) +@(builtin, require_results) make_slice :: proc($T: typeid/[]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_aligned(T, len, align_of(E), allocator, loc) } -@(builtin) +@(builtin, require_results) make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_dynamic_array_len_cap(T, 0, DEFAULT_RESERVE_CAPACITY, allocator, loc) } -@(builtin) +@(builtin, require_results) make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_dynamic_array_len_cap(T, len, len, allocator, loc) } -@(builtin) +@(builtin, require_results) make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { make_dynamic_array_error_loc(loc, len, cap) data := mem_alloc_bytes(size_of(E)*cap, align_of(E), allocator, loc) or_return @@ -234,7 +236,7 @@ make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #a array = transmute(T)s return } -@(builtin) +@(builtin, require_results) make_map :: proc($T: typeid/map[$K]$E, #any_int capacity: int = 1< (m: T, err: Allocator_Error) #optional_allocator_error { make_map_expr_error_loc(loc, capacity) context.allocator = allocator @@ -242,7 +244,7 @@ make_map :: proc($T: typeid/map[$K]$E, #any_int capacity: int = 1< (mp: T, err: Allocator_Error) #optional_allocator_error { make_slice_error_loc(loc, len) data := mem_alloc_bytes(size_of(E)*len, align_of(E), allocator, loc) or_return diff --git a/core/runtime/core_builtin_matrix.odin b/core/runtime/core_builtin_matrix.odin index 53589587c..7d60d625c 100644 --- a/core/runtime/core_builtin_matrix.odin +++ b/core/runtime/core_builtin_matrix.odin @@ -37,12 +37,12 @@ inverse :: proc{ matrix4x4_inverse, } -@(builtin) +@(builtin, require_results) hermitian_adjoint :: proc "contextless" (m: $M/matrix[$N, N]$T) -> M where intrinsics.type_is_complex(T), N >= 1 { return conj(transpose(m)) } -@(builtin) +@(builtin, require_results) matrix_trace :: proc "contextless" (m: $M/matrix[$N, N]$T) -> (trace: T) { for i in 0.. (trace: T) { return } -@(builtin) +@(builtin, require_results) matrix_minor :: proc "contextless" (m: $M/matrix[$N, N]$T, row, column: int) -> (minor: T) where N > 1 { K :: N-1 cut_down: matrix[K, K]T @@ -66,23 +66,23 @@ matrix_minor :: proc "contextless" (m: $M/matrix[$N, N]$T, row, column: int) -> -@(builtin) +@(builtin, require_results) matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) { return m[0, 0] } -@(builtin) +@(builtin, require_results) matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } -@(builtin) +@(builtin, require_results) matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } -@(builtin) +@(builtin, require_results) matrix4x4_determinant :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { a := adjugate(m) #no_bounds_check for i in 0..<4 { @@ -94,13 +94,13 @@ matrix4x4_determinant :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { -@(builtin) +@(builtin, require_results) matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { y = x return } -@(builtin) +@(builtin, require_results) matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { y[0, 0] = +x[1, 1] y[0, 1] = -x[1, 0] @@ -109,7 +109,7 @@ matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { return } -@(builtin) +@(builtin, require_results) matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { y[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) y[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -124,7 +124,7 @@ matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { } -@(builtin) +@(builtin, require_results) matrix4x4_adjugate :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { for i in 0..<4 { for j in 0..<4 { @@ -135,13 +135,13 @@ matrix4x4_adjugate :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { return } -@(builtin) +@(builtin, require_results) matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { y[0, 0] = 1/x[0, 0] return } -@(builtin) +@(builtin, require_results) matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] when intrinsics.type_is_integer(T) { @@ -159,7 +159,7 @@ matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: return } -@(builtin) +@(builtin, require_results) matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { a := adjugate(x) d := determinant(x) @@ -180,7 +180,7 @@ matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: return } -@(builtin) +@(builtin, require_results) matrix4x4_inverse_transpose :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { a := adjugate(x) d: T @@ -204,13 +204,13 @@ matrix4x4_inverse_transpose :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: return } -@(builtin) +@(builtin, require_results) matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { y[0, 0] = 1/x[0, 0] return } -@(builtin) +@(builtin, require_results) matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] when intrinsics.type_is_integer(T) { @@ -228,7 +228,7 @@ matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { return } -@(builtin) +@(builtin, require_results) matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { a := adjugate(x) d := determinant(x) @@ -249,7 +249,7 @@ matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bou return } -@(builtin) +@(builtin, require_results) matrix4x4_inverse :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { a := adjugate(x) d: T diff --git a/core/runtime/core_builtin_soa.odin b/core/runtime/core_builtin_soa.odin index 2b7fd3681..10f9846a2 100644 --- a/core/runtime/core_builtin_soa.odin +++ b/core/runtime/core_builtin_soa.odin @@ -50,6 +50,7 @@ Raw_SOA_Footer_Dynamic_Array :: struct { allocator: Allocator, } +@(builtin, require_results) raw_soa_footer_slice :: proc(array: ^$T/#soa[]$E) -> (footer: ^Raw_SOA_Footer_Slice) { if array == nil { return nil @@ -58,6 +59,7 @@ raw_soa_footer_slice :: proc(array: ^$T/#soa[]$E) -> (footer: ^Raw_SOA_Footer_Sl footer = (^Raw_SOA_Footer_Slice)(uintptr(array) + field_count*size_of(rawptr)) return } +@(builtin, require_results) raw_soa_footer_dynamic_array :: proc(array: ^$T/#soa[dynamic]$E) -> (footer: ^Raw_SOA_Footer_Dynamic_Array) { if array == nil { return nil @@ -78,7 +80,7 @@ raw_soa_footer :: proc{ -@builtin +@(builtin, require_results) make_soa_aligned :: proc($T: typeid/#soa[]$E, length: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { if length <= 0 { return @@ -137,26 +139,26 @@ make_soa_aligned :: proc($T: typeid/#soa[]$E, length: int, alignment: int, alloc return } -@builtin +@(builtin, require_results) make_soa_slice :: proc($T: typeid/#soa[]$E, length: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { return make_soa_aligned(T, length, align_of(E), allocator, loc) } -@builtin +@(builtin, require_results) make_soa_dynamic_array :: proc($T: typeid/#soa[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (array: T) { context.allocator = allocator reserve_soa(&array, DEFAULT_RESERVE_CAPACITY, loc) return } -@builtin +@(builtin, require_results) make_soa_dynamic_array_len :: proc($T: typeid/#soa[dynamic]$E, #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T) { context.allocator = allocator resize_soa(&array, length, loc) return } -@builtin +@(builtin, require_results) make_soa_dynamic_array_len_cap :: proc($T: typeid/#soa[dynamic]$E, #any_int length, capacity: int, allocator := context.allocator, loc := #caller_location) -> (array: T) { context.allocator = allocator if reserve_soa(&array, capacity, loc) { From 600c97cc0f2a9c4c5e1ccf098c95f892c35ff78a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 11:26:22 +0100 Subject: [PATCH 042/108] Add missing `Allocator_Error` and `@(require_results)` to many procedures --- core/mem/alloc.odin | 66 +++++++++++++++--------------- core/mem/allocators.odin | 15 +++++-- core/mem/mem.odin | 28 +++++++++++++ core/odin/ast/clone.odin | 6 ++- core/slice/slice.odin | 86 +++++++++++++++++++++++++++++++--------- core/slice/sort.odin | 9 ++++- 6 files changed, 153 insertions(+), 57 deletions(-) diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index c7a21dcd4..93d120c67 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -60,15 +60,18 @@ DEFAULT_PAGE_SIZE :: 16 * 1024 when ODIN_OS == .Darwin && ODIN_ARCH == .arm64 else 4 * 1024 -alloc :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> rawptr { - data, _ := runtime.mem_alloc(size, alignment, allocator, loc) - return raw_data(data) +@(require_results) +alloc :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := runtime.mem_alloc(size, alignment, allocator, loc) + return raw_data(data), err } +@(require_results) alloc_bytes :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { return runtime.mem_alloc(size, alignment, allocator, loc) } +@(require_results) alloc_bytes_non_zeroed :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { return runtime.mem_alloc_non_zeroed(size, alignment, allocator, loc) } @@ -93,15 +96,18 @@ free_all :: proc(allocator := context.allocator, loc := #caller_location) -> All return runtime.mem_free_all(allocator, loc) } -resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> rawptr { - data, _ := runtime.mem_resize(ptr, old_size, new_size, alignment, allocator, loc) - return raw_data(data) +@(require_results) +resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> (rawptr, Allocator_Error) { + data, err := runtime.mem_resize(ptr, old_size, new_size, alignment, allocator, loc) + return raw_data(data), err } +@(require_results) resize_bytes :: proc(old_data: []byte, new_size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { return runtime.mem_resize(raw_data(old_data), len(old_data), new_size, alignment, allocator, loc) } +@(require_results) query_features :: proc(allocator: Allocator, loc := #caller_location) -> (set: Allocator_Mode_Set) { if allocator.procedure != nil { allocator.procedure(allocator.data, .Query_Features, 0, 0, &set, 0, loc) @@ -110,6 +116,7 @@ query_features :: proc(allocator: Allocator, loc := #caller_location) -> (set: A return nil } +@(require_results) query_info :: proc(pointer: rawptr, allocator: Allocator, loc := #caller_location) -> (props: Allocator_Query_Info) { props.pointer = pointer if allocator.procedure != nil { @@ -146,14 +153,17 @@ delete :: proc{ } +@(require_results) new :: proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> (^T, Allocator_Error) { return new_aligned(T, align_of(T), allocator, loc) } +@(require_results) new_aligned :: proc($T: typeid, alignment: int, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) { data := alloc_bytes(size_of(T), alignment, allocator, loc) or_return t = (^T)(raw_data(data)) return } +@(require_results) new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_location) -> (t: ^T, err: Allocator_Error) { backing := alloc_bytes(size_of(T), align_of(T), allocator, loc) or_return t = (^T)(raw_data(backing)) @@ -164,6 +174,7 @@ new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_locat return nil, .Out_Of_Memory } +@(require_results) make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (slice: T, err: Allocator_Error) { runtime.make_slice_error_loc(loc, len) data := alloc_bytes(size_of(E)*len, alignment, allocator, loc) or_return @@ -173,15 +184,19 @@ make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocat slice = transmute(T)Raw_Slice{raw_data(data), len} return } +@(require_results) make_slice :: proc($T: typeid/[]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { return make_aligned(T, len, align_of(E), allocator, loc) } +@(require_results) make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { return make_dynamic_array_len_cap(T, 0, 16, allocator, loc) } +@(require_results) make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) { return make_dynamic_array_len_cap(T, len, len, allocator, loc) } +@(require_results) make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) { runtime.make_dynamic_array_error_loc(loc, len, cap) data := alloc_bytes(size_of(E)*cap, align_of(E), allocator, loc) or_return @@ -192,14 +207,15 @@ make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #a array = transmute(T)s return } -make_map :: proc($T: typeid/map[$K]$E, #any_int cap: int = 1< T { +@(require_results) +make_map :: proc($T: typeid/map[$K]$E, #any_int cap: int = 1< (m: T, err: Allocator_Error) { runtime.make_map_expr_error_loc(loc, cap) context.allocator = allocator - m: T - reserve_map(&m, cap, loc) - return m + err = reserve_map(&m, cap, loc) + return } +@(require_results) make_multi_pointer :: proc($T: typeid/[^]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (mp: T, err: Allocator_Error) { runtime.make_slice_error_loc(loc, len) data := alloc_bytes(size_of(E)*len, align_of(E), allocator, loc) or_return @@ -220,30 +236,14 @@ make :: proc{ } - -default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> rawptr { - if old_memory == nil { - return alloc(new_size, alignment, allocator, loc) - } - - if new_size == 0 { - free(old_memory, allocator, loc) - return nil - } - - if new_size == old_size { - return old_memory - } - - new_memory := alloc(new_size, alignment, allocator, loc) - if new_memory == nil { - return nil - } - - copy(new_memory, old_memory, min(old_size, new_size)) - free(old_memory, allocator, loc) - return new_memory +@(require_results) +default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> (res: rawptr, err: Allocator_Error) { + data: []byte + data, err = default_resize_bytes_align(([^]byte)(old_memory)[:old_size], new_size, alignment, allocator, loc) + res = raw_data(data) + return } +@(require_results) default_resize_bytes_align :: proc(old_data: []byte, new_size, alignment: int, allocator := context.allocator, loc := #caller_location) -> ([]byte, Allocator_Error) { old_memory := raw_data(old_data) old_size := len(old_data) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 66da12959..8c19f1788 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -46,6 +46,7 @@ init_arena :: proc(a: ^Arena, data: []byte) { a.temp_count = 0 } +@(require_results) arena_allocator :: proc(arena: ^Arena) -> Allocator { return Allocator{ procedure = arena_allocator_proc, @@ -100,6 +101,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } +@(require_results) begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory { tmp: Arena_Temp_Memory tmp.arena = a @@ -286,6 +288,7 @@ scratch_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } +@(require_results) scratch_allocator :: proc(allocator: ^Scratch_Allocator) -> Allocator { return Allocator{ procedure = scratch_allocator_proc, @@ -325,6 +328,7 @@ init_stack :: proc(s: ^Stack, data: []byte) { s.peak_used = 0 } +@(require_results) stack_allocator :: proc(stack: ^Stack) -> Allocator { return Allocator{ procedure = stack_allocator_proc, @@ -490,6 +494,7 @@ init_small_stack :: proc(s: ^Small_Stack, data: []byte) { s.peak_used = 0 } +@(require_results) small_stack_allocator :: proc(stack: ^Small_Stack) -> Allocator { return Allocator{ procedure = small_stack_allocator_proc, @@ -673,6 +678,7 @@ dynamic_pool_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode } +@(require_results) dynamic_pool_allocator :: proc(pool: ^Dynamic_Pool) -> Allocator { return Allocator{ procedure = dynamic_pool_allocator_proc, @@ -705,12 +711,13 @@ dynamic_pool_destroy :: proc(using pool: ^Dynamic_Pool) { } -dynamic_pool_alloc :: proc(pool: ^Dynamic_Pool, bytes: int) -> rawptr { +@(require_results) +dynamic_pool_alloc :: proc(pool: ^Dynamic_Pool, bytes: int) -> (rawptr, Allocator_Error) { data, err := dynamic_pool_alloc_bytes(pool, bytes) - assert(err == nil) - return raw_data(data) + return raw_data(data), err } +@(require_results) dynamic_pool_alloc_bytes :: proc(using pool: ^Dynamic_Pool, bytes: int) -> ([]byte, Allocator_Error) { cycle_new_block :: proc(using pool: ^Dynamic_Pool) -> (err: Allocator_Error) { if block_allocator.procedure == nil { @@ -836,6 +843,7 @@ panic_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil, nil } +@(require_results) panic_allocator :: proc() -> Allocator { return Allocator{ procedure = panic_allocator_proc, @@ -885,6 +893,7 @@ tracking_allocator_clear :: proc(t: ^Tracking_Allocator) { } +@(require_results) tracking_allocator :: proc(data: ^Tracking_Allocator) -> Allocator { return Allocator{ data = data, diff --git a/core/mem/mem.odin b/core/mem/mem.odin index bc77ca287..a06579d71 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -53,14 +53,17 @@ compare :: proc "contextless" (a, b: []byte) -> int { return res } +@(require_results) compare_byte_ptrs :: proc "contextless" (a, b: ^byte, n: int) -> int #no_bounds_check { return runtime.memory_compare(a, b, n) } +@(require_results) check_zero :: proc(data: []byte) -> bool { return check_zero_ptr(raw_data(data), len(data)) } +@(require_results) check_zero_ptr :: proc(ptr: rawptr, len: int) -> bool { switch { case len <= 0: @@ -101,11 +104,13 @@ check_zero_ptr :: proc(ptr: rawptr, len: int) -> bool { return true } +@(require_results) simple_equal :: proc "contextless" (a, b: $T) -> bool where intrinsics.type_is_simple_compare(T) { a, b := a, b return compare_byte_ptrs((^byte)(&a), (^byte)(&b), size_of(T)) == 0 } +@(require_results) compare_ptrs :: proc "contextless" (a, b: rawptr, n: int) -> int { return compare_byte_ptrs((^byte)(a), (^byte)(b), n) } @@ -113,20 +118,24 @@ compare_ptrs :: proc "contextless" (a, b: rawptr, n: int) -> int { ptr_offset :: intrinsics.ptr_offset ptr_sub :: intrinsics.ptr_sub +@(require_results) slice_ptr :: proc "contextless" (ptr: ^$T, len: int) -> []T { return ([^]T)(ptr)[:len] } +@(require_results) byte_slice :: #force_inline proc "contextless" (data: rawptr, #any_int len: int) -> []byte { return ([^]u8)(data)[:max(len, 0)] } +@(require_results) slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []byte { s := transmute(Raw_Slice)slice s.len *= size_of(T) return transmute([]byte)s } +@(require_results) slice_data_cast :: proc "contextless" ($T: typeid/[]$A, slice: $S/[]$B) -> T { when size_of(A) == 0 || size_of(B) == 0 { return nil @@ -137,11 +146,13 @@ slice_data_cast :: proc "contextless" ($T: typeid/[]$A, slice: $S/[]$B) -> T { } } +@(require_results) slice_to_components :: proc "contextless" (slice: $E/[]$T) -> (data: ^T, len: int) { s := transmute(Raw_Slice)slice return (^T)(s.data), s.len } +@(require_results) buffer_from_slice :: proc "contextless" (backing: $T/[]$E) -> [dynamic]E { return transmute([dynamic]E)Raw_Dynamic_Array{ data = raw_data(backing), @@ -154,10 +165,12 @@ buffer_from_slice :: proc "contextless" (backing: $T/[]$E) -> [dynamic]E { } } +@(require_results) ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []byte { return transmute([]byte)Raw_Slice{ptr, len*size_of(T)} } +@(require_results) any_to_bytes :: proc "contextless" (val: any) -> []byte { ti := type_info_of(val.id) size := ti != nil ? ti.size : 0 @@ -165,6 +178,7 @@ any_to_bytes :: proc "contextless" (val: any) -> []byte { } +@(require_results) is_power_of_two :: proc "contextless" (x: uintptr) -> bool { if x <= 0 { return false @@ -172,10 +186,12 @@ is_power_of_two :: proc "contextless" (x: uintptr) -> bool { return (x & (x-1)) == 0 } +@(require_results) align_forward :: proc(ptr: rawptr, align: uintptr) -> rawptr { return rawptr(align_forward_uintptr(uintptr(ptr), align)) } +@(require_results) align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { assert(is_power_of_two(align)) @@ -187,33 +203,41 @@ align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr { return p } +@(require_results) align_forward_int :: proc(ptr, align: int) -> int { return int(align_forward_uintptr(uintptr(ptr), uintptr(align))) } +@(require_results) align_forward_uint :: proc(ptr, align: uint) -> uint { return uint(align_forward_uintptr(uintptr(ptr), uintptr(align))) } +@(require_results) align_backward :: proc(ptr: rawptr, align: uintptr) -> rawptr { return rawptr(align_backward_uintptr(uintptr(ptr), align)) } +@(require_results) align_backward_uintptr :: proc(ptr, align: uintptr) -> uintptr { return align_forward_uintptr(ptr - align + 1, align) } +@(require_results) align_backward_int :: proc(ptr, align: int) -> int { return int(align_backward_uintptr(uintptr(ptr), uintptr(align))) } +@(require_results) align_backward_uint :: proc(ptr, align: uint) -> uint { return uint(align_backward_uintptr(uintptr(ptr), uintptr(align))) } +@(require_results) context_from_allocator :: proc(a: Allocator) -> type_of(context) { context.allocator = a return context } +@(require_results) reinterpret_copy :: proc "contextless" ($T: typeid, ptr: rawptr) -> (value: T) { copy(&value, ptr, size_of(T)) return @@ -222,6 +246,7 @@ reinterpret_copy :: proc "contextless" ($T: typeid, ptr: rawptr) -> (value: T) { Fixed_Byte_Buffer :: distinct [dynamic]byte +@(require_results) make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buffer { s := transmute(Raw_Slice)backing d: Raw_Dynamic_Array @@ -237,11 +262,13 @@ make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buf +@(require_results) align_formula :: proc "contextless" (size, align: int) -> int { result := size + align-1 return result - result%align } +@(require_results) calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, header_size: int) -> int { p, a := ptr, align modulo := p & (a-1) @@ -267,6 +294,7 @@ calc_padding_with_header :: proc "contextless" (ptr: uintptr, align: uintptr, he +@(require_results, deprecated="prefer 'slice.clone'") clone_slice :: proc(slice: $T/[]$E, allocator := context.allocator, loc := #caller_location) -> (new_slice: T) { new_slice, _ = make(T, len(slice), allocator, loc) runtime.copy(new_slice, slice) diff --git a/core/odin/ast/clone.odin b/core/odin/ast/clone.odin index 5ec6bc335..b8c0b8087 100644 --- a/core/odin/ast/clone.odin +++ b/core/odin/ast/clone.odin @@ -82,7 +82,11 @@ clone_node :: proc(node: ^Node) -> ^Node { panic("Cannot clone this node type") } - res := cast(^Node)mem.alloc(size, align) + res := cast(^Node)(mem.alloc(size, align) or_else nil) + if res == nil { + // allocation failure + return nil + } src: rawptr = node if node.derived != nil { src = (^rawptr)(&node.derived)^ diff --git a/core/slice/slice.odin b/core/slice/slice.odin index 84da242e2..a8f70e333 100644 --- a/core/slice/slice.odin +++ b/core/slice/slice.odin @@ -13,6 +13,7 @@ _ :: mem /* Turn a pointer and a length into a slice. */ +@(require_results) from_ptr :: proc "contextless" (ptr: ^$T, count: int) -> []T { return ([^]T)(ptr)[:count] } @@ -20,6 +21,7 @@ from_ptr :: proc "contextless" (ptr: ^$T, count: int) -> []T { /* Turn a pointer and a length into a byte slice. */ +@(require_results) bytes_from_ptr :: proc "contextless" (ptr: rawptr, byte_count: int) -> []byte { return ([^]byte)(ptr)[:byte_count] } @@ -29,6 +31,7 @@ bytes_from_ptr :: proc "contextless" (ptr: rawptr, byte_count: int) -> []byte { See `slice.reinterpret` to go the other way. */ +@(require_results) to_bytes :: proc "contextless" (s: []$T) -> []byte { return ([^]byte)(raw_data(s))[:len(s) * size_of(T)] } @@ -51,10 +54,15 @@ to_bytes :: proc "contextless" (s: []$T) -> []byte { assert(len(large_items) == 1) // only enough bytes to make 1 x i64; two would need at least 8 bytes. ``` */ +@(require_results) reinterpret :: proc "contextless" ($T: typeid/[]$U, s: []$V) -> []U { - bytes := to_bytes(s) - n := len(bytes) / size_of(U) - return ([^]U)(raw_data(bytes))[:n] + when size_of(U) == 0 || size_of(B) == 0 { + return nil + } else { + bytes := to_bytes(s) + n := len(bytes) / size_of(U) + return ([^]U)(raw_data(bytes))[:n] + } } @@ -82,11 +90,13 @@ reverse :: proc(array: $T/[]$E) { } +@(require_results) contains :: proc(array: $T/[]$E, value: E) -> bool where intrinsics.type_is_comparable(E) { _, found := linear_search(array, value) return found } +@(require_results) linear_search :: proc(array: $A/[]$T, key: T) -> (index: int, found: bool) where intrinsics.type_is_comparable(T) #no_bounds_check { for x, i in array { @@ -97,6 +107,7 @@ linear_search :: proc(array: $A/[]$T, key: T) -> (index: int, found: bool) return -1, false } +@(require_results) linear_search_proc :: proc(array: $A/[]$T, f: proc(T) -> bool) -> (index: int, found: bool) #no_bounds_check { for x, i in array { if f(x) { @@ -106,6 +117,7 @@ linear_search_proc :: proc(array: $A/[]$T, f: proc(T) -> bool) -> (index: int, f return -1, false } +@(require_results) binary_search :: proc(array: $A/[]$T, key: T) -> (index: int, found: bool) where intrinsics.type_is_ordered(T) #no_bounds_check { @@ -146,6 +158,7 @@ binary_search :: proc(array: $A/[]$T, key: T) -> (index: int, found: bool) } +@(require_results) equal :: proc(a, b: $T/[]$E) -> bool where intrinsics.type_is_comparable(E) { if len(a) != len(b) { return false @@ -162,6 +175,7 @@ equal :: proc(a, b: $T/[]$E) -> bool where intrinsics.type_is_comparable(E) { } } +@(require_results) simple_equal :: proc(a, b: $T/[]$E) -> bool where intrinsics.type_is_simple_compare(E) { if len(a) != len(b) { return false @@ -176,6 +190,7 @@ simple_equal :: proc(a, b: $T/[]$E) -> bool where intrinsics.type_is_simple_comp slice.prefix_length([]u8{1, 2, 3, 4}, []u8{1, 2, 3}) -> 3 slice.prefix_length([]u8{1, 2, 3, 4}, []u8{2, 3, 4}) -> 0 */ +@(require_results) prefix_length :: proc(a, b: $T/[]$E) -> (n: int) where intrinsics.type_is_comparable(E) { _len := builtin.min(len(a), len(b)) @@ -185,6 +200,7 @@ prefix_length :: proc(a, b: $T/[]$E) -> (n: int) where intrinsics.type_is_compar return } +@(require_results) has_prefix :: proc(array: $T/[]$E, needle: E) -> bool where intrinsics.type_is_comparable(E) { n := len(needle) if len(array) >= n { @@ -194,6 +210,7 @@ has_prefix :: proc(array: $T/[]$E, needle: E) -> bool where intrinsics.type_is_c } +@(require_results) has_suffix :: proc(array: $T/[]$E, needle: E) -> bool where intrinsics.type_is_comparable(E) { array := array m, n := len(array), len(needle) @@ -232,7 +249,8 @@ swap_with_slice :: proc(a, b: $T/[]$E, loc := #caller_location) { ptr_swap_non_overlapping(raw_data(a), raw_data(b), len(a)*size_of(E)) } -concatenate :: proc(a: []$T/[]$E, allocator := context.allocator) -> (res: T) { +@(require_results) +concatenate :: proc(a: []$T/[]$E, allocator := context.allocator) -> (res: T, err: mem.Allocator_Error) #optional_allocator_error { if len(a) == 0 { return } @@ -240,7 +258,7 @@ concatenate :: proc(a: []$T/[]$E, allocator := context.allocator) -> (res: T) { for s in a { n += len(s) } - res = make(T, n, allocator) + res = make(T, n, allocator) or_return i := 0 for s in a { i += copy(res[i:], s) @@ -249,22 +267,24 @@ concatenate :: proc(a: []$T/[]$E, allocator := context.allocator) -> (res: T) { } // copies a slice into a new slice -clone :: proc(a: $T/[]$E, allocator := context.allocator) -> []E { - d := make([]E, len(a), allocator) +@(require_results) +clone :: proc(a: $T/[]$E, allocator := context.allocator) -> ([]E, mem.Allocator_Error) #optional_allocator_error { + d, err := make([]E, len(a), allocator) copy(d[:], a) - return d + return d, err } // copies slice into a new dynamic array -clone_to_dynamic :: proc(a: $T/[]$E, allocator := context.allocator) -> [dynamic]E { - d := make([dynamic]E, len(a), allocator) +clone_to_dynamic :: proc(a: $T/[]$E, allocator := context.allocator) -> ([dynamic]E, mem.Allocator_Error) #optional_allocator_error { + d, err := make([dynamic]E, len(a), allocator) copy(d[:], a) - return d + return d, err } to_dynamic :: clone_to_dynamic // Converts slice into a dynamic array without cloning or allocating memory +@(require_results) into_dynamic :: proc(a: $T/[]$E) -> [dynamic]E { s := transmute(mem.Raw_Slice)a d := mem.Raw_Dynamic_Array{ @@ -277,43 +297,51 @@ into_dynamic :: proc(a: $T/[]$E) -> [dynamic]E { } +@(require_results) length :: proc(a: $T/[]$E) -> int { return len(a) } +@(require_results) is_empty :: proc(a: $T/[]$E) -> bool { return len(a) == 0 } - +@(require_results) split_at :: proc(array: $T/[]$E, index: int) -> (a, b: T) { return array[:index], array[index:] } +@(require_results) split_first :: proc(array: $T/[]$E) -> (first: E, rest: T) { return array[0], array[1:] } +@(require_results) split_last :: proc(array: $T/[]$E) -> (rest: T, last: E) { n := len(array)-1 return array[:n], array[n] } +@(require_results) first :: proc(array: $T/[]$E) -> E { return array[0] } +@(require_results) last :: proc(array: $T/[]$E) -> E { return array[len(array)-1] } +@(require_results) first_ptr :: proc(array: $T/[]$E) -> ^E { if len(array) != 0 { return &array[0] } return nil } +@(require_results) last_ptr :: proc(array: $T/[]$E) -> ^E { if len(array) != 0 { return &array[len(array)-1] @@ -321,6 +349,7 @@ last_ptr :: proc(array: $T/[]$E) -> ^E { return nil } +@(require_results) get :: proc(array: $T/[]$E, index: int) -> (value: E, ok: bool) { if uint(index) < len(array) { value = array[index] @@ -328,6 +357,7 @@ get :: proc(array: $T/[]$E, index: int) -> (value: E, ok: bool) { } return } +@(require_results) get_ptr :: proc(array: $T/[]$E, index: int) -> (value: ^E, ok: bool) { if uint(index) < len(array) { value = &array[index] @@ -336,19 +366,22 @@ get_ptr :: proc(array: $T/[]$E, index: int) -> (value: ^E, ok: bool) { return } +@(require_results) as_ptr :: proc(array: $T/[]$E) -> [^]E { return raw_data(array) } -mapper :: proc(s: $S/[]$U, f: proc(U) -> $V, allocator := context.allocator) -> []V { - r := make([]V, len(s), allocator) +@(require_results) +mapper :: proc(s: $S/[]$U, f: proc(U) -> $V, allocator := context.allocator) -> (r: []V, err: mem.Allocator_Error) #optional_allocator_error { + r = make([]V, len(s), allocator) or_return for v, i in s { r[i] = f(v) } - return r + return } +@(require_results) reduce :: proc(s: $S/[]$U, initializer: $V, f: proc(V, U) -> V) -> V { r := initializer for v in s { @@ -357,6 +390,7 @@ reduce :: proc(s: $S/[]$U, initializer: $V, f: proc(V, U) -> V) -> V { return r } +@(require_results) filter :: proc(s: $S/[]$U, f: proc(U) -> bool, allocator := context.allocator) -> S { r := make([dynamic]U, 0, 0, allocator) for v in s { @@ -367,10 +401,11 @@ filter :: proc(s: $S/[]$U, f: proc(U) -> bool, allocator := context.allocator) - return r[:] } -scanner :: proc (s: $S/[]$U, initializer: $V, f: proc(V, U) -> V, allocator := context.allocator) -> []V { - if len(s) == 0 { return {} } +@(require_results) +scanner :: proc (s: $S/[]$U, initializer: $V, f: proc(V, U) -> V, allocator := context.allocator) -> (res: []V, err: mem.Allocator_Error) #optional_allocator_error { + if len(s) == 0 { return } - res := make([]V, len(s), allocator) + res = make([]V, len(s), allocator) or_return p := as_ptr(s) q := as_ptr(res) r := initializer @@ -382,10 +417,11 @@ scanner :: proc (s: $S/[]$U, initializer: $V, f: proc(V, U) -> V, allocator := c q = q[1:] } - return res + return } +@(require_results) min :: proc(s: $S/[]$T) -> (res: T, ok: bool) where intrinsics.type_is_ordered(T) #optional_ok { if len(s) != 0 { res = s[0] @@ -396,6 +432,7 @@ min :: proc(s: $S/[]$T) -> (res: T, ok: bool) where intrinsics.type_is_ordered(T } return } +@(require_results) max :: proc(s: $S/[]$T) -> (res: T, ok: bool) where intrinsics.type_is_ordered(T) #optional_ok { if len(s) != 0 { res = s[0] @@ -407,6 +444,7 @@ max :: proc(s: $S/[]$T) -> (res: T, ok: bool) where intrinsics.type_is_ordered(T return } +@(require_results) min_max :: proc(s: $S/[]$T) -> (min, max: T, ok: bool) where intrinsics.type_is_ordered(T) { if len(s) != 0 { min, max = s[0], s[0] @@ -419,6 +457,7 @@ min_max :: proc(s: $S/[]$T) -> (min, max: T, ok: bool) where intrinsics.type_is_ return } +@(require_results) any_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparable(T) { for v in s { if v == value { @@ -428,6 +467,7 @@ any_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparable return false } +@(require_results) none_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparable(T) { for v in s { if v == value { @@ -437,6 +477,7 @@ none_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparabl return true } +@(require_results) all_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparable(T) { if len(s) == 0 { return false @@ -450,6 +491,7 @@ all_of :: proc(s: $S/[]$T, value: T) -> bool where intrinsics.type_is_comparable } +@(require_results) any_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { for v in s { if f(v) { @@ -459,6 +501,7 @@ any_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { return false } +@(require_results) none_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { for v in s { if f(v) { @@ -468,6 +511,7 @@ none_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { return true } +@(require_results) all_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { if len(s) == 0 { return false @@ -481,6 +525,7 @@ all_of_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> bool { } +@(require_results) count :: proc(s: $S/[]$T, value: T) -> (n: int) where intrinsics.type_is_comparable(T) { for v in s { if v == value { @@ -490,6 +535,7 @@ count :: proc(s: $S/[]$T, value: T) -> (n: int) where intrinsics.type_is_compara return } +@(require_results) count_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> (n: int) { for v in s { if f(v) { @@ -500,6 +546,7 @@ count_proc :: proc(s: $S/[]$T, f: proc(T) -> bool) -> (n: int) { } +@(require_results) dot_product :: proc(a, b: $S/[]$T) -> (r: T, ok: bool) where intrinsics.type_is_numeric(T) { if len(a) != len(b) { @@ -513,6 +560,7 @@ dot_product :: proc(a, b: $S/[]$T) -> (r: T, ok: bool) // Convert a pointer to an enumerated array to a slice of the element type +@(require_results) enumerated_array :: proc(ptr: ^$T) -> []intrinsics.type_elem_type(T) where intrinsics.type_is_enumerated_array(T) { return ([^]intrinsics.type_elem_type(T))(ptr)[:len(T)] diff --git a/core/slice/sort.odin b/core/slice/sort.odin index b146e03c3..515eddcc3 100644 --- a/core/slice/sort.odin +++ b/core/slice/sort.odin @@ -6,6 +6,7 @@ Ordering :: enum { Greater = +1, } +@(require_results) cmp :: proc(a, b: $E) -> Ordering where ORD(E) { switch { case a < b: @@ -16,6 +17,7 @@ cmp :: proc(a, b: $E) -> Ordering where ORD(E) { return .Equal } +@(require_results) cmp_proc :: proc($E: typeid) -> (proc(E, E) -> Ordering) where ORD(E) { return proc(a, b: E) -> Ordering { switch { @@ -144,6 +146,7 @@ stable_sort_by_cmp :: proc(data: $T/[]$E, cmp: proc(i, j: E) -> Ordering) { } } +@(require_results) is_sorted :: proc(array: $T/[]$E) -> bool where ORD(E) { for i := len(array)-1; i > 0; i -= 1 { if array[i] < array[i-1] { @@ -153,6 +156,7 @@ is_sorted :: proc(array: $T/[]$E) -> bool where ORD(E) { return true } +@(require_results) is_sorted_by :: proc(array: $T/[]$E, less: proc(i, j: E) -> bool) -> bool { for i := len(array)-1; i > 0; i -= 1 { if less(array[i], array[i-1]) { @@ -163,6 +167,8 @@ is_sorted_by :: proc(array: $T/[]$E, less: proc(i, j: E) -> bool) -> bool { } is_sorted_by_cmp :: is_sorted_cmp + +@(require_results) is_sorted_cmp :: proc(array: $T/[]$E, cmp: proc(i, j: E) -> Ordering) -> bool { for i := len(array)-1; i > 0; i -= 1 { if cmp(array[i], array[i-1]) == .Less { @@ -215,6 +221,7 @@ reverse_sort_by_key :: proc(data: $T/[]$E, key: proc(E) -> $K) where ORD(K) { }) } +@(require_results) is_sorted_by_key :: proc(array: $T/[]$E, key: proc(E) -> $K) -> bool where ORD(K) { for i := len(array)-1; i > 0; i -= 1 { if key(array[i]) < key(array[i-1]) { @@ -224,7 +231,7 @@ is_sorted_by_key :: proc(array: $T/[]$E, key: proc(E) -> $K) -> bool where ORD(K return true } -@(private) +@(private, require_results) _max_depth :: proc(n: int) -> (depth: int) { // 2*ceil(log2(n+1)) for i := n; i > 0; i >>= 1 { depth += 1 From 1e17f44991e6a9d068acf37f3516e08d32e3b04d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 11:47:36 +0100 Subject: [PATCH 043/108] Improve error handling for `resize` and `reserve` procedures --- core/compress/shoco/shoco.odin | 12 +-- core/image/common.odin | 10 +-- core/image/png/png.odin | 10 +-- core/image/qoi/qoi.odin | 4 +- core/image/tga/tga.odin | 4 +- core/runtime/core_builtin.odin | 137 +++++++++++++++++---------------- 6 files changed, 87 insertions(+), 90 deletions(-) diff --git a/core/compress/shoco/shoco.odin b/core/compress/shoco/shoco.odin index f94ce70b7..04b0bfdc2 100644 --- a/core/compress/shoco/shoco.odin +++ b/core/compress/shoco/shoco.odin @@ -177,12 +177,10 @@ decompress_slice_to_string :: proc(input: []u8, model := DEFAULT_MODEL, allocato max_output_size := decompress_bound(len(input), model) buf: [dynamic]u8 - if !resize(&buf, max_output_size) { - return "", .Out_Of_Memory - } + resize(&buf, max_output_size) or_return length, result := decompress_slice_to_output_buffer(input, buf[:]) - resize(&buf, length) + resize(&buf, length) or_return return string(buf[:]), result } decompress :: proc{decompress_slice_to_output_buffer, decompress_slice_to_string} @@ -307,12 +305,10 @@ compress_string :: proc(input: string, model := DEFAULT_MODEL, allocator := cont max_output_size := compress_bound(len(input)) buf: [dynamic]u8 - if !resize(&buf, max_output_size) { - return {}, .Out_Of_Memory - } + resize(&buf, max_output_size) or_return length, result := compress_string_to_buffer(input, buf[:]) - resize(&buf, length) + resize(&buf, length) or_return return buf[:length], result } compress :: proc{compress_string_to_buffer, compress_string} \ No newline at end of file diff --git a/core/image/common.odin b/core/image/common.odin index 58ff83dd1..ad01f7e6b 100644 --- a/core/image/common.odin +++ b/core/image/common.odin @@ -634,7 +634,7 @@ alpha_add_if_missing :: proc(img: ^Image, alpha_key := Alpha_Key{}, allocator := buf := bytes.Buffer{} // Can we allocate the return buffer? - if !resize(&buf.buf, bytes_wanted) { + if resize(&buf.buf, bytes_wanted) != nil { delete(buf.buf) return false } @@ -826,7 +826,7 @@ alpha_drop_if_present :: proc(img: ^Image, options := Options{}, alpha_key := Al buf := bytes.Buffer{} // Can we allocate the return buffer? - if !resize(&buf.buf, bytes_wanted) { + if resize(&buf.buf, bytes_wanted) != nil { delete(buf.buf) return false } @@ -1075,7 +1075,7 @@ apply_palette_rgb :: proc(img: ^Image, palette: [256]RGB_Pixel, allocator := con // Can we allocate the return buffer? buf := bytes.Buffer{} bytes_wanted := compute_buffer_size(img.width, img.height, 3, 8) - if !resize(&buf.buf, bytes_wanted) { + if resize(&buf.buf, bytes_wanted) != nil { delete(buf.buf) return false } @@ -1112,7 +1112,7 @@ apply_palette_rgba :: proc(img: ^Image, palette: [256]RGBA_Pixel, allocator := c // Can we allocate the return buffer? buf := bytes.Buffer{} bytes_wanted := compute_buffer_size(img.width, img.height, 4, 8) - if !resize(&buf.buf, bytes_wanted) { + if resize(&buf.buf, bytes_wanted) != nil { delete(buf.buf) return false } @@ -1147,7 +1147,7 @@ expand_grayscale :: proc(img: ^Image, allocator := context.allocator) -> (ok: bo // Can we allocate the return buffer? buf := bytes.Buffer{} bytes_wanted := compute_buffer_size(img.width, img.height, img.channels + 2, img.depth) - if !resize(&buf.buf, bytes_wanted) { + if resize(&buf.buf, bytes_wanted) != nil { delete(buf.buf) return false } diff --git a/core/image/png/png.odin b/core/image/png/png.odin index 91adddafc..caa1e6e8a 100644 --- a/core/image/png/png.odin +++ b/core/image/png/png.odin @@ -731,7 +731,7 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a // We need to create a new image buffer dest_raw_size := compute_buffer_size(int(header.width), int(header.height), out_image_channels, 8) t := bytes.Buffer{} - if !resize(&t.buf, dest_raw_size) { + if resize(&t.buf, dest_raw_size) != nil { return {}, .Unable_To_Allocate_Or_Resize } @@ -812,7 +812,7 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a // We need to create a new image buffer dest_raw_size := compute_buffer_size(int(header.width), int(header.height), out_image_channels, 16) t := bytes.Buffer{} - if !resize(&t.buf, dest_raw_size) { + if resize(&t.buf, dest_raw_size) != nil { return {}, .Unable_To_Allocate_Or_Resize } @@ -1011,7 +1011,7 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a // We need to create a new image buffer dest_raw_size := compute_buffer_size(int(header.width), int(header.height), out_image_channels, 8) t := bytes.Buffer{} - if !resize(&t.buf, dest_raw_size) { + if resize(&t.buf, dest_raw_size) != nil { return {}, .Unable_To_Allocate_Or_Resize } @@ -1522,7 +1522,7 @@ defilter :: proc(img: ^Image, filter_bytes: ^bytes.Buffer, header: ^image.PNG_IH bytes_per_channel := depth == 16 ? 2 : 1 num_bytes := compute_buffer_size(width, height, channels, depth == 16 ? 16 : 8) - if !resize(&img.pixels.buf, num_bytes) { + if resize(&img.pixels.buf, num_bytes) != nil { return .Unable_To_Allocate_Or_Resize } @@ -1564,7 +1564,7 @@ defilter :: proc(img: ^Image, filter_bytes: ^bytes.Buffer, header: ^image.PNG_IH if x > 0 && y > 0 { temp: bytes.Buffer temp_len := compute_buffer_size(x, y, channels, depth == 16 ? 16 : 8) - if !resize(&temp.buf, temp_len) { + if resize(&temp.buf, temp_len) != nil { return .Unable_To_Allocate_Or_Resize } diff --git a/core/image/qoi/qoi.odin b/core/image/qoi/qoi.odin index 27903c00f..c764178dc 100644 --- a/core/image/qoi/qoi.odin +++ b/core/image/qoi/qoi.odin @@ -53,7 +53,7 @@ save_to_buffer :: proc(output: ^bytes.Buffer, img: ^Image, options := Options{} // Calculate and allocate maximum size. We'll reclaim space to actually written output at the end. max_size := pixels * (img.channels + 1) + size_of(image.QOI_Header) + size_of(u64be) - if !resize(&output.buf, max_size) { + if resize(&output.buf, max_size) != nil { return .Unable_To_Allocate_Or_Resize } @@ -233,7 +233,7 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a bytes_needed := image.compute_buffer_size(int(header.width), int(header.height), img.channels, 8) - if !resize(&img.pixels.buf, bytes_needed) { + if resize(&img.pixels.buf, bytes_needed) != nil { return img, .Unable_To_Allocate_Or_Resize } diff --git a/core/image/tga/tga.odin b/core/image/tga/tga.odin index 9fc616804..03ef1a386 100644 --- a/core/image/tga/tga.odin +++ b/core/image/tga/tga.odin @@ -57,7 +57,7 @@ save_to_buffer :: proc(output: ^bytes.Buffer, img: ^Image, options := Options{} // Calculate and allocate necessary space. necessary := pixels * img.channels + size_of(image.TGA_Header) - if !resize(&output.buf, necessary) { + if resize(&output.buf, necessary) != nil { return .Unable_To_Allocate_Or_Resize } @@ -292,7 +292,7 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a return img, nil } - if !resize(&img.pixels.buf, dest_channels * img.width * img.height) { + if resize(&img.pixels.buf, dest_channels * img.width * img.height) != nil { return img, .Unable_To_Allocate_Or_Resize } diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin index 82b28ae6d..f578a641e 100644 --- a/core/runtime/core_builtin.odin +++ b/core/runtime/core_builtin.odin @@ -289,10 +289,9 @@ reserve_map :: proc(m: ^$T/map[$K]$V, capacity: int, loc := #caller_location) -> Shrinks the capacity of a map down to the current length. */ @builtin -shrink_map :: proc(m: ^$T/map[$K]$V, loc := #caller_location) -> (did_shrink: bool) { +shrink_map :: proc(m: ^$T/map[$K]$V, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) { if m != nil { - err := map_shrink_dynamic((^Raw_Map)(m), map_info(T), loc) - did_shrink = err == nil + return map_shrink_dynamic((^Raw_Map)(m), map_info(T), loc) } return } @@ -315,18 +314,18 @@ delete_key :: proc(m: ^$T/map[$K]$V, key: K) -> (deleted_key: K, deleted_value: @builtin -append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> int { +append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { if array == nil { - return 0 + return 0, nil } when size_of(E) == 0 { array := (^Raw_Dynamic_Array)(array) array.len += 1 - return 1 + return 1, nil } else { if cap(array) < len(array)+1 { cap := 2 * cap(array) + max(8, 1) - _ = reserve(array, cap, loc) + err = reserve(array, cap, loc) // do not 'or_return' here as it could be a partial success } if cap(array)-len(array) > 0 { a := (^Raw_Dynamic_Array)(array) @@ -336,31 +335,31 @@ append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) -> data[a.len] = arg } a.len += 1 - return 1 + return 1, err } - return 0 + return 0, err } } @builtin -append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) -> int { +append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { if array == nil { - return 0 + return 0, nil } arg_len := len(args) if arg_len <= 0 { - return 0 + return 0, nil } when size_of(E) == 0 { array := (^Raw_Dynamic_Array)(array) array.len += arg_len - return arg_len + return arg_len, nil } else { if cap(array) < len(array)+arg_len { cap := 2 * cap(array) + max(8, arg_len) - _ = reserve(array, cap, loc) + err = reserve(array, cap, loc) // do not 'or_return' here as it could be a partial success } arg_len = min(cap(array)-len(array), arg_len) if arg_len > 0 { @@ -372,13 +371,13 @@ append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) } a.len += arg_len } - return arg_len + return arg_len, err } } // The append_string built-in procedure appends a string to the end of a [dynamic]u8 like type @builtin -append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> int { +append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { args := transmute([]E)arg return append_elems(array=array, args=args, loc=loc) } @@ -386,9 +385,14 @@ append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #ca // The append_string built-in procedure appends multiple strings to the end of a [dynamic]u8 like type @builtin -append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_location) -> (n: int) { +append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { + n_arg: int for arg in args { - n += append(array = array, args = transmute([]E)(arg), loc = loc) + n_arg, err = append(array = array, args = transmute([]E)(arg), loc = loc) + n += n_arg + if err != nil { + return + } } return } @@ -398,18 +402,18 @@ append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_ @builtin -append_nothing :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> int { +append_nothing :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { if array == nil { - return 0 + return 0, nil } prev_len := len(array) - resize(array, len(array)+1, loc) - return len(array)-prev_len + resize(array, len(array)+1, loc) or_return + return len(array)-prev_len, nil } @builtin -inject_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #caller_location) -> (ok: bool) #no_bounds_check { +inject_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if array == nil { return } @@ -417,18 +421,17 @@ inject_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #calle m :: 1 new_size := n + m - if resize(array, new_size, loc) { - when size_of(E) != 0 { - copy(array[index + m:], array[index:]) - array[index] = arg - } - ok = true + resize(array, new_size, loc) or_return + when size_of(E) != 0 { + copy(array[index + m:], array[index:]) + array[index] = arg } + ok = true return } @builtin -inject_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #caller_location) -> (ok: bool) #no_bounds_check { +inject_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if array == nil { return } @@ -441,18 +444,17 @@ inject_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #c m := len(args) new_size := n + m - if resize(array, new_size, loc) { - when size_of(E) != 0 { - copy(array[index + m:], array[index:]) - copy(array[index:], args) - } - ok = true + resize(array, new_size, loc) or_return + when size_of(E) != 0 { + copy(array[index + m:], array[index:]) + copy(array[index:], args) } + ok = true return } @builtin -inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) #no_bounds_check { +inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if array == nil { return } @@ -465,11 +467,10 @@ inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string m := len(arg) new_size := n + m - if resize(array, new_size, loc) { - copy(array[index+m:], array[index:]) - copy(array[index:], arg) - ok = true - } + resize(array, new_size, loc) or_return + copy(array[index+m:], array[index:]) + copy(array[index:], arg) + ok = true return } @@ -478,11 +479,12 @@ inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string @builtin -assign_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #caller_location) -> (ok: bool) #no_bounds_check { +assign_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if index < len(array) { array[index] = arg ok = true - } else if resize(array, index+1, loc) { + } else { + resize(array, index+1, loc) or_return array[index] = arg ok = true } @@ -491,11 +493,12 @@ assign_at_elem :: proc(array: ^$T/[dynamic]$E, index: int, arg: E, loc := #calle @builtin -assign_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #caller_location) -> (ok: bool) #no_bounds_check { +assign_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if index+len(args) < len(array) { copy(array[index:], args) ok = true - } else if resize(array, index+1+len(args), loc) { + } else { + resize(array, index+1+len(args), loc) or_return copy(array[index:], args) ok = true } @@ -504,13 +507,14 @@ assign_at_elems :: proc(array: ^$T/[dynamic]$E, index: int, args: ..E, loc := #c @builtin -assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool) #no_bounds_check { +assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error { if len(args) == 0 { ok = true } else if index+len(args) < len(array) { copy(array[index:], args) ok = true - } else if resize(array, index+1+len(args), loc) { + } else { + resize(array, index+1+len(args), loc) or_return copy(array[index:], args) ok = true } @@ -530,14 +534,14 @@ clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) { } @builtin -reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> bool { +reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error { if array == nil { - return false + return nil } a := (^Raw_Dynamic_Array)(array) if capacity <= a.cap { - return true + return nil } if a.allocator.procedure == nil { @@ -549,26 +553,26 @@ reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #cal new_size := capacity * size_of(E) allocator := a.allocator - new_data, err := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) - if new_data == nil || err != nil { - return false + new_data := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return + if new_data == nil && new_size > 0 { + return .Out_Of_Memory } a.data = raw_data(new_data) a.cap = capacity - return true + return nil } @builtin -resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> bool { +resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error { if array == nil { - return false + return nil } a := (^Raw_Dynamic_Array)(array) if length <= a.cap { a.len = max(length, 0) - return true + return nil } if a.allocator.procedure == nil { @@ -580,15 +584,15 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller new_size := length * size_of(E) allocator := a.allocator - new_data, err := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) - if new_data == nil || err != nil { - return false + new_data := mem_resize(a.data, old_size, new_size, align_of(E), allocator, loc) or_return + if new_data == nil && new_size > 0 { + return .Out_Of_Memory } a.data = raw_data(new_data) a.len = length a.cap = length - return true + return nil } /* @@ -600,7 +604,7 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller If `len(array) < new_cap`, then `len(array)` will be left unchanged. */ -shrink_dynamic_array :: proc(array: ^$T/[dynamic]$E, new_cap := -1, loc := #caller_location) -> (did_shrink: bool) { +shrink_dynamic_array :: proc(array: ^$T/[dynamic]$E, new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) { if array == nil { return } @@ -620,15 +624,12 @@ shrink_dynamic_array :: proc(array: ^$T/[dynamic]$E, new_cap := -1, loc := #call old_size := a.cap * size_of(E) new_size := new_cap * size_of(E) - new_data, err := mem_resize(a.data, old_size, new_size, align_of(E), a.allocator, loc) - if err != nil { - return - } + new_data := mem_resize(a.data, old_size, new_size, align_of(E), a.allocator, loc) or_return a.data = raw_data(new_data) a.len = min(new_cap, a.len) a.cap = new_cap - return true + return true, nil } @builtin From 82023cd62989eeae2afdb94ac2c2c849049aef06 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 11:58:01 +0100 Subject: [PATCH 044/108] Add @(require_results) to `core:math` procedures --- core/math/math.odin | 640 +++++++++++++++++++++-------------- core/math/math_basic.odin | 50 +-- core/math/math_basic_js.odin | 53 +-- core/math/math_erf.odin | 26 +- core/math/math_gamma.odin | 19 +- core/math/math_lgamma.odin | 18 +- core/math/math_log1p.odin | 17 +- 7 files changed, 488 insertions(+), 335 deletions(-) diff --git a/core/math/math.odin b/core/math/math.odin index 12fe1bfd7..05177378f 100644 --- a/core/math/math.odin +++ b/core/math/math.odin @@ -42,90 +42,91 @@ min :: builtin.min max :: builtin.max clamp :: builtin.clamp -sqrt_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))) } -sqrt_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))) } -sqrt_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))) } -sqrt_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))) } -sqrt_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))) } -sqrt_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))) } -sqrt :: proc{ +@(require_results) sqrt_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(sqrt_f16(f16(x))) } +@(require_results) sqrt_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(sqrt_f16(f16(x))) } +@(require_results) sqrt_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(sqrt_f32(f32(x))) } +@(require_results) sqrt_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(sqrt_f32(f32(x))) } +@(require_results) sqrt_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(sqrt_f64(f64(x))) } +@(require_results) sqrt_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(sqrt_f64(f64(x))) } +sqrt :: proc{ sqrt_f16, sqrt_f16le, sqrt_f16be, sqrt_f32, sqrt_f32le, sqrt_f32be, sqrt_f64, sqrt_f64le, sqrt_f64be, } -sin_f16le :: proc "contextless" (θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))) } -sin_f16be :: proc "contextless" (θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))) } -sin_f32le :: proc "contextless" (θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))) } -sin_f32be :: proc "contextless" (θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))) } -sin_f64le :: proc "contextless" (θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))) } -sin_f64be :: proc "contextless" (θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))) } -sin :: proc{ +@(require_results) sin_f16le :: proc "contextless" (θ: f16le) -> f16le { return #force_inline f16le(sin_f16(f16(θ))) } +@(require_results) sin_f16be :: proc "contextless" (θ: f16be) -> f16be { return #force_inline f16be(sin_f16(f16(θ))) } +@(require_results) sin_f32le :: proc "contextless" (θ: f32le) -> f32le { return #force_inline f32le(sin_f32(f32(θ))) } +@(require_results) sin_f32be :: proc "contextless" (θ: f32be) -> f32be { return #force_inline f32be(sin_f32(f32(θ))) } +@(require_results) sin_f64le :: proc "contextless" (θ: f64le) -> f64le { return #force_inline f64le(sin_f64(f64(θ))) } +@(require_results) sin_f64be :: proc "contextless" (θ: f64be) -> f64be { return #force_inline f64be(sin_f64(f64(θ))) } +sin :: proc{ sin_f16, sin_f16le, sin_f16be, sin_f32, sin_f32le, sin_f32be, sin_f64, sin_f64le, sin_f64be, } -cos_f16le :: proc "contextless" (θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))) } -cos_f16be :: proc "contextless" (θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))) } -cos_f32le :: proc "contextless" (θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))) } -cos_f32be :: proc "contextless" (θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))) } -cos_f64le :: proc "contextless" (θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))) } -cos_f64be :: proc "contextless" (θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))) } -cos :: proc{ +@(require_results) cos_f16le :: proc "contextless" (θ: f16le) -> f16le { return #force_inline f16le(cos_f16(f16(θ))) } +@(require_results) cos_f16be :: proc "contextless" (θ: f16be) -> f16be { return #force_inline f16be(cos_f16(f16(θ))) } +@(require_results) cos_f32le :: proc "contextless" (θ: f32le) -> f32le { return #force_inline f32le(cos_f32(f32(θ))) } +@(require_results) cos_f32be :: proc "contextless" (θ: f32be) -> f32be { return #force_inline f32be(cos_f32(f32(θ))) } +@(require_results) cos_f64le :: proc "contextless" (θ: f64le) -> f64le { return #force_inline f64le(cos_f64(f64(θ))) } +@(require_results) cos_f64be :: proc "contextless" (θ: f64be) -> f64be { return #force_inline f64be(cos_f64(f64(θ))) } +cos :: proc{ cos_f16, cos_f16le, cos_f16be, cos_f32, cos_f32le, cos_f32be, cos_f64, cos_f64le, cos_f64be, } -pow_f16le :: proc "contextless" (x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))) } -pow_f16be :: proc "contextless" (x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))) } -pow_f32le :: proc "contextless" (x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))) } -pow_f32be :: proc "contextless" (x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))) } -pow_f64le :: proc "contextless" (x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))) } -pow_f64be :: proc "contextless" (x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))) } -pow :: proc{ +@(require_results) pow_f16le :: proc "contextless" (x, power: f16le) -> f16le { return #force_inline f16le(pow_f16(f16(x), f16(power))) } +@(require_results) pow_f16be :: proc "contextless" (x, power: f16be) -> f16be { return #force_inline f16be(pow_f16(f16(x), f16(power))) } +@(require_results) pow_f32le :: proc "contextless" (x, power: f32le) -> f32le { return #force_inline f32le(pow_f32(f32(x), f32(power))) } +@(require_results) pow_f32be :: proc "contextless" (x, power: f32be) -> f32be { return #force_inline f32be(pow_f32(f32(x), f32(power))) } +@(require_results) pow_f64le :: proc "contextless" (x, power: f64le) -> f64le { return #force_inline f64le(pow_f64(f64(x), f64(power))) } +@(require_results) pow_f64be :: proc "contextless" (x, power: f64be) -> f64be { return #force_inline f64be(pow_f64(f64(x), f64(power))) } +pow :: proc{ pow_f16, pow_f16le, pow_f16be, pow_f32, pow_f32le, pow_f32be, pow_f64, pow_f64le, pow_f64be, } -fmuladd_f16le :: proc "contextless" (a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))) } -fmuladd_f16be :: proc "contextless" (a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))) } -fmuladd_f32le :: proc "contextless" (a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))) } -fmuladd_f32be :: proc "contextless" (a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))) } -fmuladd_f64le :: proc "contextless" (a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))) } -fmuladd_f64be :: proc "contextless" (a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))) } -fmuladd :: proc{ +@(require_results) fmuladd_f16le :: proc "contextless" (a, b, c: f16le) -> f16le { return #force_inline f16le(fmuladd_f16(f16(a), f16(b), f16(c))) } +@(require_results) fmuladd_f16be :: proc "contextless" (a, b, c: f16be) -> f16be { return #force_inline f16be(fmuladd_f16(f16(a), f16(b), f16(c))) } +@(require_results) fmuladd_f32le :: proc "contextless" (a, b, c: f32le) -> f32le { return #force_inline f32le(fmuladd_f32(f32(a), f32(b), f32(c))) } +@(require_results) fmuladd_f32be :: proc "contextless" (a, b, c: f32be) -> f32be { return #force_inline f32be(fmuladd_f32(f32(a), f32(b), f32(c))) } +@(require_results) fmuladd_f64le :: proc "contextless" (a, b, c: f64le) -> f64le { return #force_inline f64le(fmuladd_f64(f64(a), f64(b), f64(c))) } +@(require_results) fmuladd_f64be :: proc "contextless" (a, b, c: f64be) -> f64be { return #force_inline f64be(fmuladd_f64(f64(a), f64(b), f64(c))) } +fmuladd :: proc{ fmuladd_f16, fmuladd_f16le, fmuladd_f16be, fmuladd_f32, fmuladd_f32le, fmuladd_f32be, fmuladd_f64, fmuladd_f64le, fmuladd_f64be, } -exp_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))) } -exp_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))) } -exp_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))) } -exp_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))) } -exp_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))) } -exp_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))) } -exp :: proc{ +@(require_results) exp_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(exp_f16(f16(x))) } +@(require_results) exp_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(exp_f16(f16(x))) } +@(require_results) exp_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(exp_f32(f32(x))) } +@(require_results) exp_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(exp_f32(f32(x))) } +@(require_results) exp_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(exp_f64(f64(x))) } +@(require_results) exp_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(exp_f64(f64(x))) } +exp :: proc{ exp_f16, exp_f16le, exp_f16be, exp_f32, exp_f32le, exp_f32be, exp_f64, exp_f64le, exp_f64be, } -pow10_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(pow10_f16(f16(x))) } -pow10_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(pow10_f16(f16(x))) } -pow10_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(pow10_f32(f32(x))) } -pow10_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(pow10_f32(f32(x))) } -pow10_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(pow10_f64(f64(x))) } -pow10_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(pow10_f64(f64(x))) } -pow10 :: proc{ +@(require_results) pow10_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(pow10_f16(f16(x))) } +@(require_results) pow10_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(pow10_f16(f16(x))) } +@(require_results) pow10_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(pow10_f32(f32(x))) } +@(require_results) pow10_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(pow10_f32(f32(x))) } +@(require_results) pow10_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(pow10_f64(f64(x))) } +@(require_results) pow10_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(pow10_f64(f64(x))) } +pow10 :: proc{ pow10_f16, pow10_f16le, pow10_f16be, pow10_f32, pow10_f32le, pow10_f32be, pow10_f64, pow10_f64le, pow10_f64be, } +@(require_results) pow10_f16 :: proc "contextless" (n: f16) -> f16 { @static pow10_pos_tab := [?]f16{ 1e00, 1e01, 1e02, 1e03, 1e04, @@ -146,6 +147,7 @@ pow10_f16 :: proc "contextless" (n: f16) -> f16 { return 0 } +@(require_results) pow10_f32 :: proc "contextless" (n: f32) -> f32 { @static pow10_pos_tab := [?]f32{ 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, @@ -173,6 +175,7 @@ pow10_f32 :: proc "contextless" (n: f32) -> f32 { return 0 } +@(require_results) pow10_f64 :: proc "contextless" (n: f64) -> f64 { @static pow10_tab := [?]f64{ 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, @@ -202,6 +205,7 @@ pow10_f64 :: proc "contextless" (n: f64) -> f64 { +@(require_results) ldexp_f64 :: proc "contextless" (val: f64, exp: int) -> f64 { mask :: F64_MASK shift :: F64_SHIFT @@ -236,14 +240,14 @@ ldexp_f64 :: proc "contextless" (val: f64, exp: int) -> f64 { x |= u64(exp+bias) << shift return m * transmute(f64)x } -ldexp_f16 :: proc "contextless" (val: f16, exp: int) -> f16 { return f16(ldexp_f64(f64(val), exp)) } -ldexp_f32 :: proc "contextless" (val: f32, exp: int) -> f32 { return f32(ldexp_f64(f64(val), exp)) } -ldexp_f16le :: proc "contextless" (val: f16le, exp: int) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) } -ldexp_f16be :: proc "contextless" (val: f16be, exp: int) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) } -ldexp_f32le :: proc "contextless" (val: f32le, exp: int) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) } -ldexp_f32be :: proc "contextless" (val: f32be, exp: int) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) } -ldexp_f64le :: proc "contextless" (val: f64le, exp: int) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) } -ldexp_f64be :: proc "contextless" (val: f64be, exp: int) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) } +@(require_results) ldexp_f16 :: proc "contextless" (val: f16, exp: int) -> f16 { return f16(ldexp_f64(f64(val), exp)) } +@(require_results) ldexp_f32 :: proc "contextless" (val: f32, exp: int) -> f32 { return f32(ldexp_f64(f64(val), exp)) } +@(require_results) ldexp_f16le :: proc "contextless" (val: f16le, exp: int) -> f16le { return #force_inline f16le(ldexp_f16(f16(val), exp)) } +@(require_results) ldexp_f16be :: proc "contextless" (val: f16be, exp: int) -> f16be { return #force_inline f16be(ldexp_f16(f16(val), exp)) } +@(require_results) ldexp_f32le :: proc "contextless" (val: f32le, exp: int) -> f32le { return #force_inline f32le(ldexp_f32(f32(val), exp)) } +@(require_results) ldexp_f32be :: proc "contextless" (val: f32be, exp: int) -> f32be { return #force_inline f32be(ldexp_f32(f32(val), exp)) } +@(require_results) ldexp_f64le :: proc "contextless" (val: f64le, exp: int) -> f64le { return #force_inline f64le(ldexp_f64(f64(val), exp)) } +@(require_results) ldexp_f64be :: proc "contextless" (val: f64be, exp: int) -> f64be { return #force_inline f64be(ldexp_f64(f64(val), exp)) } // ldexp is the inverse of frexp // it returns val * 2**exp. // @@ -260,82 +264,84 @@ ldexp :: proc{ } -log_f16 :: proc "contextless" (x, base: f16) -> f16 { return ln(x) / ln(base) } -log_f16le :: proc "contextless" (x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))) } -log_f16be :: proc "contextless" (x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))) } +@(require_results) log_f16 :: proc "contextless" (x, base: f16) -> f16 { return ln(x) / ln(base) } +@(require_results) log_f16le :: proc "contextless" (x, base: f16le) -> f16le { return f16le(log_f16(f16(x), f16(base))) } +@(require_results) log_f16be :: proc "contextless" (x, base: f16be) -> f16be { return f16be(log_f16(f16(x), f16(base))) } -log_f32 :: proc "contextless" (x, base: f32) -> f32 { return ln(x) / ln(base) } -log_f32le :: proc "contextless" (x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))) } -log_f32be :: proc "contextless" (x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))) } +@(require_results) log_f32 :: proc "contextless" (x, base: f32) -> f32 { return ln(x) / ln(base) } +@(require_results) log_f32le :: proc "contextless" (x, base: f32le) -> f32le { return f32le(log_f32(f32(x), f32(base))) } +@(require_results) log_f32be :: proc "contextless" (x, base: f32be) -> f32be { return f32be(log_f32(f32(x), f32(base))) } -log_f64 :: proc "contextless" (x, base: f64) -> f64 { return ln(x) / ln(base) } -log_f64le :: proc "contextless" (x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))) } -log_f64be :: proc "contextless" (x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))) } -log :: proc{ +@(require_results) log_f64 :: proc "contextless" (x, base: f64) -> f64 { return ln(x) / ln(base) } +@(require_results) log_f64le :: proc "contextless" (x, base: f64le) -> f64le { return f64le(log_f64(f64(x), f64(base))) } +@(require_results) log_f64be :: proc "contextless" (x, base: f64be) -> f64be { return f64be(log_f64(f64(x), f64(base))) } +log :: proc{ log_f16, log_f16le, log_f16be, log_f32, log_f32le, log_f32be, log_f64, log_f64le, log_f64be, } -log2_f16 :: proc "contextless" (x: f16) -> f16 { return log(f16(x), f16(2.0)) } -log2_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log_f16(f16(x), f16(2.0))) } -log2_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log_f16(f16(x), f16(2.0))) } +@(require_results) log2_f16 :: proc "contextless" (x: f16) -> f16 { return log(f16(x), f16(2.0)) } +@(require_results) log2_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log_f16(f16(x), f16(2.0))) } +@(require_results) log2_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log_f16(f16(x), f16(2.0))) } -log2_f32 :: proc "contextless" (x: f32) -> f32 { return log(f32(x), f32(2.0)) } -log2_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log_f32(f32(x), f32(2.0))) } -log2_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log_f32(f32(x), f32(2.0))) } +@(require_results) log2_f32 :: proc "contextless" (x: f32) -> f32 { return log(f32(x), f32(2.0)) } +@(require_results) log2_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log_f32(f32(x), f32(2.0))) } +@(require_results) log2_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log_f32(f32(x), f32(2.0))) } -log2_f64 :: proc "contextless" (x: f64) -> f64 { return log(f64(x), f64(2.0)) } -log2_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log_f64(f64(x), f64(2.0))) } -log2_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log_f64(f64(x), f64(2.0))) } +@(require_results) log2_f64 :: proc "contextless" (x: f64) -> f64 { return log(f64(x), f64(2.0)) } +@(require_results) log2_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log_f64(f64(x), f64(2.0))) } +@(require_results) log2_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log_f64(f64(x), f64(2.0))) } -log2 :: proc{ +log2 :: proc{ log2_f16, log2_f16le, log2_f16be, log2_f32, log2_f32le, log2_f32be, log2_f64, log2_f64le, log2_f64be, } -log10_f16 :: proc "contextless" (x: f16) -> f16 { return ln(x)/LN10 } -log10_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log10_f16(f16(x))) } -log10_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log10_f16(f16(x))) } +@(require_results) log10_f16 :: proc "contextless" (x: f16) -> f16 { return ln(x)/LN10 } +@(require_results) log10_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log10_f16(f16(x))) } +@(require_results) log10_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log10_f16(f16(x))) } -log10_f32 :: proc "contextless" (x: f32) -> f32 { return ln(x)/LN10 } -log10_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log10_f32(f32(x))) } -log10_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log10_f32(f32(x))) } +@(require_results) log10_f32 :: proc "contextless" (x: f32) -> f32 { return ln(x)/LN10 } +@(require_results) log10_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log10_f32(f32(x))) } +@(require_results) log10_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log10_f32(f32(x))) } -log10_f64 :: proc "contextless" (x: f64) -> f64 { return ln(x)/LN10 } -log10_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log10_f64(f64(x))) } -log10_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log10_f64(f64(x))) } -log10 :: proc{ +@(require_results) log10_f64 :: proc "contextless" (x: f64) -> f64 { return ln(x)/LN10 } +@(require_results) log10_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log10_f64(f64(x))) } +@(require_results) log10_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log10_f64(f64(x))) } +log10 :: proc{ log10_f16, log10_f16le, log10_f16be, log10_f32, log10_f32le, log10_f32be, log10_f64, log10_f64le, log10_f64be, } -tan_f16 :: proc "contextless" (θ: f16) -> f16 { return sin(θ)/cos(θ) } -tan_f16le :: proc "contextless" (θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))) } -tan_f16be :: proc "contextless" (θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))) } +@(require_results) tan_f16 :: proc "contextless" (θ: f16) -> f16 { return sin(θ)/cos(θ) } +@(require_results) tan_f16le :: proc "contextless" (θ: f16le) -> f16le { return f16le(tan_f16(f16(θ))) } +@(require_results) tan_f16be :: proc "contextless" (θ: f16be) -> f16be { return f16be(tan_f16(f16(θ))) } -tan_f32 :: proc "contextless" (θ: f32) -> f32 { return sin(θ)/cos(θ) } -tan_f32le :: proc "contextless" (θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))) } -tan_f32be :: proc "contextless" (θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))) } +@(require_results) tan_f32 :: proc "contextless" (θ: f32) -> f32 { return sin(θ)/cos(θ) } +@(require_results) tan_f32le :: proc "contextless" (θ: f32le) -> f32le { return f32le(tan_f32(f32(θ))) } +@(require_results) tan_f32be :: proc "contextless" (θ: f32be) -> f32be { return f32be(tan_f32(f32(θ))) } -tan_f64 :: proc "contextless" (θ: f64) -> f64 { return sin(θ)/cos(θ) } -tan_f64le :: proc "contextless" (θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))) } -tan_f64be :: proc "contextless" (θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))) } -tan :: proc{ +@(require_results) tan_f64 :: proc "contextless" (θ: f64) -> f64 { return sin(θ)/cos(θ) } +@(require_results) tan_f64le :: proc "contextless" (θ: f64le) -> f64le { return f64le(tan_f64(f64(θ))) } +@(require_results) tan_f64be :: proc "contextless" (θ: f64be) -> f64be { return f64be(tan_f64(f64(θ))) } +tan :: proc{ tan_f16, tan_f16le, tan_f16be, tan_f32, tan_f32le, tan_f32be, tan_f64, tan_f64le, tan_f64be, } -lerp :: proc "contextless" (a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t } -saturate :: proc "contextless" (a: $T) -> (x: T) { return clamp(a, 0, 1) } +@(require_results) lerp :: proc "contextless" (a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t } +@(require_results) saturate :: proc "contextless" (a: $T) -> (x: T) { return clamp(a, 0, 1) } -unlerp :: proc "contextless" (a, b, x: $T) -> (t: T) where intrinsics.type_is_float(T), !intrinsics.type_is_array(T) { +@(require_results) +unlerp :: proc "contextless" (a, b, x: $T) -> (t: T) where intrinsics.type_is_float(T), !intrinsics.type_is_array(T) { return (x-a)/(b-a) } +@(require_results) remap :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T) -> (x: T) where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { old_range := old_max - old_min new_range := new_max - new_min @@ -345,32 +351,39 @@ remap :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T) return ((old_value - old_min) / old_range) * new_range + new_min } +@(require_results) wrap :: proc "contextless" (x, y: $T) -> T where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { tmp := mod(x, y) return y + tmp if tmp < 0 else tmp } +@(require_results) angle_diff :: proc "contextless" (a, b: $T) -> T where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { dist := wrap(b - a, TAU) return wrap(dist*2, TAU) - dist } +@(require_results) angle_lerp :: proc "contextless" (a, b, t: $T) -> T where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { return a + angle_diff(a, b) * t } +@(require_results) step :: proc "contextless" (edge, x: $T) -> T where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { return 0 if x < edge else 1 } +@(require_results) smoothstep :: proc "contextless" (edge0, edge1, x: $T) -> T where intrinsics.type_is_numeric(T), !intrinsics.type_is_array(T) { t := clamp((x - edge0) / (edge1 - edge0), 0, 1) return t * t * (3 - 2*t) } +@(require_results) bias :: proc "contextless" (t, b: $T) -> T where intrinsics.type_is_numeric(T) { return t / (((1/b) - 2) * (1 - t) + 1) } +@(require_results) gain :: proc "contextless" (t, g: $T) -> T where intrinsics.type_is_numeric(T) { if t < 0.5 { return bias(t*2, g)*0.5 @@ -379,51 +392,47 @@ gain :: proc "contextless" (t, g: $T) -> T where intrinsics.type_is_numeric(T) { } -sign_f16 :: proc "contextless" (x: f16) -> f16 { return f16(int(0 < x) - int(x < 0)) } -sign_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)) } -sign_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)) } -sign_f32 :: proc "contextless" (x: f32) -> f32 { return f32(int(0 < x) - int(x < 0)) } -sign_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)) } -sign_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)) } -sign_f64 :: proc "contextless" (x: f64) -> f64 { return f64(int(0 < x) - int(x < 0)) } -sign_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)) } -sign_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)) } -sign :: proc{ +@(require_results) sign_f16 :: proc "contextless" (x: f16) -> f16 { return f16(int(0 < x) - int(x < 0)) } +@(require_results) sign_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(int(0 < x) - int(x < 0)) } +@(require_results) sign_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(int(0 < x) - int(x < 0)) } +@(require_results) sign_f32 :: proc "contextless" (x: f32) -> f32 { return f32(int(0 < x) - int(x < 0)) } +@(require_results) sign_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(int(0 < x) - int(x < 0)) } +@(require_results) sign_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(int(0 < x) - int(x < 0)) } +@(require_results) sign_f64 :: proc "contextless" (x: f64) -> f64 { return f64(int(0 < x) - int(x < 0)) } +@(require_results) sign_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(int(0 < x) - int(x < 0)) } +@(require_results) sign_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(int(0 < x) - int(x < 0)) } +sign :: proc{ sign_f16, sign_f16le, sign_f16be, sign_f32, sign_f32le, sign_f32be, sign_f64, sign_f64le, sign_f64be, } -sign_bit_f16 :: proc "contextless" (x: f16) -> bool { - return (transmute(u16)x) & (1<<15) != 0 -} -sign_bit_f16le :: proc "contextless" (x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)) } -sign_bit_f16be :: proc "contextless" (x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)) } -sign_bit_f32 :: proc "contextless" (x: f32) -> bool { - return (transmute(u32)x) & (1<<31) != 0 -} -sign_bit_f32le :: proc "contextless" (x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)) } -sign_bit_f32be :: proc "contextless" (x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)) } -sign_bit_f64 :: proc "contextless" (x: f64) -> bool { - return (transmute(u64)x) & (1<<63) != 0 -} -sign_bit_f64le :: proc "contextless" (x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)) } -sign_bit_f64be :: proc "contextless" (x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)) } -sign_bit :: proc{ +@(require_results) sign_bit_f16 :: proc "contextless" (x: f16) -> bool { return (transmute(u16)x) & (1<<15) != 0 } +@(require_results) sign_bit_f16le :: proc "contextless" (x: f16le) -> bool { return #force_inline sign_bit_f16(f16(x)) } +@(require_results) sign_bit_f16be :: proc "contextless" (x: f16be) -> bool { return #force_inline sign_bit_f16(f16(x)) } +@(require_results) sign_bit_f32 :: proc "contextless" (x: f32) -> bool { return (transmute(u32)x) & (1<<31) != 0 } +@(require_results) sign_bit_f32le :: proc "contextless" (x: f32le) -> bool { return #force_inline sign_bit_f32(f32(x)) } +@(require_results) sign_bit_f32be :: proc "contextless" (x: f32be) -> bool { return #force_inline sign_bit_f32(f32(x)) } +@(require_results) sign_bit_f64 :: proc "contextless" (x: f64) -> bool { return (transmute(u64)x) & (1<<63) != 0 } +@(require_results) sign_bit_f64le :: proc "contextless" (x: f64le) -> bool { return #force_inline sign_bit_f64(f64(x)) } +@(require_results) sign_bit_f64be :: proc "contextless" (x: f64be) -> bool { return #force_inline sign_bit_f64(f64(x)) } +sign_bit :: proc{ sign_bit_f16, sign_bit_f16le, sign_bit_f16be, sign_bit_f32, sign_bit_f32le, sign_bit_f32be, sign_bit_f64, sign_bit_f64le, sign_bit_f64be, } -copy_sign_f16 :: proc "contextless" (x, y: f16) -> f16 { +@(require_results) +copy_sign_f16 :: proc "contextless" (x, y: f16) -> f16 { ix := transmute(u16)x iy := transmute(u16)y ix &= 0x7fff ix |= iy & 0x8000 return transmute(f16)ix } -copy_sign_f16le :: proc "contextless" (x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))) } -copy_sign_f16be :: proc "contextless" (x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))) } +@(require_results) copy_sign_f16le :: proc "contextless" (x, y: f16le) -> f16le { return #force_inline f16le(copy_sign_f16(f16(x), f16(y))) } +@(require_results) copy_sign_f16be :: proc "contextless" (x, y: f16be) -> f16be { return #force_inline f16be(copy_sign_f16(f16(x), f16(y))) } +@(require_results) copy_sign_f32 :: proc "contextless" (x, y: f32) -> f32 { ix := transmute(u32)x iy := transmute(u32)y @@ -431,53 +440,55 @@ copy_sign_f32 :: proc "contextless" (x, y: f32) -> f32 { ix |= iy & 0x8000_0000 return transmute(f32)ix } -copy_sign_f32le :: proc "contextless" (x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))) } -copy_sign_f32be :: proc "contextless" (x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))) } -copy_sign_f64 :: proc "contextless" (x, y: f64) -> f64 { +@(require_results) copy_sign_f32le :: proc "contextless" (x, y: f32le) -> f32le { return #force_inline f32le(copy_sign_f32(f32(x), f32(y))) } +@(require_results) copy_sign_f32be :: proc "contextless" (x, y: f32be) -> f32be { return #force_inline f32be(copy_sign_f32(f32(x), f32(y))) } +@(require_results) +copy_sign_f64 :: proc "contextless" (x, y: f64) -> f64 { ix := transmute(u64)x iy := transmute(u64)y ix &= 0x7fff_ffff_ffff_ffff ix |= iy & 0x8000_0000_0000_0000 return transmute(f64)ix } -copy_sign_f64le :: proc "contextless" (x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))) } -copy_sign_f64be :: proc "contextless" (x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))) } -copy_sign :: proc{ +@(require_results) copy_sign_f64le :: proc "contextless" (x, y: f64le) -> f64le { return #force_inline f64le(copy_sign_f64(f64(x), f64(y))) } +@(require_results) copy_sign_f64be :: proc "contextless" (x, y: f64be) -> f64be { return #force_inline f64be(copy_sign_f64(f64(x), f64(y))) } +copy_sign :: proc{ copy_sign_f16, copy_sign_f16le, copy_sign_f16be, copy_sign_f32, copy_sign_f32le, copy_sign_f32be, copy_sign_f64, copy_sign_f64le, copy_sign_f64be, } -to_radians_f16 :: proc "contextless" (degrees: f16) -> f16 { return degrees * RAD_PER_DEG } -to_radians_f16le :: proc "contextless" (degrees: f16le) -> f16le { return degrees * RAD_PER_DEG } -to_radians_f16be :: proc "contextless" (degrees: f16be) -> f16be { return degrees * RAD_PER_DEG } -to_radians_f32 :: proc "contextless" (degrees: f32) -> f32 { return degrees * RAD_PER_DEG } -to_radians_f32le :: proc "contextless" (degrees: f32le) -> f32le { return degrees * RAD_PER_DEG } -to_radians_f32be :: proc "contextless" (degrees: f32be) -> f32be { return degrees * RAD_PER_DEG } -to_radians_f64 :: proc "contextless" (degrees: f64) -> f64 { return degrees * RAD_PER_DEG } -to_radians_f64le :: proc "contextless" (degrees: f64le) -> f64le { return degrees * RAD_PER_DEG } -to_radians_f64be :: proc "contextless" (degrees: f64be) -> f64be { return degrees * RAD_PER_DEG } -to_degrees_f16 :: proc "contextless" (radians: f16) -> f16 { return radians * DEG_PER_RAD } -to_degrees_f16le :: proc "contextless" (radians: f16le) -> f16le { return radians * DEG_PER_RAD } -to_degrees_f16be :: proc "contextless" (radians: f16be) -> f16be { return radians * DEG_PER_RAD } -to_degrees_f32 :: proc "contextless" (radians: f32) -> f32 { return radians * DEG_PER_RAD } -to_degrees_f32le :: proc "contextless" (radians: f32le) -> f32le { return radians * DEG_PER_RAD } -to_degrees_f32be :: proc "contextless" (radians: f32be) -> f32be { return radians * DEG_PER_RAD } -to_degrees_f64 :: proc "contextless" (radians: f64) -> f64 { return radians * DEG_PER_RAD } -to_degrees_f64le :: proc "contextless" (radians: f64le) -> f64le { return radians * DEG_PER_RAD } -to_degrees_f64be :: proc "contextless" (radians: f64be) -> f64be { return radians * DEG_PER_RAD } -to_radians :: proc{ +@(require_results) to_radians_f16 :: proc "contextless" (degrees: f16) -> f16 { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f16le :: proc "contextless" (degrees: f16le) -> f16le { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f16be :: proc "contextless" (degrees: f16be) -> f16be { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f32 :: proc "contextless" (degrees: f32) -> f32 { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f32le :: proc "contextless" (degrees: f32le) -> f32le { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f32be :: proc "contextless" (degrees: f32be) -> f32be { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f64 :: proc "contextless" (degrees: f64) -> f64 { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f64le :: proc "contextless" (degrees: f64le) -> f64le { return degrees * RAD_PER_DEG } +@(require_results) to_radians_f64be :: proc "contextless" (degrees: f64be) -> f64be { return degrees * RAD_PER_DEG } +@(require_results) to_degrees_f16 :: proc "contextless" (radians: f16) -> f16 { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f16le :: proc "contextless" (radians: f16le) -> f16le { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f16be :: proc "contextless" (radians: f16be) -> f16be { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f32 :: proc "contextless" (radians: f32) -> f32 { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f32le :: proc "contextless" (radians: f32le) -> f32le { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f32be :: proc "contextless" (radians: f32be) -> f32be { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f64 :: proc "contextless" (radians: f64) -> f64 { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f64le :: proc "contextless" (radians: f64le) -> f64le { return radians * DEG_PER_RAD } +@(require_results) to_degrees_f64be :: proc "contextless" (radians: f64be) -> f64be { return radians * DEG_PER_RAD } +to_radians :: proc{ to_radians_f16, to_radians_f16le, to_radians_f16be, to_radians_f32, to_radians_f32le, to_radians_f32be, to_radians_f64, to_radians_f64le, to_radians_f64be, } -to_degrees :: proc{ +to_degrees :: proc{ to_degrees_f16, to_degrees_f16le, to_degrees_f16be, to_degrees_f32, to_degrees_f32le, to_degrees_f32be, to_degrees_f64, to_degrees_f64le, to_degrees_f64be, } -trunc_f16 :: proc "contextless" (x: f16) -> f16 { +@(require_results) +trunc_f16 :: proc "contextless" (x: f16) -> f16 { trunc_internal :: proc "contextless" (f: f16) -> f16 { mask :: F16_MASK shift :: F16_SHIFT @@ -506,10 +517,11 @@ trunc_f16 :: proc "contextless" (x: f16) -> f16 { } return trunc_internal(x) } -trunc_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))) } -trunc_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))) } +@(require_results) trunc_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(trunc_f16(f16(x))) } +@(require_results) trunc_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(trunc_f16(f16(x))) } -trunc_f32 :: proc "contextless" (x: f32) -> f32 { +@(require_results) +trunc_f32 :: proc "contextless" (x: f32) -> f32 { trunc_internal :: proc "contextless" (f: f32) -> f32 { mask :: F32_MASK shift :: F32_SHIFT @@ -538,10 +550,11 @@ trunc_f32 :: proc "contextless" (x: f32) -> f32 { } return trunc_internal(x) } -trunc_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))) } -trunc_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))) } +@(require_results) trunc_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(trunc_f32(f32(x))) } +@(require_results) trunc_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(trunc_f32(f32(x))) } -trunc_f64 :: proc "contextless" (x: f64) -> f64 { +@(require_results) +trunc_f64 :: proc "contextless" (x: f64) -> f64 { trunc_internal :: proc "contextless" (f: f64) -> f64 { mask :: F64_MASK shift :: F64_SHIFT @@ -570,68 +583,78 @@ trunc_f64 :: proc "contextless" (x: f64) -> f64 { } return trunc_internal(x) } -trunc_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))) } -trunc_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))) } +@(require_results) trunc_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(trunc_f64(f64(x))) } +@(require_results) trunc_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(trunc_f64(f64(x))) } // Removes the fractional part of the value, i.e. rounds towards zero. -trunc :: proc{ +trunc :: proc{ trunc_f16, trunc_f16le, trunc_f16be, trunc_f32, trunc_f32le, trunc_f32be, trunc_f64, trunc_f64le, trunc_f64be, } +@(require_results) round_f16 :: proc "contextless" (x: f16) -> f16 { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f16le :: proc "contextless" (x: f16le) -> f16le { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f16be :: proc "contextless" (x: f16be) -> f16be { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f32 :: proc "contextless" (x: f32) -> f32 { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f32le :: proc "contextless" (x: f32le) -> f32le { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f32be :: proc "contextless" (x: f32be) -> f32be { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f64 :: proc "contextless" (x: f64) -> f64 { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f64le :: proc "contextless" (x: f64le) -> f64le { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } +@(require_results) round_f64be :: proc "contextless" (x: f64be) -> f64be { return ceil(x - 0.5) if x < 0 else floor(x + 0.5) } -round :: proc{ +round :: proc{ round_f16, round_f16le, round_f16be, round_f32, round_f32le, round_f32be, round_f64, round_f64le, round_f64be, } -ceil_f16 :: proc "contextless" (x: f16) -> f16 { return -floor(-x) } -ceil_f16le :: proc "contextless" (x: f16le) -> f16le { return -floor(-x) } -ceil_f16be :: proc "contextless" (x: f16be) -> f16be { return -floor(-x) } +@(require_results) ceil_f16 :: proc "contextless" (x: f16) -> f16 { return -floor(-x) } +@(require_results) ceil_f16le :: proc "contextless" (x: f16le) -> f16le { return -floor(-x) } +@(require_results) ceil_f16be :: proc "contextless" (x: f16be) -> f16be { return -floor(-x) } -ceil_f32 :: proc "contextless" (x: f32) -> f32 { return -floor(-x) } -ceil_f32le :: proc "contextless" (x: f32le) -> f32le { return -floor(-x) } -ceil_f32be :: proc "contextless" (x: f32be) -> f32be { return -floor(-x) } +@(require_results) ceil_f32 :: proc "contextless" (x: f32) -> f32 { return -floor(-x) } +@(require_results) ceil_f32le :: proc "contextless" (x: f32le) -> f32le { return -floor(-x) } +@(require_results) ceil_f32be :: proc "contextless" (x: f32be) -> f32be { return -floor(-x) } -ceil_f64 :: proc "contextless" (x: f64) -> f64 { return -floor(-x) } -ceil_f64le :: proc "contextless" (x: f64le) -> f64le { return -floor(-x) } -ceil_f64be :: proc "contextless" (x: f64be) -> f64be { return -floor(-x) } +@(require_results) ceil_f64 :: proc "contextless" (x: f64) -> f64 { return -floor(-x) } +@(require_results) ceil_f64le :: proc "contextless" (x: f64le) -> f64le { return -floor(-x) } +@(require_results) ceil_f64be :: proc "contextless" (x: f64be) -> f64be { return -floor(-x) } -ceil :: proc{ +ceil :: proc{ ceil_f16, ceil_f16le, ceil_f16be, ceil_f32, ceil_f32le, ceil_f32be, ceil_f64, ceil_f64le, ceil_f64be, } +@(require_results) floor_f16 :: proc "contextless" (x: f16) -> f16 { if x == 0 || is_nan(x) || is_inf(x) { return x @@ -646,9 +669,10 @@ floor_f16 :: proc "contextless" (x: f16) -> f16 { d, _ := modf(x) return d } -floor_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))) } -floor_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))) } -floor_f32 :: proc "contextless" (x: f32) -> f32 { +@(require_results) floor_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(floor_f16(f16(x))) } +@(require_results) floor_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(floor_f16(f16(x))) } +@(require_results) +floor_f32 :: proc "contextless" (x: f32) -> f32 { if x == 0 || is_nan(x) || is_inf(x) { return x } @@ -662,8 +686,9 @@ floor_f32 :: proc "contextless" (x: f32) -> f32 { d, _ := modf(x) return d } -floor_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))) } -floor_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))) } +@(require_results) floor_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(floor_f32(f32(x))) } +@(require_results) floor_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(floor_f32(f32(x))) } +@(require_results) floor_f64 :: proc "contextless" (x: f64) -> f64 { if x == 0 || is_nan(x) || is_inf(x) { return x @@ -678,15 +703,16 @@ floor_f64 :: proc "contextless" (x: f64) -> f64 { d, _ := modf(x) return d } -floor_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))) } -floor_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))) } -floor :: proc{ +@(require_results) floor_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(floor_f64(f64(x))) } +@(require_results) floor_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(floor_f64(f64(x))) } +floor :: proc{ floor_f16, floor_f16le, floor_f16be, floor_f32, floor_f32le, floor_f32be, floor_f64, floor_f64le, floor_f64be, } +@(require_results) floor_div :: proc "contextless" (x, y: $T) -> T where intrinsics.type_is_integer(T) { a := x / y @@ -697,6 +723,7 @@ floor_div :: proc "contextless" (x, y: $T) -> T return a } +@(require_results) floor_mod :: proc "contextless" (x, y: $T) -> T where intrinsics.type_is_integer(T) { r := x % y @@ -706,6 +733,7 @@ floor_mod :: proc "contextless" (x, y: $T) -> T return r } +@(require_results) divmod :: #force_inline proc "contextless" (x, y: $T) -> (div, mod: T) where intrinsics.type_is_integer(T) { div = x / y @@ -713,6 +741,7 @@ divmod :: #force_inline proc "contextless" (x, y: $T) -> (div, mod: T) return } +@(require_results) floor_divmod :: #force_inline proc "contextless" (x, y: $T) -> (div, mod: T) where intrinsics.type_is_integer(T) { div = x / y @@ -725,6 +754,7 @@ floor_divmod :: #force_inline proc "contextless" (x, y: $T) -> (div, mod: T) } +@(require_results) modf_f16 :: proc "contextless" (x: f16) -> (int: f16, frac: f16) { shift :: F16_SHIFT mask :: F16_MASK @@ -751,15 +781,18 @@ modf_f16 :: proc "contextless" (x: f16) -> (int: f16, frac: f16) { frac = x - int return } +@(require_results) modf_f16le :: proc "contextless" (x: f16le) -> (int: f16le, frac: f16le) { i, f := #force_inline modf_f16(f16(x)) return f16le(i), f16le(f) } +@(require_results) modf_f16be :: proc "contextless" (x: f16be) -> (int: f16be, frac: f16be) { i, f := #force_inline modf_f16(f16(x)) return f16be(i), f16be(f) } -modf_f32 :: proc "contextless" (x: f32) -> (int: f32, frac: f32) { +@(require_results) +modf_f32 :: proc "contextless" (x: f32) -> (int: f32, frac: f32) { shift :: F32_SHIFT mask :: F32_MASK bias :: F32_BIAS @@ -785,14 +818,17 @@ modf_f32 :: proc "contextless" (x: f32) -> (int: f32, frac: f32) { frac = x - int return } +@(require_results) modf_f32le :: proc "contextless" (x: f32le) -> (int: f32le, frac: f32le) { i, f := #force_inline modf_f32(f32(x)) return f32le(i), f32le(f) } +@(require_results) modf_f32be :: proc "contextless" (x: f32be) -> (int: f32be, frac: f32be) { i, f := #force_inline modf_f32(f32(x)) return f32be(i), f32be(f) } +@(require_results) modf_f64 :: proc "contextless" (x: f64) -> (int: f64, frac: f64) { shift :: F64_SHIFT mask :: F64_MASK @@ -819,10 +855,12 @@ modf_f64 :: proc "contextless" (x: f64) -> (int: f64, frac: f64) { frac = x - int return } +@(require_results) modf_f64le :: proc "contextless" (x: f64le) -> (int: f64le, frac: f64le) { i, f := #force_inline modf_f64(f64(x)) return f64le(i), f64le(f) } +@(require_results) modf_f64be :: proc "contextless" (x: f64be) -> (int: f64be, frac: f64be) { i, f := #force_inline modf_f64(f64(x)) return f64be(i), f64be(f) @@ -834,7 +872,8 @@ modf :: proc{ } split_decimal :: modf -mod_f16 :: proc "contextless" (x, y: f16) -> (n: f16) { +@(require_results) +mod_f16 :: proc "contextless" (x, y: f16) -> (n: f16) { z := abs(y) n = remainder(abs(x), z) if sign(n) < 0 { @@ -842,9 +881,10 @@ mod_f16 :: proc "contextless" (x, y: f16) -> (n: f16) { } return copy_sign(n, x) } -mod_f16le :: proc "contextless" (x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))) } -mod_f16be :: proc "contextless" (x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))) } -mod_f32 :: proc "contextless" (x, y: f32) -> (n: f32) { +@(require_results) mod_f16le :: proc "contextless" (x, y: f16le) -> (n: f16le) { return #force_inline f16le(mod_f16(f16(x), f16(y))) } +@(require_results) mod_f16be :: proc "contextless" (x, y: f16be) -> (n: f16be) { return #force_inline f16be(mod_f16(f16(x), f16(y))) } +@(require_results) +mod_f32 :: proc "contextless" (x, y: f32) -> (n: f32) { z := abs(y) n = remainder(abs(x), z) if sign(n) < 0 { @@ -852,9 +892,12 @@ mod_f32 :: proc "contextless" (x, y: f32) -> (n: f32) { } return copy_sign(n, x) } +@(require_results) mod_f32le :: proc "contextless" (x, y: f32le) -> (n: f32le) { return #force_inline f32le(mod_f32(f32(x), f32(y))) } +@(require_results) mod_f32be :: proc "contextless" (x, y: f32be) -> (n: f32be) { return #force_inline f32be(mod_f32(f32(x), f32(y))) } -mod_f64 :: proc "contextless" (x, y: f64) -> (n: f64) { +@(require_results) +mod_f64 :: proc "contextless" (x, y: f64) -> (n: f64) { z := abs(y) n = remainder(abs(x), z) if sign(n) < 0 { @@ -862,29 +905,32 @@ mod_f64 :: proc "contextless" (x, y: f64) -> (n: f64) { } return copy_sign(n, x) } +@(require_results) mod_f64le :: proc "contextless" (x, y: f64le) -> (n: f64le) { return #force_inline f64le(mod_f64(f64(x), f64(y))) } +@(require_results) mod_f64be :: proc "contextless" (x, y: f64be) -> (n: f64be) { return #force_inline f64be(mod_f64(f64(x), f64(y))) } -mod :: proc{ +mod :: proc{ mod_f16, mod_f16le, mod_f16be, mod_f32, mod_f32le, mod_f32be, mod_f64, mod_f64le, mod_f64be, } -remainder_f16 :: proc "contextless" (x, y: f16 ) -> f16 { return x - round(x/y) * y } -remainder_f16le :: proc "contextless" (x, y: f16le) -> f16le { return x - round(x/y) * y } -remainder_f16be :: proc "contextless" (x, y: f16be) -> f16be { return x - round(x/y) * y } -remainder_f32 :: proc "contextless" (x, y: f32 ) -> f32 { return x - round(x/y) * y } -remainder_f32le :: proc "contextless" (x, y: f32le) -> f32le { return x - round(x/y) * y } -remainder_f32be :: proc "contextless" (x, y: f32be) -> f32be { return x - round(x/y) * y } -remainder_f64 :: proc "contextless" (x, y: f64 ) -> f64 { return x - round(x/y) * y } -remainder_f64le :: proc "contextless" (x, y: f64le) -> f64le { return x - round(x/y) * y } -remainder_f64be :: proc "contextless" (x, y: f64be) -> f64be { return x - round(x/y) * y } -remainder :: proc{ +@(require_results) remainder_f16 :: proc "contextless" (x, y: f16 ) -> f16 { return x - round(x/y) * y } +@(require_results) remainder_f16le :: proc "contextless" (x, y: f16le) -> f16le { return x - round(x/y) * y } +@(require_results) remainder_f16be :: proc "contextless" (x, y: f16be) -> f16be { return x - round(x/y) * y } +@(require_results) remainder_f32 :: proc "contextless" (x, y: f32 ) -> f32 { return x - round(x/y) * y } +@(require_results) remainder_f32le :: proc "contextless" (x, y: f32le) -> f32le { return x - round(x/y) * y } +@(require_results) remainder_f32be :: proc "contextless" (x, y: f32be) -> f32be { return x - round(x/y) * y } +@(require_results) remainder_f64 :: proc "contextless" (x, y: f64 ) -> f64 { return x - round(x/y) * y } +@(require_results) remainder_f64le :: proc "contextless" (x, y: f64le) -> f64le { return x - round(x/y) * y } +@(require_results) remainder_f64be :: proc "contextless" (x, y: f64be) -> f64be { return x - round(x/y) * y } +remainder :: proc{ remainder_f16, remainder_f16le, remainder_f16be, remainder_f32, remainder_f32le, remainder_f32be, remainder_f64, remainder_f64le, remainder_f64be, } +@(require_results) gcd :: proc "contextless" (x, y: $T) -> T where intrinsics.type_is_ordered_numeric(T) { x, y := x, y @@ -895,23 +941,27 @@ gcd :: proc "contextless" (x, y: $T) -> T return abs(x) } +@(require_results) lcm :: proc "contextless" (x, y: $T) -> T where intrinsics.type_is_ordered_numeric(T) { return x / gcd(x, y) * y } +@(require_results) normalize_f16 :: proc "contextless" (x: f16) -> (y: f16, exponent: int) { if abs(x) < F16_MIN { return x * (1< (y: f32, exponent: int) { if abs(x) < F32_MIN { return x * (1< (y: f64, exponent: int) { if abs(x) < F64_MIN { return x * (1< (y: f64, exponent: int) { return x, 0 } -normalize_f16le :: proc "contextless" (x: f16le) -> (y: f16le, exponent: int) { y0, e := normalize_f16(f16(x)); return f16le(y0), e } -normalize_f16be :: proc "contextless" (x: f16be) -> (y: f16be, exponent: int) { y0, e := normalize_f16(f16(x)); return f16be(y0), e } -normalize_f32le :: proc "contextless" (x: f32le) -> (y: f32le, exponent: int) { y0, e := normalize_f32(f32(x)); return f32le(y0), e } -normalize_f32be :: proc "contextless" (x: f32be) -> (y: f32be, exponent: int) { y0, e := normalize_f32(f32(x)); return f32be(y0), e } -normalize_f64le :: proc "contextless" (x: f64le) -> (y: f64le, exponent: int) { y0, e := normalize_f64(f64(x)); return f64le(y0), e } -normalize_f64be :: proc "contextless" (x: f64be) -> (y: f64be, exponent: int) { y0, e := normalize_f64(f64(x)); return f64be(y0), e } +@(require_results) normalize_f16le :: proc "contextless" (x: f16le) -> (y: f16le, exponent: int) { y0, e := normalize_f16(f16(x)); return f16le(y0), e } +@(require_results) normalize_f16be :: proc "contextless" (x: f16be) -> (y: f16be, exponent: int) { y0, e := normalize_f16(f16(x)); return f16be(y0), e } +@(require_results) normalize_f32le :: proc "contextless" (x: f32le) -> (y: f32le, exponent: int) { y0, e := normalize_f32(f32(x)); return f32le(y0), e } +@(require_results) normalize_f32be :: proc "contextless" (x: f32be) -> (y: f32be, exponent: int) { y0, e := normalize_f32(f32(x)); return f32be(y0), e } +@(require_results) normalize_f64le :: proc "contextless" (x: f64le) -> (y: f64le, exponent: int) { y0, e := normalize_f64(f64(x)); return f64le(y0), e } +@(require_results) normalize_f64be :: proc "contextless" (x: f64be) -> (y: f64be, exponent: int) { y0, e := normalize_f64(f64(x)); return f64be(y0), e } normalize :: proc{ normalize_f16, @@ -938,30 +988,37 @@ normalize :: proc{ normalize_f64be, } +@(require_results) frexp_f16 :: proc "contextless" (x: f16) -> (significand: f16, exponent: int) { f, e := frexp_f64(f64(x)) return f16(f), e } +@(require_results) frexp_f16le :: proc "contextless" (x: f16le) -> (significand: f16le, exponent: int) { f, e := frexp_f64(f64(x)) return f16le(f), e } +@(require_results) frexp_f16be :: proc "contextless" (x: f16be) -> (significand: f16be, exponent: int) { f, e := frexp_f64(f64(x)) return f16be(f), e } +@(require_results) frexp_f32 :: proc "contextless" (x: f32) -> (significand: f32, exponent: int) { f, e := frexp_f64(f64(x)) return f32(f), e } +@(require_results) frexp_f32le :: proc "contextless" (x: f32le) -> (significand: f32le, exponent: int) { f, e := frexp_f64(f64(x)) return f32le(f), e } +@(require_results) frexp_f32be :: proc "contextless" (x: f32be) -> (significand: f32be, exponent: int) { f, e := frexp_f64(f64(x)) return f32be(f), e } +@(require_results) frexp_f64 :: proc "contextless" (f: f64) -> (significand: f64, exponent: int) { mask :: F64_MASK shift :: F64_SHIFT @@ -983,10 +1040,12 @@ frexp_f64 :: proc "contextless" (f: f64) -> (significand: f64, exponent: int) { significand = transmute(f64)x return } +@(require_results) frexp_f64le :: proc "contextless" (x: f64le) -> (significand: f64le, exponent: int) { f, e := frexp_f64(f64(x)) return f64le(f), e } +@(require_results) frexp_f64be :: proc "contextless" (x: f64be) -> (significand: f64be, exponent: int) { f, e := frexp_f64(f64(x)) return f64be(f), e @@ -1011,6 +1070,7 @@ frexp :: proc{ +@(require_results) binomial :: proc "contextless" (n, k: int) -> int { switch { case k <= 0: return 1 @@ -1024,6 +1084,7 @@ binomial :: proc "contextless" (n, k: int) -> int { return b } +@(require_results) factorial :: proc "contextless" (n: int) -> int { when size_of(int) == size_of(i64) { @static table := [21]int{ @@ -1069,7 +1130,8 @@ factorial :: proc "contextless" (n: int) -> int { return table[n] } -classify_f16 :: proc "contextless" (x: f16) -> Float_Class { +@(require_results) +classify_f16 :: proc "contextless" (x: f16) -> Float_Class { switch { case x == 0: i := transmute(i16)x @@ -1093,8 +1155,9 @@ classify_f16 :: proc "contextless" (x: f16) -> Float_Class { } return .Normal } -classify_f16le :: proc "contextless" (x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)) } -classify_f16be :: proc "contextless" (x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)) } +@(require_results) classify_f16le :: proc "contextless" (x: f16le) -> Float_Class { return #force_inline classify_f16(f16(x)) } +@(require_results) classify_f16be :: proc "contextless" (x: f16be) -> Float_Class { return #force_inline classify_f16(f16(x)) } +@(require_results) classify_f32 :: proc "contextless" (x: f32) -> Float_Class { switch { case x == 0: @@ -1119,8 +1182,9 @@ classify_f32 :: proc "contextless" (x: f32) -> Float_Class { } return .Normal } -classify_f32le :: proc "contextless" (x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)) } -classify_f32be :: proc "contextless" (x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)) } +@(require_results) classify_f32le :: proc "contextless" (x: f32le) -> Float_Class { return #force_inline classify_f32(f32(x)) } +@(require_results) classify_f32be :: proc "contextless" (x: f32be) -> Float_Class { return #force_inline classify_f32(f32(x)) } +@(require_results) classify_f64 :: proc "contextless" (x: f64) -> Float_Class { switch { case x == 0: @@ -1144,26 +1208,26 @@ classify_f64 :: proc "contextless" (x: f64) -> Float_Class { } return .Normal } -classify_f64le :: proc "contextless" (x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)) } -classify_f64be :: proc "contextless" (x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)) } +@(require_results) classify_f64le :: proc "contextless" (x: f64le) -> Float_Class { return #force_inline classify_f64(f64(x)) } +@(require_results) classify_f64be :: proc "contextless" (x: f64be) -> Float_Class { return #force_inline classify_f64(f64(x)) } // Returns the `Float_Class` of the value, i.e. whether normal, subnormal, zero, negative zero, NaN, infinity or // negative infinity. -classify :: proc{ +classify :: proc{ classify_f16, classify_f16le, classify_f16be, classify_f32, classify_f32le, classify_f32be, classify_f64, classify_f64le, classify_f64be, } -is_nan_f16 :: proc "contextless" (x: f16) -> bool { return classify(x) == .NaN } -is_nan_f16le :: proc "contextless" (x: f16le) -> bool { return classify(x) == .NaN } -is_nan_f16be :: proc "contextless" (x: f16be) -> bool { return classify(x) == .NaN } -is_nan_f32 :: proc "contextless" (x: f32) -> bool { return classify(x) == .NaN } -is_nan_f32le :: proc "contextless" (x: f32le) -> bool { return classify(x) == .NaN } -is_nan_f32be :: proc "contextless" (x: f32be) -> bool { return classify(x) == .NaN } -is_nan_f64 :: proc "contextless" (x: f64) -> bool { return classify(x) == .NaN } -is_nan_f64le :: proc "contextless" (x: f64le) -> bool { return classify(x) == .NaN } -is_nan_f64be :: proc "contextless" (x: f64be) -> bool { return classify(x) == .NaN } -is_nan :: proc{ +@(require_results) is_nan_f16 :: proc "contextless" (x: f16) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f16le :: proc "contextless" (x: f16le) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f16be :: proc "contextless" (x: f16be) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f32 :: proc "contextless" (x: f32) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f32le :: proc "contextless" (x: f32le) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f32be :: proc "contextless" (x: f32be) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f64 :: proc "contextless" (x: f64) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f64le :: proc "contextless" (x: f64le) -> bool { return classify(x) == .NaN } +@(require_results) is_nan_f64be :: proc "contextless" (x: f64be) -> bool { return classify(x) == .NaN } +is_nan :: proc{ is_nan_f16, is_nan_f16le, is_nan_f16be, is_nan_f32, is_nan_f32le, is_nan_f32be, is_nan_f64, is_nan_f64le, is_nan_f64be, @@ -1173,6 +1237,7 @@ is_nan :: proc{ // If sign > 0, is_inf reports whether f is positive infinity. // If sign < 0, is_inf reports whether f is negative infinity. // If sign == 0, is_inf reports whether f is either infinity. +@(require_results) is_inf_f16 :: proc "contextless" (x: f16, sign: int = 0) -> bool { class := classify(x) switch { @@ -1183,13 +1248,16 @@ is_inf_f16 :: proc "contextless" (x: f16, sign: int = 0) -> bool { } return class == .Inf || class == .Neg_Inf } +@(require_results) is_inf_f16le :: proc "contextless" (x: f16le, sign: int = 0) -> bool { return #force_inline is_inf_f16(f16(x), sign) } +@(require_results) is_inf_f16be :: proc "contextless" (x: f16be, sign: int = 0) -> bool { return #force_inline is_inf_f16(f16(x), sign) } +@(require_results) is_inf_f32 :: proc "contextless" (x: f32, sign: int = 0) -> bool { class := classify(x) switch { @@ -1200,13 +1268,16 @@ is_inf_f32 :: proc "contextless" (x: f32, sign: int = 0) -> bool { } return class == .Inf || class == .Neg_Inf } +@(require_results) is_inf_f32le :: proc "contextless" (x: f32le, sign: int = 0) -> bool { return #force_inline is_inf_f32(f32(x), sign) } +@(require_results) is_inf_f32be :: proc "contextless" (x: f32be, sign: int = 0) -> bool { return #force_inline is_inf_f32(f32(x), sign) } +@(require_results) is_inf_f64 :: proc "contextless" (x: f64, sign: int = 0) -> bool { class := classify(x) switch { @@ -1217,9 +1288,11 @@ is_inf_f64 :: proc "contextless" (x: f64, sign: int = 0) -> bool { } return class == .Inf || class == .Neg_Inf } +@(require_results) is_inf_f64le :: proc "contextless" (x: f64le, sign: int = 0) -> bool { return #force_inline is_inf_f64(f64(x), sign) } +@(require_results) is_inf_f64be :: proc "contextless" (x: f64be, sign: int = 0) -> bool { return #force_inline is_inf_f64(f64(x), sign) } @@ -1229,24 +1302,31 @@ is_inf :: proc{ is_inf_f64, is_inf_f64le, is_inf_f64be, } +@(require_results) inf_f16 :: proc "contextless" (sign: int) -> f16 { return f16(inf_f64(sign)) } +@(require_results) inf_f16le :: proc "contextless" (sign: int) -> f16le { return f16le(inf_f64(sign)) } +@(require_results) inf_f16be :: proc "contextless" (sign: int) -> f16be { return f16be(inf_f64(sign)) } +@(require_results) inf_f32 :: proc "contextless" (sign: int) -> f32 { return f32(inf_f64(sign)) } +@(require_results) inf_f32le :: proc "contextless" (sign: int) -> f32le { return f32le(inf_f64(sign)) } +@(require_results) inf_f32be :: proc "contextless" (sign: int) -> f32be { return f32be(inf_f64(sign)) } +@(require_results) inf_f64 :: proc "contextless" (sign: int) -> f64 { if sign >= 0 { return 0h7ff00000_00000000 @@ -1254,45 +1334,58 @@ inf_f64 :: proc "contextless" (sign: int) -> f64 { return 0hfff00000_00000000 } } +@(require_results) inf_f64le :: proc "contextless" (sign: int) -> f64le { return f64le(inf_f64(sign)) } +@(require_results) inf_f64be :: proc "contextless" (sign: int) -> f64be { return f64be(inf_f64(sign)) } +@(require_results) nan_f16 :: proc "contextless" () -> f16 { return f16(nan_f64()) } +@(require_results) nan_f16le :: proc "contextless" () -> f16le { return f16le(nan_f64()) } +@(require_results) nan_f16be :: proc "contextless" () -> f16be { return f16be(nan_f64()) } +@(require_results) nan_f32 :: proc "contextless" () -> f32 { return f32(nan_f64()) } +@(require_results) nan_f32le :: proc "contextless" () -> f32le { return f32le(nan_f64()) } +@(require_results) nan_f32be :: proc "contextless" () -> f32be { return f32be(nan_f64()) } +@(require_results) nan_f64 :: proc "contextless" () -> f64 { return 0h7ff80000_00000001 } +@(require_results) nan_f64le :: proc "contextless" () -> f64le { return f64le(nan_f64()) } +@(require_results) nan_f64be :: proc "contextless" () -> f64be { return f64be(nan_f64()) } +@(require_results) is_power_of_two :: proc "contextless" (x: int) -> bool { return x > 0 && (x & (x-1)) == 0 } +@(require_results) next_power_of_two :: proc "contextless" (x: int) -> int { k := x -1 when size_of(int) == 8 { @@ -1307,6 +1400,7 @@ next_power_of_two :: proc "contextless" (x: int) -> int { return k } +@(require_results) sum :: proc "contextless" (x: $T/[]$E) -> (res: E) where intrinsics.type_is_numeric(E) { for i in x { @@ -1315,6 +1409,7 @@ sum :: proc "contextless" (x: $T/[]$E) -> (res: E) return } +@(require_results) prod :: proc "contextless" (x: $T/[]$E) -> (res: E) where intrinsics.type_is_numeric(E) { res = 1 @@ -1332,6 +1427,7 @@ cumsum_inplace :: proc "contextless" (x: $T/[]$E) } +@(require_results) cumsum :: proc "contextless" (dst, src: $T/[]$E) -> T where intrinsics.type_is_numeric(E) { N := min(len(dst), len(src)) @@ -1345,31 +1441,38 @@ cumsum :: proc "contextless" (dst, src: $T/[]$E) -> T } +@(require_results) atan2_f16 :: proc "contextless" (y, x: f16) -> f16 { // TODO(bill): Better atan2_f16 return f16(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f16le :: proc "contextless" (y, x: f16le) -> f16le { // TODO(bill): Better atan2_f16 return f16le(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f16be :: proc "contextless" (y, x: f16be) -> f16be { // TODO(bill): Better atan2_f16 return f16be(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f32 :: proc "contextless" (y, x: f32) -> f32 { // TODO(bill): Better atan2_f32 return f32(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f32le :: proc "contextless" (y, x: f32le) -> f32le { // TODO(bill): Better atan2_f32 return f32le(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f32be :: proc "contextless" (y, x: f32be) -> f32be { // TODO(bill): Better atan2_f32 return f32be(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f64 :: proc "contextless" (y, x: f64) -> f64 { // TODO(bill): Faster atan2_f64 if possible @@ -1455,10 +1558,12 @@ atan2_f64 :: proc "contextless" (y, x: f64) -> f64 { } return q } +@(require_results) atan2_f64le :: proc "contextless" (y, x: f64le) -> f64le { // TODO(bill): Better atan2_f32 return f64le(atan2_f64(f64(y), f64(x))) } +@(require_results) atan2_f64be :: proc "contextless" (y, x: f64be) -> f64be { // TODO(bill): Better atan2_f32 return f64be(atan2_f64(f64(y), f64(x))) @@ -1471,12 +1576,14 @@ atan2 :: proc{ atan2_f16le, atan2_f16be, } +@(require_results) atan :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) { return atan2(x, 1) } +@(require_results) asin_f64 :: proc "contextless" (x: f64) -> f64 { /* origin: FreeBSD /usr/src/lib/msun/src/e_asin.c */ /* @@ -1548,27 +1655,35 @@ asin_f64 :: proc "contextless" (x: f64) -> f64 { } return -x if hx >> 31 != 0 else x } +@(require_results) asin_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(asin_f64(f64(x))) } +@(require_results) asin_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(asin_f64(f64(x))) } +@(require_results) asin_f32 :: proc "contextless" (x: f32) -> f32 { return f32(asin_f64(f64(x))) } +@(require_results) asin_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(asin_f64(f64(x))) } +@(require_results) asin_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(asin_f64(f64(x))) } +@(require_results) asin_f16 :: proc "contextless" (x: f16) -> f16 { return f16(asin_f64(f64(x))) } +@(require_results) asin_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(asin_f64(f64(x))) } +@(require_results) asin_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(asin_f64(f64(x))) } @@ -1580,6 +1695,7 @@ asin :: proc{ } +@(require_results) acos_f64 :: proc "contextless" (x: f64) -> f64 { /* origin: FreeBSD /usr/src/lib/msun/src/e_acos.c */ /* @@ -1653,27 +1769,35 @@ acos_f64 :: proc "contextless" (x: f64) -> f64 { w = R(z)*s+c return 2*(df+w) } +@(require_results) acos_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(acos_f64(f64(x))) } +@(require_results) acos_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(acos_f64(f64(x))) } +@(require_results) acos_f32 :: proc "contextless" (x: f32) -> f32 { return f32(acos_f64(f64(x))) } +@(require_results) acos_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(acos_f64(f64(x))) } +@(require_results) acos_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(acos_f64(f64(x))) } +@(require_results) acos_f16 :: proc "contextless" (x: f16) -> f16 { return f16(acos_f64(f64(x))) } +@(require_results) acos_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(acos_f64(f64(x))) } +@(require_results) acos_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(acos_f64(f64(x))) } @@ -1684,14 +1808,17 @@ acos :: proc{ acos_f16le, acos_f16be, } +@(require_results) sinh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) { return copy_sign(((exp(x) - exp(-x))*0.5), x) } +@(require_results) cosh :: proc "contextless" (x: $T) -> T where intrinsics.type_is_float(T) { return ((exp(x) + exp(-x))*0.5) } +@(require_results) tanh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { P0 :: -9.64399179425052238628e-1 P1 :: -9.92877231001918586564e1 @@ -1727,6 +1854,7 @@ tanh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { return T(z) } +@(require_results) asinh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { // The original C code, the long comment, and the constants // below are from FreeBSD's /usr/src/lib/msun/src/s_asinh.c @@ -1773,6 +1901,7 @@ asinh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { return T(temp) } +@(require_results) acosh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { // The original C code, the long comment, and the constants // below are from FreeBSD's /usr/src/lib/msun/src/e_acosh.c @@ -1804,6 +1933,7 @@ acosh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { return T(log1p(t + sqrt(2*t + t*t))) } +@(require_results) atanh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { // The original C code, the long comment, and the constants // below are from FreeBSD's /usr/src/lib/msun/src/e_atanh.c @@ -1848,6 +1978,7 @@ atanh :: proc "contextless" (y: $T) -> T where intrinsics.type_is_float(T) { return T(temp) } +@(require_results) ilogb_f16 :: proc "contextless" (val: f16) -> int { switch { case val == 0: return int(min(i32)) @@ -1857,6 +1988,7 @@ ilogb_f16 :: proc "contextless" (val: f16) -> int { x, exp := normalize_f16(val) return int(((transmute(u16)x)>>F16_SHIFT)&F16_MASK) - F16_BIAS + exp } +@(require_results) ilogb_f32 :: proc "contextless" (val: f32) -> int { switch { case val == 0: return int(min(i32)) @@ -1866,6 +1998,7 @@ ilogb_f32 :: proc "contextless" (val: f32) -> int { x, exp := normalize_f32(val) return int(((transmute(u32)x)>>F32_SHIFT)&F32_MASK) - F32_BIAS + exp } +@(require_results) ilogb_f64 :: proc "contextless" (val: f64) -> int { switch { case val == 0: return int(min(i32)) @@ -1875,12 +2008,12 @@ ilogb_f64 :: proc "contextless" (val: f64) -> int { x, exp := normalize_f64(val) return int(((transmute(u64)x)>>F64_SHIFT)&F64_MASK) - F64_BIAS + exp } -ilogb_f16le :: proc "contextless" (value: f16le) -> int { return ilogb_f16(f16(value)) } -ilogb_f16be :: proc "contextless" (value: f16be) -> int { return ilogb_f16(f16(value)) } -ilogb_f32le :: proc "contextless" (value: f32le) -> int { return ilogb_f32(f32(value)) } -ilogb_f32be :: proc "contextless" (value: f32be) -> int { return ilogb_f32(f32(value)) } -ilogb_f64le :: proc "contextless" (value: f64le) -> int { return ilogb_f64(f64(value)) } -ilogb_f64be :: proc "contextless" (value: f64be) -> int { return ilogb_f64(f64(value)) } +@(require_results) ilogb_f16le :: proc "contextless" (value: f16le) -> int { return ilogb_f16(f16(value)) } +@(require_results) ilogb_f16be :: proc "contextless" (value: f16be) -> int { return ilogb_f16(f16(value)) } +@(require_results) ilogb_f32le :: proc "contextless" (value: f32le) -> int { return ilogb_f32(f32(value)) } +@(require_results) ilogb_f32be :: proc "contextless" (value: f32be) -> int { return ilogb_f32(f32(value)) } +@(require_results) ilogb_f64le :: proc "contextless" (value: f64le) -> int { return ilogb_f64(f64(value)) } +@(require_results) ilogb_f64be :: proc "contextless" (value: f64be) -> int { return ilogb_f64(f64(value)) } ilogb :: proc { ilogb_f16, ilogb_f32, @@ -1893,6 +2026,7 @@ ilogb :: proc { ilogb_f64be, } +@(require_results) logb_f16 :: proc "contextless" (val: f16) -> f16 { switch { case val == 0: return inf_f16(-1) @@ -1901,6 +2035,7 @@ logb_f16 :: proc "contextless" (val: f16) -> f16 { } return f16(ilogb(val)) } +@(require_results) logb_f32 :: proc "contextless" (val: f32) -> f32 { switch { case val == 0: return inf_f32(-1) @@ -1909,6 +2044,7 @@ logb_f32 :: proc "contextless" (val: f32) -> f32 { } return f32(ilogb(val)) } +@(require_results) logb_f64 :: proc "contextless" (val: f64) -> f64 { switch { case val == 0: return inf_f64(-1) @@ -1917,12 +2053,12 @@ logb_f64 :: proc "contextless" (val: f64) -> f64 { } return f64(ilogb(val)) } -logb_f16le :: proc "contextless" (value: f16le) -> f16le { return f16le(logb_f16(f16(value))) } -logb_f16be :: proc "contextless" (value: f16be) -> f16be { return f16be(logb_f16(f16(value))) } -logb_f32le :: proc "contextless" (value: f32le) -> f32le { return f32le(logb_f32(f32(value))) } -logb_f32be :: proc "contextless" (value: f32be) -> f32be { return f32be(logb_f32(f32(value))) } -logb_f64le :: proc "contextless" (value: f64le) -> f64le { return f64le(logb_f64(f64(value))) } -logb_f64be :: proc "contextless" (value: f64be) -> f64be { return f64be(logb_f64(f64(value))) } +@(require_results) logb_f16le :: proc "contextless" (value: f16le) -> f16le { return f16le(logb_f16(f16(value))) } +@(require_results) logb_f16be :: proc "contextless" (value: f16be) -> f16be { return f16be(logb_f16(f16(value))) } +@(require_results) logb_f32le :: proc "contextless" (value: f32le) -> f32le { return f32le(logb_f32(f32(value))) } +@(require_results) logb_f32be :: proc "contextless" (value: f32be) -> f32be { return f32be(logb_f32(f32(value))) } +@(require_results) logb_f64le :: proc "contextless" (value: f64le) -> f64le { return f64le(logb_f64(f64(value))) } +@(require_results) logb_f64be :: proc "contextless" (value: f64be) -> f64be { return f64be(logb_f64(f64(value))) } logb :: proc { logb_f16, logb_f32, @@ -1935,6 +2071,7 @@ logb :: proc { logb_f64be, } +@(require_results) nextafter_f16 :: proc "contextless" (x, y: f16) -> (r: f16) { switch { case is_nan(x) || is_nan(y): @@ -1950,6 +2087,7 @@ nextafter_f16 :: proc "contextless" (x, y: f16) -> (r: f16) { } return } +@(require_results) nextafter_f32 :: proc "contextless" (x, y: f32) -> (r: f32) { switch { case is_nan(x) || is_nan(y): @@ -1965,6 +2103,7 @@ nextafter_f32 :: proc "contextless" (x, y: f32) -> (r: f32) { } return } +@(require_results) nextafter_f64 :: proc "contextless" (x, y: f64) -> (r: f64) { switch { case is_nan(x) || is_nan(y): @@ -1980,12 +2119,12 @@ nextafter_f64 :: proc "contextless" (x, y: f64) -> (r: f64) { } return } -nextafter_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) { return f16le(nextafter_f16(f16(x), f16(y))) } -nextafter_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) { return f16be(nextafter_f16(f16(x), f16(y))) } -nextafter_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) { return f32le(nextafter_f32(f32(x), f32(y))) } -nextafter_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) { return f32be(nextafter_f32(f32(x), f32(y))) } -nextafter_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) { return f64le(nextafter_f64(f64(x), f64(y))) } -nextafter_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) { return f64be(nextafter_f64(f64(x), f64(y))) } +@(require_results) nextafter_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) { return f16le(nextafter_f16(f16(x), f16(y))) } +@(require_results) nextafter_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) { return f16be(nextafter_f16(f16(x), f16(y))) } +@(require_results) nextafter_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) { return f32le(nextafter_f32(f32(x), f32(y))) } +@(require_results) nextafter_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) { return f32be(nextafter_f32(f32(x), f32(y))) } +@(require_results) nextafter_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) { return f64le(nextafter_f64(f64(x), f64(y))) } +@(require_results) nextafter_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) { return f64be(nextafter_f64(f64(x), f64(y))) } nextafter :: proc{ nextafter_f16, nextafter_f16le, nextafter_f16be, @@ -1993,21 +2132,24 @@ nextafter :: proc{ nextafter_f64, nextafter_f64le, nextafter_f64be, } +@(require_results) signbit_f16 :: proc "contextless" (x: f16) -> bool { return (transmute(u16)x)&(1<<15) != 0 } +@(require_results) signbit_f32 :: proc "contextless" (x: f32) -> bool { return (transmute(u32)x)&(1<<31) != 0 } +@(require_results) signbit_f64 :: proc "contextless" (x: f64) -> bool { return (transmute(u64)x)&(1<<63) != 0 } -signbit_f16le :: proc "contextless" (x: f16le) -> bool { return signbit_f16(f16(x)) } -signbit_f32le :: proc "contextless" (x: f32le) -> bool { return signbit_f32(f32(x)) } -signbit_f64le :: proc "contextless" (x: f64le) -> bool { return signbit_f64(f64(x)) } -signbit_f16be :: proc "contextless" (x: f16be) -> bool { return signbit_f16(f16(x)) } -signbit_f32be :: proc "contextless" (x: f32be) -> bool { return signbit_f32(f32(x)) } -signbit_f64be :: proc "contextless" (x: f64be) -> bool { return signbit_f64(f64(x)) } +@(require_results) signbit_f16le :: proc "contextless" (x: f16le) -> bool { return signbit_f16(f16(x)) } +@(require_results) signbit_f32le :: proc "contextless" (x: f32le) -> bool { return signbit_f32(f32(x)) } +@(require_results) signbit_f64le :: proc "contextless" (x: f64le) -> bool { return signbit_f64(f64(x)) } +@(require_results) signbit_f16be :: proc "contextless" (x: f16be) -> bool { return signbit_f16(f16(x)) } +@(require_results) signbit_f32be :: proc "contextless" (x: f32be) -> bool { return signbit_f32(f32(x)) } +@(require_results) signbit_f64be :: proc "contextless" (x: f64be) -> bool { return signbit_f64(f64(x)) } signbit :: proc{ signbit_f16, signbit_f16le, signbit_f16be, diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin index c9d2e632d..785c43b10 100644 --- a/core/math/math_basic.odin +++ b/core/math/math_basic.odin @@ -5,54 +5,58 @@ import "core:intrinsics" @(default_calling_convention="none") foreign _ { - @(link_name="llvm.sin.f16") + @(link_name="llvm.sin.f16", require_results) sin_f16 :: proc(θ: f16) -> f16 --- - @(link_name="llvm.sin.f32") + @(link_name="llvm.sin.f32", require_results) sin_f32 :: proc(θ: f32) -> f32 --- - @(link_name="llvm.sin.f64") + @(link_name="llvm.sin.f64", require_results) sin_f64 :: proc(θ: f64) -> f64 --- - @(link_name="llvm.cos.f16") + @(link_name="llvm.cos.f16", require_results) cos_f16 :: proc(θ: f16) -> f16 --- - @(link_name="llvm.cos.f32") + @(link_name="llvm.cos.f32", require_results) cos_f32 :: proc(θ: f32) -> f32 --- - @(link_name="llvm.cos.f64") + @(link_name="llvm.cos.f64", require_results) cos_f64 :: proc(θ: f64) -> f64 --- - @(link_name="llvm.pow.f16") + @(link_name="llvm.pow.f16", require_results) pow_f16 :: proc(x, power: f16) -> f16 --- - @(link_name="llvm.pow.f32") + @(link_name="llvm.pow.f32", require_results) pow_f32 :: proc(x, power: f32) -> f32 --- - @(link_name="llvm.pow.f64") + @(link_name="llvm.pow.f64", require_results) pow_f64 :: proc(x, power: f64) -> f64 --- - @(link_name="llvm.fmuladd.f16") + @(link_name="llvm.fmuladd.f16", require_results) fmuladd_f16 :: proc(a, b, c: f16) -> f16 --- - @(link_name="llvm.fmuladd.f32") + @(link_name="llvm.fmuladd.f32", require_results) fmuladd_f32 :: proc(a, b, c: f32) -> f32 --- - @(link_name="llvm.fmuladd.f64") + @(link_name="llvm.fmuladd.f64", require_results) fmuladd_f64 :: proc(a, b, c: f64) -> f64 --- - @(link_name="llvm.exp.f16") + @(link_name="llvm.exp.f16", require_results) exp_f16 :: proc(x: f16) -> f16 --- - @(link_name="llvm.exp.f32") + @(link_name="llvm.exp.f32", require_results) exp_f32 :: proc(x: f32) -> f32 --- - @(link_name="llvm.exp.f64") + @(link_name="llvm.exp.f64", require_results) exp_f64 :: proc(x: f64) -> f64 --- } +@(require_results) sqrt_f16 :: proc "contextless" (x: f16) -> f16 { return intrinsics.sqrt(x) } +@(require_results) sqrt_f32 :: proc "contextless" (x: f32) -> f32 { return intrinsics.sqrt(x) } +@(require_results) sqrt_f64 :: proc "contextless" (x: f64) -> f64 { return intrinsics.sqrt(x) } +@(require_results) ln_f64 :: proc "contextless" (x: f64) -> f64 { // The original C code, the long comment, and the constants // below are from FreeBSD's /usr/src/lib/msun/src/e_log.c @@ -154,14 +158,14 @@ ln_f64 :: proc "contextless" (x: f64) -> f64 { return k*LN2_HI - ((hfsq - (s*(hfsq+R) + k*LN2_LO)) - f) } -ln_f16 :: proc "contextless" (x: f16) -> f16 { return #force_inline f16(ln_f64(f64(x))) } -ln_f32 :: proc "contextless" (x: f32) -> f32 { return #force_inline f32(ln_f64(f64(x))) } -ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) } -ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) } -ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) } -ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) } -ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) } -ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) } +@(require_results) ln_f16 :: proc "contextless" (x: f16) -> f16 { return #force_inline f16(ln_f64(f64(x))) } +@(require_results) ln_f32 :: proc "contextless" (x: f32) -> f32 { return #force_inline f32(ln_f64(f64(x))) } +@(require_results) ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) } +@(require_results) ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) } +@(require_results) ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) } +@(require_results) ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) } +@(require_results) ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) } +@(require_results) ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) } ln :: proc{ ln_f16, ln_f16le, ln_f16be, ln_f32, ln_f32le, ln_f32be, diff --git a/core/math/math_basic_js.odin b/core/math/math_basic_js.odin index ec572f898..acd3c2b39 100644 --- a/core/math/math_basic_js.odin +++ b/core/math/math_basic_js.odin @@ -7,46 +7,47 @@ foreign import "odin_env" @(default_calling_convention="c") foreign odin_env { - @(link_name="sin") + @(link_name="sin", require_results) sin_f64 :: proc(θ: f64) -> f64 --- - @(link_name="cos") + @(link_name="cos", require_results) cos_f64 :: proc(θ: f64) -> f64 --- - @(link_name="pow") + @(link_name="pow", require_results) pow_f64 :: proc(x, power: f64) -> f64 --- - @(link_name="fmuladd") + @(link_name="fmuladd", require_results) fmuladd_f64 :: proc(a, b, c: f64) -> f64 --- - @(link_name="ln") + @(link_name="ln", require_results) ln_f64 :: proc(x: f64) -> f64 --- - @(link_name="exp") + @(link_name="exp", require_results) exp_f64 :: proc(x: f64) -> f64 --- } +@(require_results) sqrt_f64 :: proc "contextless" (x: f64) -> f64 { return intrinsics.sqrt(x) } -sqrt_f16 :: proc "c" (x: f16) -> f16 { return f16(sqrt_f64(f64(x))) } -sin_f16 :: proc "c" (θ: f16) -> f16 { return f16(sin_f64(f64(θ))) } -cos_f16 :: proc "c" (θ: f16) -> f16 { return f16(cos_f64(f64(θ))) } -pow_f16 :: proc "c" (x, power: f16) -> f16 { return f16(pow_f64(f64(x), f64(power))) } -fmuladd_f16 :: proc "c" (a, b, c: f16) -> f16 { return f16(fmuladd_f64(f64(a), f64(a), f64(c))) } -ln_f16 :: proc "c" (x: f16) -> f16 { return f16(ln_f64(f64(x))) } -exp_f16 :: proc "c" (x: f16) -> f16 { return f16(exp_f64(f64(x))) } +@(require_results) sqrt_f16 :: proc "c" (x: f16) -> f16 { return f16(sqrt_f64(f64(x))) } +@(require_results) sin_f16 :: proc "c" (θ: f16) -> f16 { return f16(sin_f64(f64(θ))) } +@(require_results) cos_f16 :: proc "c" (θ: f16) -> f16 { return f16(cos_f64(f64(θ))) } +@(require_results) pow_f16 :: proc "c" (x, power: f16) -> f16 { return f16(pow_f64(f64(x), f64(power))) } +@(require_results) fmuladd_f16 :: proc "c" (a, b, c: f16) -> f16 { return f16(fmuladd_f64(f64(a), f64(a), f64(c))) } +@(require_results) ln_f16 :: proc "c" (x: f16) -> f16 { return f16(ln_f64(f64(x))) } +@(require_results) exp_f16 :: proc "c" (x: f16) -> f16 { return f16(exp_f64(f64(x))) } -sqrt_f32 :: proc "c" (x: f32) -> f32 { return f32(sqrt_f64(f64(x))) } -sin_f32 :: proc "c" (θ: f32) -> f32 { return f32(sin_f64(f64(θ))) } -cos_f32 :: proc "c" (θ: f32) -> f32 { return f32(cos_f64(f64(θ))) } -pow_f32 :: proc "c" (x, power: f32) -> f32 { return f32(pow_f64(f64(x), f64(power))) } -fmuladd_f32 :: proc "c" (a, b, c: f32) -> f32 { return f32(fmuladd_f64(f64(a), f64(a), f64(c))) } -ln_f32 :: proc "c" (x: f32) -> f32 { return f32(ln_f64(f64(x))) } -exp_f32 :: proc "c" (x: f32) -> f32 { return f32(exp_f64(f64(x))) } +@(require_results) sqrt_f32 :: proc "c" (x: f32) -> f32 { return f32(sqrt_f64(f64(x))) } +@(require_results) sin_f32 :: proc "c" (θ: f32) -> f32 { return f32(sin_f64(f64(θ))) } +@(require_results) cos_f32 :: proc "c" (θ: f32) -> f32 { return f32(cos_f64(f64(θ))) } +@(require_results) pow_f32 :: proc "c" (x, power: f32) -> f32 { return f32(pow_f64(f64(x), f64(power))) } +@(require_results) fmuladd_f32 :: proc "c" (a, b, c: f32) -> f32 { return f32(fmuladd_f64(f64(a), f64(a), f64(c))) } +@(require_results) ln_f32 :: proc "c" (x: f32) -> f32 { return f32(ln_f64(f64(x))) } +@(require_results) exp_f32 :: proc "c" (x: f32) -> f32 { return f32(exp_f64(f64(x))) } -ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) } -ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) } -ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) } -ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) } -ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) } -ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) } +@(require_results) ln_f16le :: proc "contextless" (x: f16le) -> f16le { return #force_inline f16le(ln_f64(f64(x))) } +@(require_results) ln_f16be :: proc "contextless" (x: f16be) -> f16be { return #force_inline f16be(ln_f64(f64(x))) } +@(require_results) ln_f32le :: proc "contextless" (x: f32le) -> f32le { return #force_inline f32le(ln_f64(f64(x))) } +@(require_results) ln_f32be :: proc "contextless" (x: f32be) -> f32be { return #force_inline f32be(ln_f64(f64(x))) } +@(require_results) ln_f64le :: proc "contextless" (x: f64le) -> f64le { return #force_inline f64le(ln_f64(f64(x))) } +@(require_results) ln_f64be :: proc "contextless" (x: f64be) -> f64be { return #force_inline f64be(ln_f64(f64(x))) } ln :: proc{ ln_f16, ln_f16le, ln_f16be, ln_f32, ln_f32le, ln_f32be, diff --git a/core/math/math_erf.odin b/core/math/math_erf.odin index cdade59c5..b5a4663ae 100644 --- a/core/math/math_erf.odin +++ b/core/math/math_erf.odin @@ -117,13 +117,14 @@ erf :: proc{ erf_f64, } -erf_f16 :: proc "contextless" (x: f16) -> f16 { return f16(erf_f64(f64(x))) } -erf_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erf_f64(f64(x))) } -erf_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erf_f64(f64(x))) } -erf_f32 :: proc "contextless" (x: f32) -> f32 { return f32(erf_f64(f64(x))) } -erf_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erf_f64(f64(x))) } -erf_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erf_f64(f64(x))) } +@(require_results) erf_f16 :: proc "contextless" (x: f16) -> f16 { return f16(erf_f64(f64(x))) } +@(require_results) erf_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erf_f64(f64(x))) } +@(require_results) erf_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erf_f64(f64(x))) } +@(require_results) erf_f32 :: proc "contextless" (x: f32) -> f32 { return f32(erf_f64(f64(x))) } +@(require_results) erf_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erf_f64(f64(x))) } +@(require_results) erf_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erf_f64(f64(x))) } +@(require_results) erf_f64 :: proc "contextless" (x: f64) -> f64 { erx :: 0h3FEB0AC160000000 // Coefficients for approximation to erf in [0, 0.84375] @@ -268,13 +269,14 @@ erfc :: proc{ erfc_f64, } -erfc_f16 :: proc "contextless" (x: f16) -> f16 { return f16(erfc_f64(f64(x))) } -erfc_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erfc_f64(f64(x))) } -erfc_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erfc_f64(f64(x))) } -erfc_f32 :: proc "contextless" (x: f32) -> f32 { return f32(erfc_f64(f64(x))) } -erfc_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erfc_f64(f64(x))) } -erfc_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erfc_f64(f64(x))) } +@(require_results) erfc_f16 :: proc "contextless" (x: f16) -> f16 { return f16(erfc_f64(f64(x))) } +@(require_results) erfc_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(erfc_f64(f64(x))) } +@(require_results) erfc_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(erfc_f64(f64(x))) } +@(require_results) erfc_f32 :: proc "contextless" (x: f32) -> f32 { return f32(erfc_f64(f64(x))) } +@(require_results) erfc_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(erfc_f64(f64(x))) } +@(require_results) erfc_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(erfc_f64(f64(x))) } +@(require_results) erfc_f64 :: proc "contextless" (x: f64) -> f64 { erx :: 0h3FEB0AC160000000 // Coefficients for approximation to erf in [0, 0.84375] diff --git a/core/math/math_gamma.odin b/core/math/math_gamma.odin index 6b783cc25..00d4b7316 100644 --- a/core/math/math_gamma.odin +++ b/core/math/math_gamma.odin @@ -65,7 +65,7 @@ package math // The polynomial is valid for 33 <= x <= 172; larger values are only used // in reciprocal and produce denormalized floats. The lower precision there // masks any imprecision in the polynomial. -@(private="file") +@(private="file", require_results) stirling :: proc "contextless" (x: f64) -> (f64, f64) { @(static) gamS := [?]f64{ +7.87311395793093628397e-04, @@ -93,6 +93,7 @@ stirling :: proc "contextless" (x: f64) -> (f64, f64) { return y1, SQRT_TWO_PI * w * y2 } +@(require_results) gamma_f64 :: proc "contextless" (x: f64) -> f64 { is_neg_int :: proc "contextless" (x: f64) -> bool { if x < 0 { @@ -210,14 +211,14 @@ gamma_f64 :: proc "contextless" (x: f64) -> f64 { } -gamma_f16 :: proc "contextless" (x: f16) -> f16 { return f16(gamma_f64(f64(x))) } -gamma_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(gamma_f64(f64(x))) } -gamma_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(gamma_f64(f64(x))) } -gamma_f32 :: proc "contextless" (x: f32) -> f32 { return f32(gamma_f64(f64(x))) } -gamma_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(gamma_f64(f64(x))) } -gamma_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(gamma_f64(f64(x))) } -gamma_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(gamma_f64(f64(x))) } -gamma_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(gamma_f64(f64(x))) } +@(require_results) gamma_f16 :: proc "contextless" (x: f16) -> f16 { return f16(gamma_f64(f64(x))) } +@(require_results) gamma_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(gamma_f64(f64(x))) } +@(require_results) gamma_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(gamma_f64(f64(x))) } +@(require_results) gamma_f32 :: proc "contextless" (x: f32) -> f32 { return f32(gamma_f64(f64(x))) } +@(require_results) gamma_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(gamma_f64(f64(x))) } +@(require_results) gamma_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(gamma_f64(f64(x))) } +@(require_results) gamma_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(gamma_f64(f64(x))) } +@(require_results) gamma_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(gamma_f64(f64(x))) } gamma :: proc{ gamma_f16, gamma_f16le, gamma_f16be, diff --git a/core/math/math_lgamma.odin b/core/math/math_lgamma.odin index 98b2731c9..0705d8564 100644 --- a/core/math/math_lgamma.odin +++ b/core/math/math_lgamma.odin @@ -80,7 +80,9 @@ package math // +@(require_results) lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) { + @(require_results) sin_pi :: proc "contextless" (x: f64) -> f64 { if x < 0.25 { return -sin(PI * x) @@ -345,14 +347,14 @@ lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) { } -lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) { r, s := lgamma_f64(f64(x)); return f16(r), s } -lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) { r, s := lgamma_f64(f64(x)); return f32(r), s } -lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) { r, s := lgamma_f64(f64(x)); return f16le(r), s } -lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) { r, s := lgamma_f64(f64(x)); return f16be(r), s } -lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) { r, s := lgamma_f64(f64(x)); return f32le(r), s } -lgamma_f32be :: proc "contextless" (x: f32be) -> (lgamma: f32be, sign: int) { r, s := lgamma_f64(f64(x)); return f32be(r), s } -lgamma_f64le :: proc "contextless" (x: f64le) -> (lgamma: f64le, sign: int) { r, s := lgamma_f64(f64(x)); return f64le(r), s } -lgamma_f64be :: proc "contextless" (x: f64be) -> (lgamma: f64be, sign: int) { r, s := lgamma_f64(f64(x)); return f64be(r), s } +@(require_results) lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) { r, s := lgamma_f64(f64(x)); return f16(r), s } +@(require_results) lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) { r, s := lgamma_f64(f64(x)); return f32(r), s } +@(require_results) lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) { r, s := lgamma_f64(f64(x)); return f16le(r), s } +@(require_results) lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) { r, s := lgamma_f64(f64(x)); return f16be(r), s } +@(require_results) lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) { r, s := lgamma_f64(f64(x)); return f32le(r), s } +@(require_results) lgamma_f32be :: proc "contextless" (x: f32be) -> (lgamma: f32be, sign: int) { r, s := lgamma_f64(f64(x)); return f32be(r), s } +@(require_results) lgamma_f64le :: proc "contextless" (x: f64le) -> (lgamma: f64le, sign: int) { r, s := lgamma_f64(f64(x)); return f64le(r), s } +@(require_results) lgamma_f64be :: proc "contextless" (x: f64be) -> (lgamma: f64be, sign: int) { r, s := lgamma_f64(f64(x)); return f64be(r), s } lgamma :: proc{ lgamma_f16, lgamma_f16le, lgamma_f16be, diff --git a/core/math/math_log1p.odin b/core/math/math_log1p.odin index a4a1aa2ae..fc10ed364 100644 --- a/core/math/math_log1p.odin +++ b/core/math/math_log1p.odin @@ -90,15 +90,16 @@ log1p :: proc { log1p_f64le, log1p_f64be, } -log1p_f16 :: proc "contextless" (x: f16) -> f16 { return f16(log1p_f64(f64(x))) } -log1p_f32 :: proc "contextless" (x: f32) -> f32 { return f32(log1p_f64(f64(x))) } -log1p_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log1p_f64(f64(x))) } -log1p_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log1p_f64(f64(x))) } -log1p_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log1p_f64(f64(x))) } -log1p_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log1p_f64(f64(x))) } -log1p_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log1p_f64(f64(x))) } -log1p_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log1p_f64(f64(x))) } +@(require_results) log1p_f16 :: proc "contextless" (x: f16) -> f16 { return f16(log1p_f64(f64(x))) } +@(require_results) log1p_f32 :: proc "contextless" (x: f32) -> f32 { return f32(log1p_f64(f64(x))) } +@(require_results) log1p_f16le :: proc "contextless" (x: f16le) -> f16le { return f16le(log1p_f64(f64(x))) } +@(require_results) log1p_f16be :: proc "contextless" (x: f16be) -> f16be { return f16be(log1p_f64(f64(x))) } +@(require_results) log1p_f32le :: proc "contextless" (x: f32le) -> f32le { return f32le(log1p_f64(f64(x))) } +@(require_results) log1p_f32be :: proc "contextless" (x: f32be) -> f32be { return f32be(log1p_f64(f64(x))) } +@(require_results) log1p_f64le :: proc "contextless" (x: f64le) -> f64le { return f64le(log1p_f64(f64(x))) } +@(require_results) log1p_f64be :: proc "contextless" (x: f64be) -> f64be { return f64be(log1p_f64(f64(x))) } +@(require_results) log1p_f64 :: proc "contextless" (x: f64) -> f64 { SQRT2_M1 :: 0h3fda827999fcef34 // sqrt(2)-1 SQRT2_HALF_M1 :: 0hbfd2bec333018866 // sqrt(2)/2-1 From 2df6cabee0067fc0214cd9e246bcb2c9521f61b8 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 11:59:44 +0100 Subject: [PATCH 045/108] Add `@(require_results)` to `core:math/rand` --- core/math/rand/distributions.odin | 26 ++++++++++++++++++++++++++ core/math/rand/exp.odin | 1 + core/math/rand/normal.odin | 1 + core/math/rand/rand.odin | 25 ++++++++++++++++++------- core/math/rand/system_darwin.odin | 1 + core/math/rand/system_linux.odin | 1 + core/math/rand/system_windows.odin | 1 + 7 files changed, 49 insertions(+), 7 deletions(-) diff --git a/core/math/rand/distributions.odin b/core/math/rand/distributions.odin index ada89afad..9365e8b76 100644 --- a/core/math/rand/distributions.odin +++ b/core/math/rand/distributions.odin @@ -7,6 +7,7 @@ float32_uniform :: float32_range // Triangular Distribution // See: http://wikipedia.org/wiki/Triangular_distribution +@(require_results) float64_triangular :: proc(lo, hi: f64, mode: Maybe(f64), r: ^Rand = nil) -> f64 { if hi-lo == 0 { return lo @@ -24,6 +25,7 @@ float64_triangular :: proc(lo, hi: f64, mode: Maybe(f64), r: ^Rand = nil) -> f64 } // Triangular Distribution // See: http://wikipedia.org/wiki/Triangular_distribution +@(require_results) float32_triangular :: proc(lo, hi: f32, mode: Maybe(f32), r: ^Rand = nil) -> f32 { if hi-lo == 0 { return lo @@ -41,20 +43,24 @@ float32_triangular :: proc(lo, hi: f32, mode: Maybe(f32), r: ^Rand = nil) -> f32 // Normal/Gaussian Distribution +@(require_results) float64_normal :: proc(mean, stddev: f64, r: ^Rand = nil) -> f64 { return norm_float64(r) * stddev + mean } // Normal/Gaussian Distribution +@(require_results) float32_normal :: proc(mean, stddev: f32, r: ^Rand = nil) -> f32 { return f32(float64_normal(f64(mean), f64(stddev), r)) } // Log Normal Distribution +@(require_results) float64_log_normal :: proc(mean, stddev: f64, r: ^Rand = nil) -> f64 { return math.exp(float64_normal(mean, stddev, r)) } // Log Normal Distribution +@(require_results) float32_log_normal :: proc(mean, stddev: f32, r: ^Rand = nil) -> f32 { return f32(float64_log_normal(f64(mean), f64(stddev), r)) } @@ -65,6 +71,7 @@ float32_log_normal :: proc(mean, stddev: f32, r: ^Rand = nil) -> f32 { // Return values range from // 0 to positive infinity if lambda > 0 // negative infinity to 0 if lambda <= 0 +@(require_results) float64_exponential :: proc(lambda: f64, r: ^Rand = nil) -> f64 { return - math.ln(1 - float64(r)) / lambda } @@ -73,6 +80,7 @@ float64_exponential :: proc(lambda: f64, r: ^Rand = nil) -> f64 { // Return values range from // 0 to positive infinity if lambda > 0 // negative infinity to 0 if lambda <= 0 +@(require_results) float32_exponential :: proc(lambda: f32, r: ^Rand = nil) -> f32 { return f32(float64_exponential(f64(lambda), r)) } @@ -87,6 +95,7 @@ float32_exponential :: proc(lambda: f32, r: ^Rand = nil) -> f32 { // math.gamma(alpha) * math.pow(beta, alpha) // // mean is alpha*beta, variance is math.pow(alpha*beta, 2) +@(require_results) float64_gamma :: proc(alpha, beta: f64, r: ^Rand = nil) -> f64 { if alpha <= 0 || beta <= 0 { panic(#procedure + ": alpha and beta must be > 0.0") @@ -152,6 +161,7 @@ float64_gamma :: proc(alpha, beta: f64, r: ^Rand = nil) -> f64 { // math.gamma(alpha) * math.pow(beta, alpha) // // mean is alpha*beta, variance is math.pow(alpha*beta, 2) +@(require_results) float32_gamma :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { return f32(float64_gamma(f64(alpha), f64(beta), r)) } @@ -162,6 +172,7 @@ float32_gamma :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { // Required: alpha > 0 and beta > 0 // // Return values range between 0 and 1 +@(require_results) float64_beta :: proc(alpha, beta: f64, r: ^Rand = nil) -> f64 { if alpha <= 0 || beta <= 0 { panic(#procedure + ": alpha and beta must be > 0.0") @@ -178,6 +189,7 @@ float64_beta :: proc(alpha, beta: f64, r: ^Rand = nil) -> f64 { // Required: alpha > 0 and beta > 0 // // Return values range between 0 and 1 +@(require_results) float32_beta :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { return f32(float64_beta(f64(alpha), f64(beta), r)) } @@ -185,22 +197,26 @@ float32_beta :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { // Pareto distribution, `alpha` is the shape parameter. // https://wikipedia.org/wiki/Pareto_distribution +@(require_results) float64_pareto :: proc(alpha: f64, r: ^Rand = nil) -> f64 { return math.pow(1 - float64(r), -1.0 / alpha) } // Pareto distribution, `alpha` is the shape parameter. // https://wikipedia.org/wiki/Pareto_distribution +@(require_results) float32_pareto :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { return f32(float64_pareto(f64(alpha), r)) } // Weibull distribution, `alpha` is the scale parameter, `beta` is the shape parameter. +@(require_results) float64_weibull :: proc(alpha, beta: f64, r: ^Rand = nil) -> f64 { u := 1 - float64(r) return alpha * math.pow(-math.ln(u), 1.0/beta) } // Weibull distribution, `alpha` is the scale parameter, `beta` is the shape parameter. +@(require_results) float32_weibull :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { return f32(float64_weibull(f64(alpha), f64(beta), r)) } @@ -210,6 +226,7 @@ float32_weibull :: proc(alpha, beta: f32, r: ^Rand = nil) -> f32 { // `mean_angle` is the in mean angle between 0 and 2pi radians // `kappa` is the concentration parameter which must be >= 0 // When `kappa` is zero, the Distribution is a uniform Distribution over the range 0 to 2pi +@(require_results) float64_von_mises :: proc(mean_angle, kappa: f64, r: ^Rand = nil) -> f64 { // Fisher, N.I., "Statistical Analysis of Circular Data", Cambridge University Press, 1993. @@ -245,6 +262,7 @@ float64_von_mises :: proc(mean_angle, kappa: f64, r: ^Rand = nil) -> f64 { // `mean_angle` is the in mean angle between 0 and 2pi radians // `kappa` is the concentration parameter which must be >= 0 // When `kappa` is zero, the Distribution is a uniform Distribution over the range 0 to 2pi +@(require_results) float32_von_mises :: proc(mean_angle, kappa: f32, r: ^Rand = nil) -> f32 { return f32(float64_von_mises(f64(mean_angle), f64(kappa), r)) } @@ -252,6 +270,7 @@ float32_von_mises :: proc(mean_angle, kappa: f32, r: ^Rand = nil) -> f32 { // Cauchy-Lorentz Distribution // `x_0` is the location, `gamma` is the scale where `gamma` > 0 +@(require_results) float64_cauchy_lorentz :: proc(x_0, gamma: f64, r: ^Rand = nil) -> f64 { assert(gamma > 0) @@ -261,6 +280,7 @@ float64_cauchy_lorentz :: proc(x_0, gamma: f64, r: ^Rand = nil) -> f64 { } // Cauchy-Lorentz Distribution // `x_0` is the location, `gamma` is the scale where `gamma` > 0 +@(require_results) float32_cauchy_lorentz :: proc(x_0, gamma: f32, r: ^Rand = nil) -> f32 { return f32(float64_cauchy_lorentz(f64(x_0), f64(gamma), r)) } @@ -268,12 +288,14 @@ float32_cauchy_lorentz :: proc(x_0, gamma: f32, r: ^Rand = nil) -> f32 { // Log Cauchy-Lorentz Distribution // `x_0` is the location, `gamma` is the scale where `gamma` > 0 +@(require_results) float64_log_cauchy_lorentz :: proc(x_0, gamma: f64, r: ^Rand = nil) -> f64 { assert(gamma > 0) return math.exp(math.tan(math.PI * (float64(r) - 0.5))*gamma + x_0) } // Log Cauchy-Lorentz Distribution // `x_0` is the location, `gamma` is the scale where `gamma` > 0 +@(require_results) float32_log_cauchy_lorentz :: proc(x_0, gamma: f32, r: ^Rand = nil) -> f32 { return f32(float64_log_cauchy_lorentz(f64(x_0), f64(gamma), r)) } @@ -281,6 +303,7 @@ float32_log_cauchy_lorentz :: proc(x_0, gamma: f32, r: ^Rand = nil) -> f32 { // Laplace Distribution // `b` is the scale where `b` > 0 +@(require_results) float64_laplace :: proc(mean, b: f64, r: ^Rand = nil) -> f64 { assert(b > 0) p := float64(r)-0.5 @@ -288,6 +311,7 @@ float64_laplace :: proc(mean, b: f64, r: ^Rand = nil) -> f64 { } // Laplace Distribution // `b` is the scale where `b` > 0 +@(require_results) float32_laplace :: proc(mean, b: f32, r: ^Rand = nil) -> f32 { return f32(float64_laplace(f64(mean), f64(b), r)) } @@ -296,6 +320,7 @@ float32_laplace :: proc(mean, b: f32, r: ^Rand = nil) -> f32 { // Gompertz Distribution // `eta` is the shape, `b` is the scale // Both `eta` and `b` must be > 0 +@(require_results) float64_gompertz :: proc(eta, b: f64, r: ^Rand = nil) -> f64 { if eta <= 0 || b <= 0 { panic(#procedure + ": eta and b must be > 0.0") @@ -307,6 +332,7 @@ float64_gompertz :: proc(eta, b: f64, r: ^Rand = nil) -> f64 { // Gompertz Distribution // `eta` is the shape, `b` is the scale // Both `eta` and `b` must be > 0 +@(require_results) float32_gompertz :: proc(eta, b: f32, r: ^Rand = nil) -> f32 { return f32(float64_gompertz(f64(eta), f64(b), r)) } diff --git a/core/math/rand/exp.odin b/core/math/rand/exp.odin index c0f92e99c..719debe75 100644 --- a/core/math/rand/exp.odin +++ b/core/math/rand/exp.odin @@ -15,6 +15,7 @@ import "core:math" // https://www.jstatsoft.org/index.php/jss/article/view/v005i08/ziggurat.pdf [pdf] // https://www.jstatsoft.org/article/view/v005i08 [web page] // +@(require_results) exp_float64 :: proc(r: ^Rand = nil) -> f64 { re :: 7.69711747013104972 diff --git a/core/math/rand/normal.odin b/core/math/rand/normal.odin index a9edd0f19..f96163fe9 100644 --- a/core/math/rand/normal.odin +++ b/core/math/rand/normal.odin @@ -17,6 +17,7 @@ import "core:math" // https://www.jstatsoft.org/index.php/jss/article/view/v005i08/ziggurat.pdf [pdf] // https://www.jstatsoft.org/article/view/v005i08 [web page] // +@(require_results) norm_float64 :: proc(r: ^Rand = nil) -> f64 { rn :: 3.442619855899 diff --git a/core/math/rand/rand.odin b/core/math/rand/rand.odin index 2d92d29ff..825aa7b87 100644 --- a/core/math/rand/rand.odin +++ b/core/math/rand/rand.odin @@ -16,6 +16,7 @@ set_global_seed :: proc(seed: u64) { init(&global_rand, seed) } +@(require_results) create :: proc(seed: u64) -> Rand { r: Rand init(&r, seed) @@ -60,14 +61,17 @@ _random :: proc(r: ^Rand) -> u32 { return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 31)) } +@(require_results) uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r) } +@(require_results) uint64 :: proc(r: ^Rand = nil) -> u64 { a := u64(_random(r)) b := u64(_random(r)) return (a<<32) | b } +@(require_results) uint128 :: proc(r: ^Rand = nil) -> u128 { a := u128(_random(r)) b := u128(_random(r)) @@ -76,10 +80,11 @@ uint128 :: proc(r: ^Rand = nil) -> u128 { return (a<<96) | (b<<64) | (c<<32) | d } -int31 :: proc(r: ^Rand = nil) -> i32 { return i32(uint32(r) << 1 >> 1) } -int63 :: proc(r: ^Rand = nil) -> i64 { return i64(uint64(r) << 1 >> 1) } -int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1) } +@(require_results) int31 :: proc(r: ^Rand = nil) -> i32 { return i32(uint32(r) << 1 >> 1) } +@(require_results) int63 :: proc(r: ^Rand = nil) -> i64 { return i64(uint64(r) << 1 >> 1) } +@(require_results) int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1) } +@(require_results) int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 { if n <= 0 { panic("Invalid argument to int31_max") @@ -95,6 +100,7 @@ int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 { return v % n } +@(require_results) int63_max :: proc(n: i64, r: ^Rand = nil) -> i64 { if n <= 0 { panic("Invalid argument to int63_max") @@ -110,6 +116,7 @@ int63_max :: proc(n: i64, r: ^Rand = nil) -> i64 { return v % n } +@(require_results) int127_max :: proc(n: i128, r: ^Rand = nil) -> i128 { if n <= 0 { panic("Invalid argument to int127_max") @@ -125,6 +132,7 @@ int127_max :: proc(n: i128, r: ^Rand = nil) -> i128 { return v % n } +@(require_results) int_max :: proc(n: int, r: ^Rand = nil) -> int { if n <= 0 { panic("Invalid argument to int_max") @@ -137,13 +145,14 @@ int_max :: proc(n: int, r: ^Rand = nil) -> int { } // Uniform random distribution [0, 1) -float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53) } +@(require_results) float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53) } // Uniform random distribution [0, 1) -float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)) } +@(require_results) float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)) } -float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo } -float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo } +@(require_results) float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo } +@(require_results) float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo } +@(require_results) read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) { pos := i8(0) val := i64(0) @@ -160,6 +169,7 @@ read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) { } // perm returns a slice of n ints in a pseudo-random permutation of integers in the range [0, n) +@(require_results) perm :: proc(n: int, r: ^Rand = nil, allocator := context.allocator) -> []int { m := make([]int, n, allocator) for i := 0; i < n; i += 1 { @@ -184,6 +194,7 @@ shuffle :: proc(array: $T/[]$E, r: ^Rand = nil) { } // Returns a random element from the given slice +@(require_results) choice :: proc(array: $T/[]$E, r: ^Rand = nil) -> (res: E) { n := i64(len(array)) if n < 1 { diff --git a/core/math/rand/system_darwin.odin b/core/math/rand/system_darwin.odin index f51e4473e..a2890d1b4 100644 --- a/core/math/rand/system_darwin.odin +++ b/core/math/rand/system_darwin.odin @@ -2,6 +2,7 @@ package rand import "core:sys/darwin" +@(require_results) _system_random :: proc() -> u32 { for { value: u32 diff --git a/core/math/rand/system_linux.odin b/core/math/rand/system_linux.odin index bfdc8872b..0e34228dc 100644 --- a/core/math/rand/system_linux.odin +++ b/core/math/rand/system_linux.odin @@ -2,6 +2,7 @@ package rand import "core:sys/unix" +@(require_results) _system_random :: proc() -> u32 { for { value: u32 diff --git a/core/math/rand/system_windows.odin b/core/math/rand/system_windows.odin index ee9cd0294..b6af9e6a4 100644 --- a/core/math/rand/system_windows.odin +++ b/core/math/rand/system_windows.odin @@ -2,6 +2,7 @@ package rand import win32 "core:sys/windows" +@(require_results) _system_random :: proc() -> u32 { value: u32 status := win32.BCryptGenRandom(nil, ([^]u8)(&value), 4, win32.BCRYPT_USE_SYSTEM_PREFERRED_RNG) From 89a233ccd2d4b41c18662d2652f3200507e489e2 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:00:17 +0100 Subject: [PATCH 046/108] Add `@(require_results)` to `core:math/noise` --- core/math/noise/opensimplex2.odin | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/core/math/noise/opensimplex2.odin b/core/math/noise/opensimplex2.odin index d90dafdf5..d28356f2c 100644 --- a/core/math/noise/opensimplex2.odin +++ b/core/math/noise/opensimplex2.odin @@ -20,6 +20,7 @@ Vec4 :: [4]f64 /* 2D Simplex noise, standard lattice orientation. */ +@(require_results) noise_2d :: proc(seed: i64, coord: Vec2) -> (value: f32) { // Get points for A2* lattice skew := SKEW_2D * (coord.x + coord.y) @@ -35,6 +36,7 @@ noise_2d :: proc(seed: i64, coord: Vec2) -> (value: f32) { unless your map is centered around an equator. It's a subtle difference, but the option is here to make it an easy choice. */ +@(require_results) noise_2d_improve_x :: proc(seed: i64, coord: Vec2) -> (value: f32) { // Skew transform and rotation baked into one. xx := coord.x * ROOT_2_OVER_2 @@ -51,6 +53,7 @@ noise_2d_improve_x :: proc(seed: i64, coord: Vec2) -> (value: f32) { If Z is vertical in world coordinates, call `noise_3d_improve_xz(x, y, Z)`. For a time varied animation, call `noise_3d_improve_xz(x, y, T)`. */ +@(require_results) noise_3d_improve_xy :: proc(seed: i64, coord: Vec3) -> (value: f32) { /* Re-orient the cubic lattices without skewing, so Z points up the main lattice diagonal, @@ -75,6 +78,7 @@ noise_3d_improve_xy :: proc(seed: i64, coord: Vec3) -> (value: f32) { If Z is vertical in world coordinates, call `noise_3d_improve_xz(x, Z, y)` or use `noise_3d_improve_xy`. For a time varied animation, call `noise_3d_improve_xz(x, T, y)` or use `noise_3d_improve_xy`. */ +@(require_results) noise_3d_improve_xz :: proc(seed: i64, coord: Vec3) -> (value: f32) { /* Re-orient the cubic lattices without skewing, so Y points up the main lattice diagonal, @@ -96,6 +100,7 @@ noise_3d_improve_xz :: proc(seed: i64, coord: Vec3) -> (value: f32) { Use `noise_3d_improve_xy` or `noise_3d_improve_xz` instead, wherever appropriate. They have less diagonal bias. This function's best use is as a fallback. */ +@(require_results) noise_3d_fallback :: proc(seed: i64, coord: Vec3) -> (value: f32) { /* Re-orient the cubic lattices via rotation, to produce a familiar look. @@ -114,6 +119,7 @@ noise_3d_fallback :: proc(seed: i64, coord: Vec3) -> (value: f32) { Recommended for time-varied animations which texture a 3D object (W=time) in a space where Z is vertical. */ +@(require_results) noise_4d_improve_xyz_improve_xy :: proc(seed: i64, coord: Vec4) -> (value: f32) { xy := coord.x + coord.y s2 := xy * -0.21132486540518699998 @@ -133,6 +139,7 @@ noise_4d_improve_xyz_improve_xy :: proc(seed: i64, coord: Vec4) -> (value: f32) Recommended for time-varied animations which texture a 3D object (W=time) in a space where Y is vertical. */ +@(require_results) noise_4d_improve_xyz_improve_xz :: proc(seed: i64, coord: Vec4) -> (value: f32) { xz := coord.x + coord.z s2 := xz * -0.21132486540518699998 @@ -152,6 +159,7 @@ noise_4d_improve_xyz_improve_xz :: proc(seed: i64, coord: Vec4) -> (value: f32) Recommended for time-varied animations which texture a 3D object (W=time) where there isn't a clear distinction between horizontal and vertical */ +@(require_results) noise_4d_improve_xyz :: proc(seed: i64, coord: Vec4) -> (value: f32) { xyz := coord.x + coord.y + coord.z ww := coord.w * 0.2236067977499788 @@ -164,6 +172,7 @@ noise_4d_improve_xyz :: proc(seed: i64, coord: Vec4) -> (value: f32) { /* 4D OpenSimplex2 noise, fallback lattice orientation. */ +@(require_results) noise_4d_fallback :: proc(seed: i64, coord: Vec4) -> (value: f32) { // Get points for A4 lattice skew := f64(SKEW_4D) * (coord.x + coord.y + coord.z + coord.w) From 74ce99e0d758753f255c36d1df564e88347dd712 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:05:56 +0100 Subject: [PATCH 047/108] Add `@(require_results)` `core:math/linalg` procedures --- core/math/linalg/extended.odin | 71 ++++++- core/math/linalg/general.odin | 74 +++++-- core/math/linalg/specific.odin | 185 ++++++++++++++++++ .../linalg/specific_euler_angles_f16.odin | 100 ++++++++++ .../linalg/specific_euler_angles_f32.odin | 100 ++++++++++ .../linalg/specific_euler_angles_f64.odin | 100 ++++++++++ core/math/linalg/swizzle.odin | 32 +++ 7 files changed, 638 insertions(+), 24 deletions(-) diff --git a/core/math/linalg/extended.odin b/core/math/linalg/extended.odin index 22368b70c..f0be35aa1 100644 --- a/core/math/linalg/extended.odin +++ b/core/math/linalg/extended.odin @@ -3,6 +3,7 @@ package linalg import "core:builtin" import "core:math" +@(require_results) to_radians :: proc(degrees: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) to_degrees :: proc(radians: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) min_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -56,12 +60,14 @@ min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) return } +@(require_results) min_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return min_double(a, min_double(b, c)) } min :: proc{min_single, min_double, min_triple} +@(require_results) max_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -95,12 +102,14 @@ max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) return } +@(require_results) max_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return max_double(a, max_double(b, c)) } max :: proc{max_single, max_double, max_triple} +@(require_results) abs :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) sign :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) clamp :: proc(x, a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } +@(require_results) saturate :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return clamp(x, 0.0, 1.0) } +@(require_results) lerp :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } return } +@(require_results) mix :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) unlerp :: proc(a, b, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return (x - a) / (b - a) } +@(require_results) step :: proc(e, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) smoothstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * (3.0 - 2.0 * t) } +@(require_results) smootherstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * t * (t * (6*t - 15) + 10) } +@(require_results) sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) inverse_sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) cos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) sin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) tan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) acos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) asin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) atan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } return } +@(require_results) atan2 :: proc(y, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } +@(require_results) ln :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log :: proc(x, b: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) pow :: proc(x, e: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } +@(require_results) ceil :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) floor :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) round :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) fract :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x) return x - f } +@(require_results) mod :: proc(x, m: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x / m) return x - f * m } +@(require_results) face_forward :: proc(N, I, N_ref: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { return dot(N_ref, I) < 0 ? N : -N } +@(require_results) distance :: proc(p0, p1: $V/[$N]$E) -> E where IS_NUMERIC(E) { return length(p1 - p0) } +@(require_results) reflect :: proc(I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { b := N * (2 * dot(N, I)) return I - b } +@(require_results) refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_FLOAT(ELEM_TYPE(V)) { dv := dot(Normal, I) k := 1 - eta*eta * (1 - dv*dv) @@ -441,10 +485,12 @@ refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_ +@(require_results) is_nan_single :: proc(x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_nan(x) } +@(require_results) is_nan_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { return } +@(require_results) is_inf_single :: proc(x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_inf(x) } +@(require_results) is_inf_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { return } +@(require_results) classify_single :: proc(x: $T) -> math.Float_Class where IS_FLOAT(T) { return #force_inline math.classify(x) } +@(require_results) classify_array :: proc(x: $A/[$N]$T) -> (out: [N]math.Float_Class) where IS_FLOAT(T) { for i in 0.. (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } -less_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } -greater_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } -greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } -equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } -not_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } +@(require_results) less_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } +@(require_results) less_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } +@(require_results) greater_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } +@(require_results) greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } +@(require_results) equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } +@(require_results) not_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } +@(require_results) less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. y[i] } return } +@(require_results) greater_than_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0..= y[i] } return } +@(require_results) equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: bool) { for e in x { if e { @@ -538,6 +595,7 @@ any :: proc(x: $A/[$N]bool) -> (out: bool) { } return false } +@(require_results) all :: proc(x: $A/[$N]bool) -> (out: bool) { for e in x { if !e { @@ -546,6 +604,7 @@ all :: proc(x: $A/[$N]bool) -> (out: bool) { } return true } +@(require_results) not :: proc(x: $A/[$N]bool) -> (out: A) { for e, i in x { out[i] = !e diff --git a/core/math/linalg/general.odin b/core/math/linalg/general.odin index c11151b25..dca3cf5d5 100644 --- a/core/math/linalg/general.odin +++ b/core/math/linalg/general.odin @@ -38,22 +38,27 @@ DEG_PER_RAD :: 360.0/TAU @private ELEM_TYPE :: intrinsics.type_elem_type +@(require_results) scalar_dot :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } +@(require_results) vector_dot :: proc(a, b: $T/[$N]$E) -> (c: E) where IS_NUMERIC(E) #no_bounds_check { for i in 0.. (c: f16) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) quaternion128_dot :: proc(a, b: $T/quaternion128) -> (c: f32) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) quaternion256_dot :: proc(a, b: $T/quaternion256) -> (c: f64) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } @@ -63,19 +68,23 @@ dot :: proc{scalar_dot, vector_dot, quaternion64_dot, quaternion128_dot, quatern inner_product :: dot outer_product :: builtin.outer_product +@(require_results) quaternion_inverse :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return conj(q) * quaternion(1.0/dot(q, q), 0, 0, 0) } +@(require_results) scalar_cross :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } +@(require_results) vector_cross2 :: proc(a, b: $T/[2]$E) -> E where IS_NUMERIC(E) { return a[0]*b[1] - b[0]*a[1] } +@(require_results) vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { c[0] = a[1]*b[2] - b[1]*a[2] c[1] = a[2]*b[0] - b[2]*a[0] @@ -83,6 +92,7 @@ vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { return } +@(require_results) quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { q3.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y q3.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z @@ -94,18 +104,22 @@ quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { vector_cross :: proc{scalar_cross, vector_cross2, vector_cross3} cross :: proc{scalar_cross, vector_cross2, vector_cross3, quaternion_cross} +@(require_results) vector_normalize :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { return v / length(v) } +@(require_results) quaternion_normalize :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return q/abs(q) } normalize :: proc{vector_normalize, quaternion_normalize} +@(require_results) vector_normalize0 :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { m := length(v) return 0 if m == 0 else v/m } +@(require_results) quaternion_normalize0 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { m := abs(q) return 0 if m == 0 else q/m @@ -113,22 +127,27 @@ quaternion_normalize0 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { normalize0 :: proc{vector_normalize0, quaternion_normalize0} +@(require_results) vector_length :: proc(v: $T/[$N]$E) -> E where IS_FLOAT(E) { return math.sqrt(dot(v, v)) } +@(require_results) vector_length2 :: proc(v: $T/[$N]$E) -> E where IS_NUMERIC(E) { return dot(v, v) } +@(require_results) quaternion_length :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return abs(q) } +@(require_results) quaternion_length2 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return dot(q, q) } +@(require_results) scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { // a . (b x c) // b . (c x a) @@ -136,6 +155,7 @@ scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { return dot(a, cross(b, c)) } +@(require_results) vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { // a x (b x c) // (a . c)b - (a . b)c @@ -146,10 +166,12 @@ vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { length :: proc{vector_length, quaternion_length} length2 :: proc{vector_length2, quaternion_length2} +@(require_results) projection :: proc(x, normal: $T/[$N]$E) -> T where IS_NUMERIC(E) { return dot(x, normal) / dot(normal, normal) * normal } +@(require_results) identity :: proc($T: typeid/[$N][N]$E) -> (m: T) #no_bounds_check { for i in 0.. (m: T) #no_bounds_check { trace :: builtin.matrix_trace transpose :: builtin.transpose +@(require_results) matrix_mul :: proc(a, b: $M/matrix[$N, N]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } +@(require_results) matrix_comp_mul :: proc(a, b: $M/matrix[$I, $J]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return hadamard_product(a, b) } +@(require_results) matrix_mul_differ :: proc(a: $A/matrix[$I, $J]$E, b: $B/matrix[J, $K]E) -> (c: matrix[I, K]E) where !IS_ARRAY(E), IS_NUMERIC(E), I != K #no_bounds_check { return a * b } +@(require_results) matrix_mul_vector :: proc(a: $A/matrix[$I, $J]$E, b: $B/[J]E) -> (c: B) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } +@(require_results) quaternion_mul_quaternion :: proc(q1, q2: $Q) -> Q where IS_QUATERNION(Q) { return q1 * q2 } +@(require_results) quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { Raw_Quaternion :: struct {xyz: [3]f16, r: f16} @@ -194,6 +222,7 @@ quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { t := cross(2*q.xyz, v) return V(v + q.r*t + cross(q.xyz, t)) } +@(require_results) quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { Raw_Quaternion :: struct {xyz: [3]f32, r: f32} @@ -203,6 +232,7 @@ quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { t := cross(2*q.xyz, v) return V(v + q.r*t + cross(q.xyz, t)) } +@(require_results) quaternion256_mul_vector3 :: proc(q: $Q/quaternion256, v: $V/[3]$F/f64) -> V { Raw_Quaternion :: struct {xyz: [3]f64, r: f64} @@ -224,9 +254,11 @@ mul :: proc{ quaternion_mul_quaternion, } +@(require_results) vector_to_ptr :: proc(v: ^$V/[$N]$E) -> ^E where IS_NUMERIC(E), N > 0 #no_bounds_check { return &v[0] } +@(require_results) matrix_to_ptr :: proc(m: ^$A/matrix[$I, $J]$E) -> ^E where IS_NUMERIC(E), I > 0, J > 0 #no_bounds_check { return &m[0, 0] } @@ -239,6 +271,7 @@ to_ptr :: proc{vector_to_ptr, matrix_to_ptr} // Splines +@(require_results) vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { cos_alpha := dot(x, y) alpha := math.acos(cos_alpha) @@ -250,6 +283,7 @@ vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { return x * t1 + y * t2 } +@(require_results) catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -262,6 +296,7 @@ catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) * 0.5 } +@(require_results) hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -274,12 +309,14 @@ hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2 } +@(require_results) cubic :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { return ((v1 * s + v2) * s + v3) * s + v4 } +@(require_results) array_cast :: proc(v: $A/[$N]$T, $Elem_Type: typeid) -> (w: [N]Elem_Type) #no_bounds_check { for i in 0.. (w: [N]Elem_Type) #no_bo return } +@(require_results) matrix_cast :: proc(v: $A/matrix[$M, $N]$T, $Elem_Type: typeid) -> (w: matrix[M, N]Elem_Type) #no_bounds_check { for j in 0.. (w: matrix[M, return } -to_f32 :: #force_inline proc(v: $A/[$N]$T) -> [N]f32 { return array_cast(v, f32) } -to_f64 :: #force_inline proc(v: $A/[$N]$T) -> [N]f64 { return array_cast(v, f64) } +@(require_results) to_f32 :: #force_inline proc(v: $A/[$N]$T) -> [N]f32 { return array_cast(v, f32) } +@(require_results) to_f64 :: #force_inline proc(v: $A/[$N]$T) -> [N]f64 { return array_cast(v, f64) } -to_i8 :: #force_inline proc(v: $A/[$N]$T) -> [N]i8 { return array_cast(v, i8) } -to_i16 :: #force_inline proc(v: $A/[$N]$T) -> [N]i16 { return array_cast(v, i16) } -to_i32 :: #force_inline proc(v: $A/[$N]$T) -> [N]i32 { return array_cast(v, i32) } -to_i64 :: #force_inline proc(v: $A/[$N]$T) -> [N]i64 { return array_cast(v, i64) } -to_int :: #force_inline proc(v: $A/[$N]$T) -> [N]int { return array_cast(v, int) } +@(require_results) to_i8 :: #force_inline proc(v: $A/[$N]$T) -> [N]i8 { return array_cast(v, i8) } +@(require_results) to_i16 :: #force_inline proc(v: $A/[$N]$T) -> [N]i16 { return array_cast(v, i16) } +@(require_results) to_i32 :: #force_inline proc(v: $A/[$N]$T) -> [N]i32 { return array_cast(v, i32) } +@(require_results) to_i64 :: #force_inline proc(v: $A/[$N]$T) -> [N]i64 { return array_cast(v, i64) } +@(require_results) to_int :: #force_inline proc(v: $A/[$N]$T) -> [N]int { return array_cast(v, int) } -to_u8 :: #force_inline proc(v: $A/[$N]$T) -> [N]u8 { return array_cast(v, u8) } -to_u16 :: #force_inline proc(v: $A/[$N]$T) -> [N]u16 { return array_cast(v, u16) } -to_u32 :: #force_inline proc(v: $A/[$N]$T) -> [N]u32 { return array_cast(v, u32) } -to_u64 :: #force_inline proc(v: $A/[$N]$T) -> [N]u64 { return array_cast(v, u64) } -to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint) } +@(require_results) to_u8 :: #force_inline proc(v: $A/[$N]$T) -> [N]u8 { return array_cast(v, u8) } +@(require_results) to_u16 :: #force_inline proc(v: $A/[$N]$T) -> [N]u16 { return array_cast(v, u16) } +@(require_results) to_u32 :: #force_inline proc(v: $A/[$N]$T) -> [N]u32 { return array_cast(v, u32) } +@(require_results) to_u64 :: #force_inline proc(v: $A/[$N]$T) -> [N]u64 { return array_cast(v, u64) } +@(require_results) to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint) } -to_complex32 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32 { return array_cast(v, complex32) } -to_complex64 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64 { return array_cast(v, complex64) } -to_complex128 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128 { return array_cast(v, complex128) } -to_quaternion64 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) } -to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) } -to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) } +@(require_results) to_complex32 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32 { return array_cast(v, complex32) } +@(require_results) to_complex64 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64 { return array_cast(v, complex64) } +@(require_results) to_complex128 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128 { return array_cast(v, complex128) } +@(require_results) to_quaternion64 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) } +@(require_results) to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) } +@(require_results) to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) } diff --git a/core/math/linalg/specific.odin b/core/math/linalg/specific.odin index c4ecb194f..e4ebe76da 100644 --- a/core/math/linalg/specific.odin +++ b/core/math/linalg/specific.odin @@ -130,10 +130,12 @@ VECTOR3F64_Y_AXIS :: Vector3f64{0, 1, 0} VECTOR3F64_Z_AXIS :: Vector3f64{0, 0, 1} +@(require_results) vector2_orthogonal :: proc(v: $V/[2]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { return {-v.y, v.x} } +@(require_results) vector3_orthogonal :: proc(v: $V/[3]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { x := abs(v.x) y := abs(v.y) @@ -160,6 +162,7 @@ orthogonal :: proc{vector2_orthogonal, vector3_orthogonal} +@(require_results) vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -167,6 +170,7 @@ vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { a := col.w return {r, g, b, a} } +@(require_results) vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -174,6 +178,7 @@ vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { a := col.w return {r, g, b, a} } +@(require_results) vector4_srgb_to_linear_f64 :: proc(col: Vector4f64) -> Vector4f64 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -188,6 +193,7 @@ vector4_srgb_to_linear :: proc{ } +@(require_results) vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { a :: 2.51 b :: 0.03 @@ -209,6 +215,7 @@ vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {x, y, z, col.w} } +@(require_results) vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { a :: 2.51 b :: 0.03 @@ -230,6 +237,7 @@ vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {x, y, z, col.w} } +@(require_results) vector4_linear_to_srgb_f64 :: proc(col: Vector4f64) -> Vector4f64 { a :: 2.51 b :: 0.03 @@ -258,7 +266,9 @@ vector4_linear_to_srgb :: proc{ } +@(require_results) vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { + @(require_results) hue_to_rgb :: proc(p, q, t: f16) -> f16 { t := t if t < 0 { t += 1 } @@ -285,7 +295,9 @@ vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { } return {r, g, b, a} } +@(require_results) vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { + @(require_results) hue_to_rgb :: proc(p, q, t: f32) -> f32 { t := t if t < 0 { t += 1 } @@ -312,7 +324,9 @@ vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { } return {r, g, b, a} } +@(require_results) vector4_hsl_to_rgb_f64 :: proc(h, s, l: f64, a: f64 = 1) -> Vector4f64 { + @(require_results) hue_to_rgb :: proc(p, q, t: f64) -> f64 { t := t if t < 0 { t += 1 } @@ -346,6 +360,7 @@ vector4_hsl_to_rgb :: proc{ } +@(require_results) vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { r := col.x g := col.y @@ -375,6 +390,7 @@ vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {h, s, l, a} } +@(require_results) vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { r := col.x g := col.y @@ -404,6 +420,7 @@ vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {h, s, l, a} } +@(require_results) vector4_rgb_to_hsl_f64 :: proc(col: Vector4f64) -> Vector4f64 { r := col.x g := col.y @@ -441,6 +458,7 @@ vector4_rgb_to_hsl :: proc{ +@(require_results) quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -450,6 +468,7 @@ quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Q q.w = math.cos(t) return } +@(require_results) quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -459,6 +478,7 @@ quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Q q.w = math.cos(t) return } +@(require_results) quaternion_angle_axis_f64 :: proc(angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -474,6 +494,7 @@ quaternion_angle_axis :: proc{ quaternion_angle_axis_f64, } +@(require_results) angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -481,6 +502,7 @@ angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.acos(q.w) * 2 } +@(require_results) angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -488,6 +510,7 @@ angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.acos(q.w) * 2 } +@(require_results) angle_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -501,6 +524,7 @@ angle_from_quaternion :: proc{ angle_from_quaternion_f64, } +@(require_results) axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -509,6 +533,7 @@ axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { t2 := 1.0 / math.sqrt(t1) return {q.x*t2, q.y*t2, q.z*t2} } +@(require_results) axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -517,6 +542,7 @@ axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { t2 := 1.0 / math.sqrt(t1) return {q.x*t2, q.y*t2, q.z*t2} } +@(require_results) axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> Vector3f64 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -532,16 +558,19 @@ axis_from_quaternion :: proc{ } +@(require_results) angle_axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> (angle: f16, axis: Vector3f16) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } +@(require_results) angle_axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> (angle: f32, axis: Vector3f32) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } +@(require_results) angle_axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> (angle: f64, axis: Vector3f64) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) @@ -554,6 +583,7 @@ angle_axis_from_quaternion :: proc { } +@(require_results) quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternionf16 { f := normalize(forward) s := normalize(cross(f, up)) @@ -597,6 +627,7 @@ quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternio return normalize(q) } +@(require_results) quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternionf32 { f := normalize(forward) s := normalize(cross(f, up)) @@ -640,6 +671,7 @@ quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternio return normalize(q) } +@(require_results) quaternion_from_forward_and_up_f64 :: proc(forward, up: Vector3f64) -> Quaternionf64 { f := normalize(forward) s := normalize(cross(f, up)) @@ -689,12 +721,15 @@ quaternion_from_forward_and_up :: proc{ quaternion_from_forward_and_up_f64, } +@(require_results) quaternion_look_at_f16 :: proc(eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } +@(require_results) quaternion_look_at_f32 :: proc(eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } +@(require_results) quaternion_look_at_f64 :: proc(eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } @@ -706,6 +741,7 @@ quaternion_look_at :: proc{ +@(require_results) quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -713,6 +749,7 @@ quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) c.w = a.w + (b.w-a.w)*t return normalize(c) } +@(require_results) quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -720,6 +757,7 @@ quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) c.w = a.w + (b.w-a.w)*t return normalize(c) } +@(require_results) quaternion_nlerp_f64 :: proc(a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -734,6 +772,7 @@ quaternion_nlerp :: proc{ } +@(require_results) quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) { a, b := x, y cos_angle := dot(a, b) @@ -761,6 +800,7 @@ quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) { a, b := x, y cos_angle := dot(a, b) @@ -788,6 +828,7 @@ quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quaternion_slerp_f64 :: proc(x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) { a, b := x, y cos_angle := dot(a, b) @@ -822,14 +863,17 @@ quaternion_slerp :: proc{ } +@(require_results) quaternion_squad_f16 :: proc(q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } +@(require_results) quaternion_squad_f32 :: proc(q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } +@(require_results) quaternion_squad_f64 :: proc(q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) @@ -841,6 +885,7 @@ quaternion_squad :: proc{ } +@(require_results) quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { m3: Matrix3f16 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -848,6 +893,7 @@ quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { m3[0, 2], m3[1, 2], m3[2, 2] = m[0, 2], m[1, 2], m[2, 2] return quaternion_from_matrix3(m3) } +@(require_results) quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { m3: Matrix3f32 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -855,6 +901,7 @@ quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { m3[0, 2], m3[1, 2], m3[2, 2] = m[0, 2], m[1, 2], m[2, 2] return quaternion_from_matrix3(m3) } +@(require_results) quaternion_from_matrix4_f64 :: proc(m: Matrix4f64) -> (q: Quaternionf64) { m3: Matrix3f64 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -869,6 +916,7 @@ quaternion_from_matrix4 :: proc{ } +@(require_results) quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -918,6 +966,7 @@ quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { } return } +@(require_results) quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -967,6 +1016,7 @@ quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { } return } +@(require_results) quaternion_from_matrix3_f64 :: proc(m: Matrix3f64) -> (q: Quaternionf64) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1023,6 +1073,7 @@ quaternion_from_matrix3 :: proc{ } +@(require_results) quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaternionf16) { x := normalize(from) y := normalize(to) @@ -1044,6 +1095,7 @@ quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaterni q.z = v.z return normalize(q) } +@(require_results) quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaternionf32) { x := normalize(from) y := normalize(to) @@ -1065,6 +1117,7 @@ quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaterni q.z = v.z return normalize(q) } +@(require_results) quaternion_between_two_vector3_f64 :: proc(from, to: Vector3f64) -> (q: Quaternionf64) { x := normalize(from) y := normalize(to) @@ -1093,6 +1146,7 @@ quaternion_between_two_vector3 :: proc{ } +@(require_results) matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1102,6 +1156,7 @@ matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1111,6 +1166,7 @@ matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_transpose_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1127,12 +1183,15 @@ matrix2_inverse_transpose :: proc{ } +@(require_results) matrix2_determinant_f16 :: proc(m: Matrix2f16) -> f16 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } +@(require_results) matrix2_determinant_f32 :: proc(m: Matrix2f32) -> f32 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } +@(require_results) matrix2_determinant_f64 :: proc(m: Matrix2f64) -> f64 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } @@ -1143,6 +1202,7 @@ matrix2_determinant :: proc{ } +@(require_results) matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1152,6 +1212,7 @@ matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1161,6 +1222,7 @@ matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1177,6 +1239,7 @@ matrix2_inverse :: proc{ } +@(require_results) matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1184,6 +1247,7 @@ matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] return c } +@(require_results) matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1191,6 +1255,7 @@ matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] return c } +@(require_results) matrix2_adjoint_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1205,6 +1270,7 @@ matrix2_adjoint :: proc{ } +@(require_results) matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { qxx := q.x * q.x qyy := q.y * q.y @@ -1229,6 +1295,7 @@ matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { m[2, 2] = 1 - 2 * (qxx + qyy) return m } +@(require_results) matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { qxx := q.x * q.x qyy := q.y * q.y @@ -1253,6 +1320,7 @@ matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { m[2, 2] = 1 - 2 * (qxx + qyy) return m } +@(require_results) matrix3_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix3f64) { qxx := q.x * q.x qyy := q.y * q.y @@ -1284,12 +1352,15 @@ matrix3_from_quaternion :: proc{ } +@(require_results) matrix3_inverse_f16 :: proc(m: Matrix3f16) -> Matrix3f16 { return transpose(matrix3_inverse_transpose(m)) } +@(require_results) matrix3_inverse_f32 :: proc(m: Matrix3f32) -> Matrix3f32 { return transpose(matrix3_inverse_transpose(m)) } +@(require_results) matrix3_inverse_f64 :: proc(m: Matrix3f64) -> Matrix3f64 { return transpose(matrix3_inverse_transpose(m)) } @@ -1300,18 +1371,21 @@ matrix3_inverse :: proc{ } +@(require_results) matrix3_determinant_f16 :: proc(m: Matrix3f16) -> f16 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } +@(require_results) matrix3_determinant_f32 :: proc(m: Matrix3f32) -> f32 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } +@(require_results) matrix3_determinant_f64 :: proc(m: Matrix3f64) -> f64 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) @@ -1325,6 +1399,7 @@ matrix3_determinant :: proc{ } +@(require_results) matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1337,6 +1412,7 @@ matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { adjoint[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) return adjoint } +@(require_results) matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1349,6 +1425,7 @@ matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { adjoint[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) return adjoint } +@(require_results) matrix3_adjoint_f64 :: proc(m: Matrix3f64) -> (adjoint: Matrix3f64) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1369,12 +1446,15 @@ matrix3_adjoint :: proc{ +@(require_results) matrix3_inverse_transpose_f16 :: proc(m: Matrix3f16) -> (inverse_transpose: Matrix3f16) { return builtin.inverse_transpose(m) } +@(require_results) matrix3_inverse_transpose_f32 :: proc(m: Matrix3f32) -> (inverse_transpose: Matrix3f32) { return builtin.inverse_transpose(m) } +@(require_results) matrix3_inverse_transpose_f64 :: proc(m: Matrix3f64) -> (inverse_transpose: Matrix3f64) { return builtin.inverse_transpose(m) } @@ -1385,18 +1465,21 @@ matrix3_inverse_transpose :: proc{ } +@(require_results) matrix3_scale_f16 :: proc(s: Vector3f16) -> (m: Matrix3f16) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } +@(require_results) matrix3_scale_f32 :: proc(s: Vector3f32) -> (m: Matrix3f32) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } +@(require_results) matrix3_scale_f64 :: proc(s: Vector3f64) -> (m: Matrix3f64) { m[0, 0] = s[0] m[1, 1] = s[1] @@ -1410,6 +1493,7 @@ matrix3_scale :: proc{ } +@(require_results) matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f16) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1431,6 +1515,7 @@ matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f1 return rot } +@(require_results) matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f32) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1452,6 +1537,7 @@ matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f3 return rot } +@(require_results) matrix3_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> (rot: Matrix3f64) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1480,6 +1566,7 @@ matrix3_rotate :: proc{ } +@(require_results) matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1490,6 +1577,7 @@ matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { -f.x, -f.y, -f.z, } } +@(require_results) matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1500,6 +1588,7 @@ matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { -f.x, -f.y, -f.z, } } +@(require_results) matrix3_look_at_f64 :: proc(eye, centre, up: Vector3f64) -> Matrix3f64 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1517,6 +1606,7 @@ matrix3_look_at :: proc{ } +@(require_results) matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { qxx := q.x * q.x qyy := q.y * q.y @@ -1544,6 +1634,7 @@ matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { return m } +@(require_results) matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { qxx := q.x * q.x qyy := q.y * q.y @@ -1571,6 +1662,7 @@ matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { return m } +@(require_results) matrix4_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix4f64) { qxx := q.x * q.x qyy := q.y * q.y @@ -1605,18 +1697,21 @@ matrix4_from_quaternion :: proc{ } +@(require_results) matrix4_from_trs_f16 :: proc(t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4f16 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } +@(require_results) matrix4_from_trs_f32 :: proc(t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4f32 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } +@(require_results) matrix4_from_trs_f64 :: proc(t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4f64 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) @@ -1631,12 +1726,15 @@ matrix4_from_trs :: proc{ +@(require_results) matrix4_inverse_f16 :: proc(m: Matrix4f16) -> Matrix4f16 { return transpose(matrix4_inverse_transpose(m)) } +@(require_results) matrix4_inverse_f32 :: proc(m: Matrix4f32) -> Matrix4f32 { return transpose(matrix4_inverse_transpose(m)) } +@(require_results) matrix4_inverse_f64 :: proc(m: Matrix4f64) -> Matrix4f64 { return transpose(matrix4_inverse_transpose(m)) } @@ -1647,6 +1745,7 @@ matrix4_inverse :: proc{ } +@(require_results) matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { cut_down: Matrix3f16 for i in 0..<3 { @@ -1658,6 +1757,7 @@ matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { } return matrix3_determinant(cut_down) } +@(require_results) matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { cut_down: Matrix3f32 for i in 0..<3 { @@ -1669,6 +1769,7 @@ matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { } return matrix3_determinant(cut_down) } +@(require_results) matrix4_minor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { cut_down: Matrix3f64 for i in 0..<3 { @@ -1687,18 +1788,21 @@ matrix4_minor :: proc{ } +@(require_results) matrix4_cofactor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { sign, minor: f16 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } +@(require_results) matrix4_cofactor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { sign, minor: f32 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } +@(require_results) matrix4_cofactor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { sign, minor: f64 sign = 1 if (c + r) % 2 == 0 else -1 @@ -1712,6 +1816,7 @@ matrix4_cofactor :: proc{ } +@(require_results) matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { for i in 0..<4 { for j in 0..<4 { @@ -1720,6 +1825,7 @@ matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { } return } +@(require_results) matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { for i in 0..<4 { for j in 0..<4 { @@ -1728,6 +1834,7 @@ matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { } return } +@(require_results) matrix4_adjoint_f64 :: proc(m: Matrix4f64) -> (adjoint: Matrix4f64) { for i in 0..<4 { for j in 0..<4 { @@ -1743,6 +1850,7 @@ matrix4_adjoint :: proc{ } +@(require_results) matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1750,6 +1858,7 @@ matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { } return } +@(require_results) matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1757,6 +1866,7 @@ matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { } return } +@(require_results) matrix4_determinant_f64 :: proc(m: Matrix4f64) -> (determinant: f64) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1771,6 +1881,7 @@ matrix4_determinant :: proc{ } +@(require_results) matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matrix4f16) { adjoint := matrix4_adjoint(m) determinant: f16 = 0 @@ -1785,6 +1896,7 @@ matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matr } return } +@(require_results) matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matrix4f32) { adjoint := matrix4_adjoint(m) determinant: f32 = 0 @@ -1799,6 +1911,7 @@ matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matr } return } +@(require_results) matrix4_inverse_transpose_f64 :: proc(m: Matrix4f64) -> (inverse_transpose: Matrix4f64) { adjoint := matrix4_adjoint(m) determinant: f64 = 0 @@ -1820,6 +1933,7 @@ matrix4_inverse_transpose :: proc{ } +@(require_results) matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { m := MATRIX4F16_IDENTITY m[3][0] = v[0] @@ -1827,6 +1941,7 @@ matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { m[3][2] = v[2] return m } +@(require_results) matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { m := MATRIX4F32_IDENTITY m[3][0] = v[0] @@ -1834,6 +1949,7 @@ matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { m[3][2] = v[2] return m } +@(require_results) matrix4_translate_f64 :: proc(v: Vector3f64) -> Matrix4f64 { m := MATRIX4F64_IDENTITY m[3][0] = v[0] @@ -1848,6 +1964,7 @@ matrix4_translate :: proc{ } +@(require_results) matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1874,6 +1991,7 @@ matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { return rot } +@(require_results) matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1900,6 +2018,7 @@ matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { return rot } +@(require_results) matrix4_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> Matrix4f64 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1933,6 +2052,7 @@ matrix4_rotate :: proc{ } +@(require_results) matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { m[0][0] = v[0] m[1][1] = v[1] @@ -1940,6 +2060,7 @@ matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { m[3][3] = 1 return } +@(require_results) matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { m[0][0] = v[0] m[1][1] = v[1] @@ -1947,6 +2068,7 @@ matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { m[3][3] = 1 return } +@(require_results) matrix4_scale_f64 :: proc(v: Vector3f64) -> (m: Matrix4f64) { m[0][0] = v[0] m[1][1] = v[1] @@ -1961,6 +2083,7 @@ matrix4_scale :: proc{ } +@(require_results) matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1975,6 +2098,7 @@ matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1989,6 +2113,7 @@ matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_f64 :: proc(eye, centre, up: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -2010,6 +2135,7 @@ matrix4_look_at :: proc{ } +@(require_results) matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f, s, u := f, r, u f = normalize(f) @@ -2024,6 +2150,7 @@ matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := tr 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f, s, u := f, r, u f = normalize(f) @@ -2038,6 +2165,7 @@ matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := tr 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_from_fru_f64 :: proc(eye, f, r, u: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f, s, u := f, r, u f = normalize(f) @@ -2059,6 +2187,7 @@ matrix4_look_at_from_fru :: proc{ } +@(require_results) matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2073,6 +2202,7 @@ matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := tru return } +@(require_results) matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2087,6 +2217,7 @@ matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := tru return } +@(require_results) matrix4_perspective_f64 :: proc(fovy, aspect, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2109,6 +2240,7 @@ matrix4_perspective :: proc{ +@(require_results) matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2124,6 +2256,7 @@ matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis return } +@(require_results) matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2139,6 +2272,7 @@ matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis return } +@(require_results) matrix_ortho3d_f64 :: proc(left, right, bottom, top, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2162,6 +2296,7 @@ matrix_ortho3d :: proc{ +@(require_results) matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2176,6 +2311,7 @@ matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := return } +@(require_results) matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2190,6 +2326,7 @@ matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := return } +@(require_results) matrix4_infinite_perspective_f64 :: proc(fovy, aspect, near: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2212,16 +2349,19 @@ matrix4_infinite_perspective :: proc{ +@(require_results) matrix2_from_scalar_f16 :: proc(f: f16) -> (m: Matrix2f16) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } +@(require_results) matrix2_from_scalar_f32 :: proc(f: f32) -> (m: Matrix2f32) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } +@(require_results) matrix2_from_scalar_f64 :: proc(f: f64) -> (m: Matrix2f64) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f @@ -2234,18 +2374,21 @@ matrix2_from_scalar :: proc{ } +@(require_results) matrix3_from_scalar_f16 :: proc(f: f16) -> (m: Matrix3f16) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } +@(require_results) matrix3_from_scalar_f32 :: proc(f: f32) -> (m: Matrix3f32) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } +@(require_results) matrix3_from_scalar_f64 :: proc(f: f64) -> (m: Matrix3f64) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 @@ -2259,6 +2402,7 @@ matrix3_from_scalar :: proc{ } +@(require_results) matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2266,6 +2410,7 @@ matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { m[0, 3], m[1, 3], m[2, 3], m[3, 3] = 0, 0, 0, f return } +@(require_results) matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2273,6 +2418,7 @@ matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { m[0, 3], m[1, 3], m[2, 3], m[3, 3] = 0, 0, 0, f return } +@(require_results) matrix4_from_scalar_f64 :: proc(f: f64) -> (m: Matrix4f64) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2287,16 +2433,19 @@ matrix4_from_scalar :: proc{ } +@(require_results) matrix2_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] @@ -2309,16 +2458,19 @@ matrix2_from_matrix3 :: proc{ } +@(require_results) matrix2_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] @@ -2331,18 +2483,21 @@ matrix2_from_matrix4 :: proc{ } +@(require_results) matrix3_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } +@(require_results) matrix3_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } +@(require_results) matrix3_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 @@ -2356,18 +2511,21 @@ matrix3_from_matrix2 :: proc{ } +@(require_results) matrix3_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } +@(require_results) matrix3_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } +@(require_results) matrix3_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] @@ -2381,6 +2539,7 @@ matrix3_from_matrix4 :: proc{ } +@(require_results) matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2388,6 +2547,7 @@ matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2395,6 +2555,7 @@ matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2409,6 +2570,7 @@ matrix4_from_matrix2 :: proc{ } +@(require_results) matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2416,6 +2578,7 @@ matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2423,6 +2586,7 @@ matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2437,14 +2601,17 @@ matrix4_from_matrix3 :: proc{ } +@(require_results) quaternion_from_scalar_f16 :: proc(f: f16) -> (q: Quaternionf16) { q.w = f return } +@(require_results) quaternion_from_scalar_f32 :: proc(f: f32) -> (q: Quaternionf32) { q.w = f return } +@(require_results) quaternion_from_scalar_f64 :: proc(f: f64) -> (q: Quaternionf64) { q.w = f return @@ -2505,6 +2672,7 @@ to_quaternion :: proc{ +@(require_results) matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { r[0] = normalize(m[0]) @@ -2514,6 +2682,7 @@ matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { return } +@(require_results) matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { r[0] = normalize(m[0]) @@ -2523,6 +2692,7 @@ matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { return } +@(require_results) matrix2_orthonormalize_f64 :: proc(m: Matrix2f64) -> (r: Matrix2f64) { r[0] = normalize(m[0]) @@ -2539,6 +2709,7 @@ matrix2_orthonormalize :: proc{ } +@(require_results) matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { r[0] = normalize(m[0]) @@ -2553,6 +2724,7 @@ matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { return } +@(require_results) matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { r[0] = normalize(m[0]) @@ -2567,6 +2739,7 @@ matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { return } +@(require_results) matrix3_orthonormalize_f64 :: proc(m: Matrix3f64) -> (r: Matrix3f64) { r[0] = normalize(m[0]) @@ -2588,12 +2761,15 @@ matrix3_orthonormalize :: proc{ } +@(require_results) vector3_orthonormalize_f16 :: proc(x, y: Vector3f16) -> (z: Vector3f16) { return normalize(x - y * dot(y, x)) } +@(require_results) vector3_orthonormalize_f32 :: proc(x, y: Vector3f32) -> (z: Vector3f32) { return normalize(x - y * dot(y, x)) } +@(require_results) vector3_orthonormalize_f64 :: proc(x, y: Vector3f64) -> (z: Vector3f64) { return normalize(x - y * dot(y, x)) } @@ -2611,6 +2787,7 @@ orthonormalize :: proc{ } +@(require_results) matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { if all(equal(normal, up)) { return MATRIX4F16_IDENTITY @@ -2621,6 +2798,7 @@ matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { return matrix4_rotate(angle, rotation_axis) } +@(require_results) matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { if all(equal(normal, up)) { return MATRIX4F32_IDENTITY @@ -2631,6 +2809,7 @@ matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { return matrix4_rotate(angle, rotation_axis) } +@(require_results) matrix4_orientation_f64 :: proc(normal, up: Vector3f64) -> Matrix4f64 { if all(equal(normal, up)) { return MATRIX4F64_IDENTITY @@ -2648,6 +2827,7 @@ matrix4_orientation :: proc{ } +@(require_results) euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2659,6 +2839,7 @@ euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { cx*cy, } } +@(require_results) euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2670,6 +2851,7 @@ euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { cx*cy, } } +@(require_results) euclidean_from_polar_f64 :: proc(polar: Vector2f64) -> Vector3f64 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2688,6 +2870,7 @@ euclidean_from_polar :: proc{ } +@(require_results) polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { n := length(euclidean) tmp := euclidean / n @@ -2700,6 +2883,7 @@ polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { xz_dist, } } +@(require_results) polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { n := length(euclidean) tmp := euclidean / n @@ -2712,6 +2896,7 @@ polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { xz_dist, } } +@(require_results) polar_from_euclidean_f64 :: proc(euclidean: Vector3f64) -> Vector3f64 { n := length(euclidean) tmp := euclidean / n diff --git a/core/math/linalg/specific_euler_angles_f16.odin b/core/math/linalg/specific_euler_angles_f16.odin index 9e21c7f97..e26860882 100644 --- a/core/math/linalg/specific_euler_angles_f16.odin +++ b/core/math/linalg/specific_euler_angles_f16.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3f16) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) } return } +@(require_results) matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4f16) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) return } +@(require_results) quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Ord // Quaternionf16s +@(require_results) quaternion_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf16 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf return q } +@(require_results) roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } +@(require_results) pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -157,11 +169,13 @@ pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, roll: f16) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f1 } +@(require_results) matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f1 return } +@(require_results) matrix3_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16 return m } +@(require_results) euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { // Matrix4 +@(require_results) matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: } +@(require_results) matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f1 } +@(require_results) matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f1 return } +@(require_results) matrix4_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } +@(require_results) matrix4_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } +@(require_results) matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16 return m } +@(require_results) euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/specific_euler_angles_f32.odin b/core/math/linalg/specific_euler_angles_f32.odin index 80e19ce85..3cd076f0b 100644 --- a/core/math/linalg/specific_euler_angles_f32.odin +++ b/core/math/linalg/specific_euler_angles_f32.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3f32) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) } return } +@(require_results) matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4f32) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) return } +@(require_results) quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Ord // Quaternionf32s +@(require_results) quaternion_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf32 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf return q } +@(require_results) roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } +@(require_results) pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -157,11 +169,13 @@ pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, roll: f32) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3f32) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3f32) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3f32) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f3 } +@(require_results) matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f3 return } +@(require_results) matrix3_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32 return m } +@(require_results) euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { // Matrix4 +@(require_results) matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) { } +@(require_results) matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4f32) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4f32) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4f32) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: } +@(require_results) matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f3 } +@(require_results) matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f3 return } +@(require_results) matrix4_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } +@(require_results) matrix4_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } +@(require_results) matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } +@(require_results) matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } +@(require_results) matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32 return m } +@(require_results) euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/specific_euler_angles_f64.odin b/core/math/linalg/specific_euler_angles_f64.odin index 2f8f758b0..a97f1757d 100644 --- a/core/math/linalg/specific_euler_angles_f64.odin +++ b/core/math/linalg/specific_euler_angles_f64.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3f64) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) } return } +@(require_results) matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4f64) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) return } +@(require_results) quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Ord // Quaternionf64s +@(require_results) quaternion_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf64 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf return q } +@(require_results) roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } +@(require_results) pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -157,11 +169,13 @@ pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, roll: f64) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3f64) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3f64) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3f64) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f6 } +@(require_results) matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f6 return } +@(require_results) matrix3_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64 return m } +@(require_results) euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { // Matrix4 +@(require_results) matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) { } +@(require_results) matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4f64) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4f64) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4f64) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: } +@(require_results) matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f6 } +@(require_results) matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f6 return } +@(require_results) matrix4_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } +@(require_results) matrix4_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } +@(require_results) matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } +@(require_results) matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } +@(require_results) matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64 return m } +@(require_results) euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/swizzle.odin b/core/math/linalg/swizzle.odin index ada4aebcf..8c2072193 100644 --- a/core/math/linalg/swizzle.odin +++ b/core/math/linalg/swizzle.odin @@ -37,109 +37,141 @@ Vector4_Components :: enum u8 { a = 3, } +@(require_results) scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> f32 { return f } +@(require_results) scalar_f32_swizzle2 :: proc(f: f32, c0, c1: Scalar_Components) -> Vector2f32 { return {f, f} } +@(require_results) scalar_f32_swizzle3 :: proc(f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 { return {f, f, f} } +@(require_results) scalar_f32_swizzle4 :: proc(f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 { return {f, f, f, f} } +@(require_results) vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> f32 { return v[c0] } +@(require_results) vector2f32_swizzle2 :: proc(v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector2f32_swizzle3 :: proc(v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector2f32_swizzle4 :: proc(v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> f32 { return v[c0] } +@(require_results) vector3f32_swizzle2 :: proc(v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector3f32_swizzle3 :: proc(v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector3f32_swizzle4 :: proc(v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> f32 { return v[c0] } +@(require_results) vector4f32_swizzle2 :: proc(v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector4f32_swizzle3 :: proc(v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector4f32_swizzle4 :: proc(v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> f64 { return f } +@(require_results) scalar_f64_swizzle2 :: proc(f: f64, c0, c1: Scalar_Components) -> Vector2f64 { return {f, f} } +@(require_results) scalar_f64_swizzle3 :: proc(f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 { return {f, f, f} } +@(require_results) scalar_f64_swizzle4 :: proc(f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 { return {f, f, f, f} } +@(require_results) vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> f64 { return v[c0] } +@(require_results) vector2f64_swizzle2 :: proc(v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector2f64_swizzle3 :: proc(v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector2f64_swizzle4 :: proc(v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> f64 { return v[c0] } +@(require_results) vector3f64_swizzle2 :: proc(v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector3f64_swizzle3 :: proc(v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector3f64_swizzle4 :: proc(v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> f64 { return v[c0] } +@(require_results) vector4f64_swizzle2 :: proc(v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector4f64_swizzle3 :: proc(v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector4f64_swizzle4 :: proc(v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } From c4cb2f237881d077c5da2a1be66f81a233d4613b Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:07:37 +0100 Subject: [PATCH 048/108] Add "contextless" to `core:math/linalg` procedures --- core/math/linalg/extended.odin | 130 +++--- core/math/linalg/general.odin | 76 ++-- core/math/linalg/specific.odin | 370 +++++++++--------- .../linalg/specific_euler_angles_f16.odin | 200 +++++----- .../linalg/specific_euler_angles_f32.odin | 200 +++++----- .../linalg/specific_euler_angles_f64.odin | 200 +++++----- core/math/linalg/swizzle.odin | 64 +-- 7 files changed, 620 insertions(+), 620 deletions(-) diff --git a/core/math/linalg/extended.odin b/core/math/linalg/extended.odin index f0be35aa1..b6e05a2c2 100644 --- a/core/math/linalg/extended.odin +++ b/core/math/linalg/extended.odin @@ -4,7 +4,7 @@ import "core:builtin" import "core:math" @(require_results) -to_radians :: proc(degrees: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +to_radians :: proc "contextless" (degrees: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -to_degrees :: proc(radians: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +to_degrees :: proc "contextless" (radians: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -min_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +min_double :: proc "contextless" (a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { +min_single :: proc "contextless" (a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -61,14 +61,14 @@ min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) } @(require_results) -min_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { +min_triple :: proc "contextless" (a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return min_double(a, min_double(b, c)) } min :: proc{min_single, min_double, min_triple} @(require_results) -max_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +max_double :: proc "contextless" (a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { +max_single :: proc "contextless" (a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -103,14 +103,14 @@ max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) } @(require_results) -max_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { +max_triple :: proc "contextless" (a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return max_double(a, max_double(b, c)) } max :: proc{max_single, max_double, max_triple} @(require_results) -abs :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +abs :: proc "contextless" (a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -sign :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +sign :: proc "contextless" (a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } @(require_results) -clamp :: proc(x, a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { +clamp :: proc "contextless" (x, a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { @(require_results) -saturate :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +saturate :: proc "contextless" (x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return clamp(x, 0.0, 1.0) } @(require_results) -lerp :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +lerp :: proc "contextless" (a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } @(require_results) -mix :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +mix :: proc "contextless" (a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -unlerp :: proc(a, b, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +unlerp :: proc "contextless" (a, b, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return (x - a) / (b - a) } @(require_results) -step :: proc(e, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +step :: proc "contextless" (e, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -smoothstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +smoothstep :: proc "contextless" (e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * (3.0 - 2.0 * t) } @(require_results) -smootherstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +smootherstep :: proc "contextless" (e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * t * (t * (6*t - 15) + 10) } @(require_results) -sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +sqrt :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -inverse_sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +inverse_sqrt :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -cos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +cos :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -sin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +sin :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -tan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +tan :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -acos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +acos :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -asin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +asin :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -atan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +atan :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } @(require_results) -atan2 :: proc(y, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +atan2 :: proc "contextless" (y, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { @(require_results) -ln :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +ln :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -log2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +log2 :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -log10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +log10 :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -log :: proc(x, b: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +log :: proc "contextless" (x, b: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -exp :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +exp :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -exp2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +exp2 :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -exp10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +exp10 :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -pow :: proc(x, e: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +pow :: proc "contextless" (x, e: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { @(require_results) -ceil :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +ceil :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -floor :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +floor :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -round :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { +round :: proc "contextless" (x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } @(require_results) -fract :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +fract :: proc "contextless" (x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x) return x - f } @(require_results) -mod :: proc(x, m: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { +mod :: proc "contextless" (x, m: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x / m) return x - f * m } @(require_results) -face_forward :: proc(N, I, N_ref: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { +face_forward :: proc "contextless" (N, I, N_ref: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { return dot(N_ref, I) < 0 ? N : -N } @(require_results) -distance :: proc(p0, p1: $V/[$N]$E) -> E where IS_NUMERIC(E) { +distance :: proc "contextless" (p0, p1: $V/[$N]$E) -> E where IS_NUMERIC(E) { return length(p1 - p0) } @(require_results) -reflect :: proc(I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { +reflect :: proc "contextless" (I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { b := N * (2 * dot(N, I)) return I - b } @(require_results) -refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_FLOAT(ELEM_TYPE(V)) { +refract :: proc "contextless" (I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_FLOAT(ELEM_TYPE(V)) { dv := dot(Normal, I) k := 1 - eta*eta * (1 - dv*dv) a := I * eta @@ -486,12 +486,12 @@ refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_ @(require_results) -is_nan_single :: proc(x: $T) -> bool where IS_FLOAT(T) { +is_nan_single :: proc "contextless" (x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_nan(x) } @(require_results) -is_nan_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { +is_nan_array :: proc "contextless" (x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { } @(require_results) -is_inf_single :: proc(x: $T) -> bool where IS_FLOAT(T) { +is_inf_single :: proc "contextless" (x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_inf(x) } @(require_results) -is_inf_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { +is_inf_array :: proc "contextless" (x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { } @(require_results) -classify_single :: proc(x: $T) -> math.Float_Class where IS_FLOAT(T) { +classify_single :: proc "contextless" (x: $T) -> math.Float_Class where IS_FLOAT(T) { return #force_inline math.classify(x) } @(require_results) -classify_array :: proc(x: $A/[$N]$T) -> (out: [N]math.Float_Class) where IS_FLOAT(T) { +classify_array :: proc "contextless" (x: $A/[$N]$T) -> (out: [N]math.Float_Class) where IS_FLOAT(T) { for i in 0.. (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } -@(require_results) less_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } -@(require_results) greater_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } -@(require_results) greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } -@(require_results) equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } -@(require_results) not_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } +@(require_results) less_than_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } +@(require_results) less_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } +@(require_results) greater_than_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } +@(require_results) greater_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } +@(require_results) equal_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } +@(require_results) not_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } @(require_results) -less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +less_than_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +less_than_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +greater_than_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. y[i] } return } @(require_results) -greater_than_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +greater_than_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0..= y[i] } return } @(require_results) -equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { +not_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: bool) { +any :: proc "contextless" (x: $A/[$N]bool) -> (out: bool) { for e in x { if e { return true @@ -596,7 +596,7 @@ any :: proc(x: $A/[$N]bool) -> (out: bool) { return false } @(require_results) -all :: proc(x: $A/[$N]bool) -> (out: bool) { +all :: proc "contextless" (x: $A/[$N]bool) -> (out: bool) { for e in x { if !e { return false @@ -605,7 +605,7 @@ all :: proc(x: $A/[$N]bool) -> (out: bool) { return true } @(require_results) -not :: proc(x: $A/[$N]bool) -> (out: A) { +not :: proc "contextless" (x: $A/[$N]bool) -> (out: A) { for e, i in x { out[i] = !e } diff --git a/core/math/linalg/general.odin b/core/math/linalg/general.odin index dca3cf5d5..b58305c63 100644 --- a/core/math/linalg/general.odin +++ b/core/math/linalg/general.odin @@ -39,27 +39,27 @@ DEG_PER_RAD :: 360.0/TAU @(require_results) -scalar_dot :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { +scalar_dot :: proc "contextless" (a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } @(require_results) -vector_dot :: proc(a, b: $T/[$N]$E) -> (c: E) where IS_NUMERIC(E) #no_bounds_check { +vector_dot :: proc "contextless" (a, b: $T/[$N]$E) -> (c: E) where IS_NUMERIC(E) #no_bounds_check { for i in 0.. (c: f16) { +quaternion64_dot :: proc "contextless" (a, b: $T/quaternion64) -> (c: f16) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } @(require_results) -quaternion128_dot :: proc(a, b: $T/quaternion128) -> (c: f32) { +quaternion128_dot :: proc "contextless" (a, b: $T/quaternion128) -> (c: f32) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } @(require_results) -quaternion256_dot :: proc(a, b: $T/quaternion256) -> (c: f64) { +quaternion256_dot :: proc "contextless" (a, b: $T/quaternion256) -> (c: f64) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } @@ -69,23 +69,23 @@ inner_product :: dot outer_product :: builtin.outer_product @(require_results) -quaternion_inverse :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_inverse :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { return conj(q) * quaternion(1.0/dot(q, q), 0, 0, 0) } @(require_results) -scalar_cross :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { +scalar_cross :: proc "contextless" (a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } @(require_results) -vector_cross2 :: proc(a, b: $T/[2]$E) -> E where IS_NUMERIC(E) { +vector_cross2 :: proc "contextless" (a, b: $T/[2]$E) -> E where IS_NUMERIC(E) { return a[0]*b[1] - b[0]*a[1] } @(require_results) -vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { +vector_cross3 :: proc "contextless" (a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { c[0] = a[1]*b[2] - b[1]*a[2] c[1] = a[2]*b[0] - b[2]*a[0] c[2] = a[0]*b[1] - b[0]*a[1] @@ -93,7 +93,7 @@ vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { } @(require_results) -quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { +quaternion_cross :: proc "contextless" (q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { q3.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y q3.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z q3.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x @@ -105,22 +105,22 @@ vector_cross :: proc{scalar_cross, vector_cross2, vector_cross3} cross :: proc{scalar_cross, vector_cross2, vector_cross3, quaternion_cross} @(require_results) -vector_normalize :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { +vector_normalize :: proc "contextless" (v: $T/[$N]$E) -> T where IS_FLOAT(E) { return v / length(v) } @(require_results) -quaternion_normalize :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_normalize :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { return q/abs(q) } normalize :: proc{vector_normalize, quaternion_normalize} @(require_results) -vector_normalize0 :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { +vector_normalize0 :: proc "contextless" (v: $T/[$N]$E) -> T where IS_FLOAT(E) { m := length(v) return 0 if m == 0 else v/m } @(require_results) -quaternion_normalize0 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_normalize0 :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { m := abs(q) return 0 if m == 0 else q/m } @@ -128,27 +128,27 @@ normalize0 :: proc{vector_normalize0, quaternion_normalize0} @(require_results) -vector_length :: proc(v: $T/[$N]$E) -> E where IS_FLOAT(E) { +vector_length :: proc "contextless" (v: $T/[$N]$E) -> E where IS_FLOAT(E) { return math.sqrt(dot(v, v)) } @(require_results) -vector_length2 :: proc(v: $T/[$N]$E) -> E where IS_NUMERIC(E) { +vector_length2 :: proc "contextless" (v: $T/[$N]$E) -> E where IS_NUMERIC(E) { return dot(v, v) } @(require_results) -quaternion_length :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_length :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { return abs(q) } @(require_results) -quaternion_length2 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_length2 :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { return dot(q, q) } @(require_results) -scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { +scalar_triple_product :: proc "contextless" (a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { // a . (b x c) // b . (c x a) // c . (a x b) @@ -156,7 +156,7 @@ scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { } @(require_results) -vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { +vector_triple_product :: proc "contextless" (a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { // a x (b x c) // (a . c)b - (a . b)c return cross(a, cross(b, c)) @@ -167,12 +167,12 @@ length :: proc{vector_length, quaternion_length} length2 :: proc{vector_length2, quaternion_length2} @(require_results) -projection :: proc(x, normal: $T/[$N]$E) -> T where IS_NUMERIC(E) { +projection :: proc "contextless" (x, normal: $T/[$N]$E) -> T where IS_NUMERIC(E) { return dot(x, normal) / dot(normal, normal) * normal } @(require_results) -identity :: proc($T: typeid/[$N][N]$E) -> (m: T) #no_bounds_check { +identity :: proc "contextless" ($T: typeid/[$N][N]$E) -> (m: T) #no_bounds_check { for i in 0.. (c: M) +matrix_mul :: proc "contextless" (a, b: $M/matrix[$N, N]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } @(require_results) -matrix_comp_mul :: proc(a, b: $M/matrix[$I, $J]$E) -> (c: M) +matrix_comp_mul :: proc "contextless" (a, b: $M/matrix[$I, $J]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return hadamard_product(a, b) } @(require_results) -matrix_mul_differ :: proc(a: $A/matrix[$I, $J]$E, b: $B/matrix[J, $K]E) -> (c: matrix[I, K]E) +matrix_mul_differ :: proc "contextless" (a: $A/matrix[$I, $J]$E, b: $B/matrix[J, $K]E) -> (c: matrix[I, K]E) where !IS_ARRAY(E), IS_NUMERIC(E), I != K #no_bounds_check { return a * b } @(require_results) -matrix_mul_vector :: proc(a: $A/matrix[$I, $J]$E, b: $B/[J]E) -> (c: B) +matrix_mul_vector :: proc "contextless" (a: $A/matrix[$I, $J]$E, b: $B/[J]E) -> (c: B) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } @(require_results) -quaternion_mul_quaternion :: proc(q1, q2: $Q) -> Q where IS_QUATERNION(Q) { +quaternion_mul_quaternion :: proc "contextless" (q1, q2: $Q) -> Q where IS_QUATERNION(Q) { return q1 * q2 } @(require_results) -quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { +quaternion64_mul_vector3 :: proc "contextless" (q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { Raw_Quaternion :: struct {xyz: [3]f16, r: f16} q := transmute(Raw_Quaternion)q @@ -223,7 +223,7 @@ quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { return V(v + q.r*t + cross(q.xyz, t)) } @(require_results) -quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { +quaternion128_mul_vector3 :: proc "contextless" (q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { Raw_Quaternion :: struct {xyz: [3]f32, r: f32} q := transmute(Raw_Quaternion)q @@ -233,7 +233,7 @@ quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { return V(v + q.r*t + cross(q.xyz, t)) } @(require_results) -quaternion256_mul_vector3 :: proc(q: $Q/quaternion256, v: $V/[3]$F/f64) -> V { +quaternion256_mul_vector3 :: proc "contextless" (q: $Q/quaternion256, v: $V/[3]$F/f64) -> V { Raw_Quaternion :: struct {xyz: [3]f64, r: f64} q := transmute(Raw_Quaternion)q @@ -255,11 +255,11 @@ mul :: proc{ } @(require_results) -vector_to_ptr :: proc(v: ^$V/[$N]$E) -> ^E where IS_NUMERIC(E), N > 0 #no_bounds_check { +vector_to_ptr :: proc "contextless" (v: ^$V/[$N]$E) -> ^E where IS_NUMERIC(E), N > 0 #no_bounds_check { return &v[0] } @(require_results) -matrix_to_ptr :: proc(m: ^$A/matrix[$I, $J]$E) -> ^E where IS_NUMERIC(E), I > 0, J > 0 #no_bounds_check { +matrix_to_ptr :: proc "contextless" (m: ^$A/matrix[$I, $J]$E) -> ^E where IS_NUMERIC(E), I > 0, J > 0 #no_bounds_check { return &m[0, 0] } @@ -272,7 +272,7 @@ to_ptr :: proc{vector_to_ptr, matrix_to_ptr} // Splines @(require_results) -vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { +vector_slerp :: proc "contextless" (x, y: $T/[$N]$E, a: E) -> T { cos_alpha := dot(x, y) alpha := math.acos(cos_alpha) sin_alpha := math.sin(alpha) @@ -284,7 +284,7 @@ vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { } @(require_results) -catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { +catmull_rom :: proc "contextless" (v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -297,7 +297,7 @@ catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { } @(require_results) -hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { +hermite :: proc "contextless" (v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -310,14 +310,14 @@ hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { } @(require_results) -cubic :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { +cubic :: proc "contextless" (v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { return ((v1 * s + v2) * s + v3) * s + v4 } @(require_results) -array_cast :: proc(v: $A/[$N]$T, $Elem_Type: typeid) -> (w: [N]Elem_Type) #no_bounds_check { +array_cast :: proc "contextless" (v: $A/[$N]$T, $Elem_Type: typeid) -> (w: [N]Elem_Type) #no_bounds_check { for i in 0.. (w: [N]Elem_Type) #no_bo } @(require_results) -matrix_cast :: proc(v: $A/matrix[$M, $N]$T, $Elem_Type: typeid) -> (w: matrix[M, N]Elem_Type) #no_bounds_check { +matrix_cast :: proc "contextless" (v: $A/matrix[$M, $N]$T, $Elem_Type: typeid) -> (w: matrix[M, N]Elem_Type) #no_bounds_check { for j in 0.. V where !IS_ARRAY(E), IS_FLOAT(E) { +vector2_orthogonal :: proc "contextless" (v: $V/[2]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { return {-v.y, v.x} } @(require_results) -vector3_orthogonal :: proc(v: $V/[3]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { +vector3_orthogonal :: proc "contextless" (v: $V/[3]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { x := abs(v.x) y := abs(v.y) z := abs(v.z) @@ -163,7 +163,7 @@ orthogonal :: proc{vector2_orthogonal, vector3_orthogonal} @(require_results) -vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { +vector4_srgb_to_linear_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) b := math.pow(col.z, 2.2) @@ -171,7 +171,7 @@ vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {r, g, b, a} } @(require_results) -vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { +vector4_srgb_to_linear_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) b := math.pow(col.z, 2.2) @@ -179,7 +179,7 @@ vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {r, g, b, a} } @(require_results) -vector4_srgb_to_linear_f64 :: proc(col: Vector4f64) -> Vector4f64 { +vector4_srgb_to_linear_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) b := math.pow(col.z, 2.2) @@ -194,7 +194,7 @@ vector4_srgb_to_linear :: proc{ @(require_results) -vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { +vector4_linear_to_srgb_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 { a :: 2.51 b :: 0.03 c :: 2.43 @@ -216,7 +216,7 @@ vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {x, y, z, col.w} } @(require_results) -vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { +vector4_linear_to_srgb_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 { a :: 2.51 b :: 0.03 c :: 2.43 @@ -238,7 +238,7 @@ vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {x, y, z, col.w} } @(require_results) -vector4_linear_to_srgb_f64 :: proc(col: Vector4f64) -> Vector4f64 { +vector4_linear_to_srgb_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 { a :: 2.51 b :: 0.03 c :: 2.43 @@ -267,9 +267,9 @@ vector4_linear_to_srgb :: proc{ @(require_results) -vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { +vector4_hsl_to_rgb_f16 :: proc "contextless" (h, s, l: f16, a: f16 = 1) -> Vector4f16 { @(require_results) - hue_to_rgb :: proc(p, q, t: f16) -> f16 { + hue_to_rgb :: proc "contextless" (p, q, t: f16) -> f16 { t := t if t < 0 { t += 1 } if t > 1 { t -= 1 } @@ -296,9 +296,9 @@ vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { return {r, g, b, a} } @(require_results) -vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { +vector4_hsl_to_rgb_f32 :: proc "contextless" (h, s, l: f32, a: f32 = 1) -> Vector4f32 { @(require_results) - hue_to_rgb :: proc(p, q, t: f32) -> f32 { + hue_to_rgb :: proc "contextless" (p, q, t: f32) -> f32 { t := t if t < 0 { t += 1 } if t > 1 { t -= 1 } @@ -325,9 +325,9 @@ vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { return {r, g, b, a} } @(require_results) -vector4_hsl_to_rgb_f64 :: proc(h, s, l: f64, a: f64 = 1) -> Vector4f64 { +vector4_hsl_to_rgb_f64 :: proc "contextless" (h, s, l: f64, a: f64 = 1) -> Vector4f64 { @(require_results) - hue_to_rgb :: proc(p, q, t: f64) -> f64 { + hue_to_rgb :: proc "contextless" (p, q, t: f64) -> f64 { t := t if t < 0 { t += 1 } if t > 1 { t -= 1 } @@ -361,7 +361,7 @@ vector4_hsl_to_rgb :: proc{ @(require_results) -vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { +vector4_rgb_to_hsl_f16 :: proc "contextless" (col: Vector4f16) -> Vector4f16 { r := col.x g := col.y b := col.z @@ -391,7 +391,7 @@ vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {h, s, l, a} } @(require_results) -vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { +vector4_rgb_to_hsl_f32 :: proc "contextless" (col: Vector4f32) -> Vector4f32 { r := col.x g := col.y b := col.z @@ -421,7 +421,7 @@ vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {h, s, l, a} } @(require_results) -vector4_rgb_to_hsl_f64 :: proc(col: Vector4f64) -> Vector4f64 { +vector4_rgb_to_hsl_f64 :: proc "contextless" (col: Vector4f64) -> Vector4f64 { r := col.x g := col.y b := col.z @@ -459,7 +459,7 @@ vector4_rgb_to_hsl :: proc{ @(require_results) -quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) { +quaternion_angle_axis_f16 :: proc "contextless" (angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) q.x = v.x @@ -469,7 +469,7 @@ quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Q return } @(require_results) -quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) { +quaternion_angle_axis_f32 :: proc "contextless" (angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) q.x = v.x @@ -479,7 +479,7 @@ quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Q return } @(require_results) -quaternion_angle_axis_f64 :: proc(angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) { +quaternion_angle_axis_f64 :: proc "contextless" (angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) q.x = v.x @@ -495,7 +495,7 @@ quaternion_angle_axis :: proc{ } @(require_results) -angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { +angle_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 } @@ -503,7 +503,7 @@ angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.acos(q.w) * 2 } @(require_results) -angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { +angle_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 } @@ -511,7 +511,7 @@ angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.acos(q.w) * 2 } @(require_results) -angle_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { +angle_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 } @@ -525,7 +525,7 @@ angle_from_quaternion :: proc{ } @(require_results) -axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { +axis_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> Vector3f16 { t1 := 1 - q.w*q.w if t1 < 0 { return {0, 0, 1} @@ -534,7 +534,7 @@ axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { return {q.x*t2, q.y*t2, q.z*t2} } @(require_results) -axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { +axis_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> Vector3f32 { t1 := 1 - q.w*q.w if t1 < 0 { return {0, 0, 1} @@ -543,7 +543,7 @@ axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { return {q.x*t2, q.y*t2, q.z*t2} } @(require_results) -axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> Vector3f64 { +axis_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> Vector3f64 { t1 := 1 - q.w*q.w if t1 < 0 { return {0, 0, 1} @@ -559,19 +559,19 @@ axis_from_quaternion :: proc{ @(require_results) -angle_axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> (angle: f16, axis: Vector3f16) { +angle_axis_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (angle: f16, axis: Vector3f16) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } @(require_results) -angle_axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> (angle: f32, axis: Vector3f32) { +angle_axis_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (angle: f32, axis: Vector3f32) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } @(require_results) -angle_axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> (angle: f64, axis: Vector3f64) { +angle_axis_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (angle: f64, axis: Vector3f64) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return @@ -584,7 +584,7 @@ angle_axis_from_quaternion :: proc { @(require_results) -quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternionf16 { +quaternion_from_forward_and_up_f16 :: proc "contextless" (forward, up: Vector3f16) -> Quaternionf16 { f := normalize(forward) s := normalize(cross(f, up)) u := cross(s, f) @@ -628,7 +628,7 @@ quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternio return normalize(q) } @(require_results) -quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternionf32 { +quaternion_from_forward_and_up_f32 :: proc "contextless" (forward, up: Vector3f32) -> Quaternionf32 { f := normalize(forward) s := normalize(cross(f, up)) u := cross(s, f) @@ -672,7 +672,7 @@ quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternio return normalize(q) } @(require_results) -quaternion_from_forward_and_up_f64 :: proc(forward, up: Vector3f64) -> Quaternionf64 { +quaternion_from_forward_and_up_f64 :: proc "contextless" (forward, up: Vector3f64) -> Quaternionf64 { f := normalize(forward) s := normalize(cross(f, up)) u := cross(s, f) @@ -722,15 +722,15 @@ quaternion_from_forward_and_up :: proc{ } @(require_results) -quaternion_look_at_f16 :: proc(eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 { +quaternion_look_at_f16 :: proc "contextless" (eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } @(require_results) -quaternion_look_at_f32 :: proc(eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 { +quaternion_look_at_f32 :: proc "contextless" (eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } @(require_results) -quaternion_look_at_f64 :: proc(eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 { +quaternion_look_at_f64 :: proc "contextless" (eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } quaternion_look_at :: proc{ @@ -742,7 +742,7 @@ quaternion_look_at :: proc{ @(require_results) -quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) { +quaternion_nlerp_f16 :: proc "contextless" (a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t c.z = a.z + (b.z-a.z)*t @@ -750,7 +750,7 @@ quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) return normalize(c) } @(require_results) -quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) { +quaternion_nlerp_f32 :: proc "contextless" (a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t c.z = a.z + (b.z-a.z)*t @@ -758,7 +758,7 @@ quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) return normalize(c) } @(require_results) -quaternion_nlerp_f64 :: proc(a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) { +quaternion_nlerp_f64 :: proc "contextless" (a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t c.z = a.z + (b.z-a.z)*t @@ -773,7 +773,7 @@ quaternion_nlerp :: proc{ @(require_results) -quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) { +quaternion_slerp_f16 :: proc "contextless" (x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) { a, b := x, y cos_angle := dot(a, b) if cos_angle < 0 { @@ -801,7 +801,7 @@ quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) return } @(require_results) -quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) { +quaternion_slerp_f32 :: proc "contextless" (x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) { a, b := x, y cos_angle := dot(a, b) if cos_angle < 0 { @@ -829,7 +829,7 @@ quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) return } @(require_results) -quaternion_slerp_f64 :: proc(x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) { +quaternion_slerp_f64 :: proc "contextless" (x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) { a, b := x, y cos_angle := dot(a, b) if cos_angle < 0 { @@ -864,17 +864,17 @@ quaternion_slerp :: proc{ @(require_results) -quaternion_squad_f16 :: proc(q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 { +quaternion_squad_f16 :: proc "contextless" (q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } @(require_results) -quaternion_squad_f32 :: proc(q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 { +quaternion_squad_f32 :: proc "contextless" (q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } @(require_results) -quaternion_squad_f64 :: proc(q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 { +quaternion_squad_f64 :: proc "contextless" (q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } @@ -886,7 +886,7 @@ quaternion_squad :: proc{ @(require_results) -quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { +quaternion_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (q: Quaternionf16) { m3: Matrix3f16 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] m3[0, 1], m3[1, 1], m3[2, 1] = m[0, 1], m[1, 1], m[2, 1] @@ -894,7 +894,7 @@ quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { return quaternion_from_matrix3(m3) } @(require_results) -quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { +quaternion_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (q: Quaternionf32) { m3: Matrix3f32 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] m3[0, 1], m3[1, 1], m3[2, 1] = m[0, 1], m[1, 1], m[2, 1] @@ -902,7 +902,7 @@ quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { return quaternion_from_matrix3(m3) } @(require_results) -quaternion_from_matrix4_f64 :: proc(m: Matrix4f64) -> (q: Quaternionf64) { +quaternion_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (q: Quaternionf64) { m3: Matrix3f64 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] m3[0, 1], m3[1, 1], m3[2, 1] = m[0, 1], m[1, 1], m[2, 1] @@ -917,7 +917,7 @@ quaternion_from_matrix4 :: proc{ @(require_results) -quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { +quaternion_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (q: Quaternionf16) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] four_z_squared_minus_1 := m[2, 2] - m[0, 0] - m[1, 1] @@ -967,7 +967,7 @@ quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { return } @(require_results) -quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { +quaternion_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (q: Quaternionf32) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] four_z_squared_minus_1 := m[2, 2] - m[0, 0] - m[1, 1] @@ -1017,7 +1017,7 @@ quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { return } @(require_results) -quaternion_from_matrix3_f64 :: proc(m: Matrix3f64) -> (q: Quaternionf64) { +quaternion_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (q: Quaternionf64) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] four_z_squared_minus_1 := m[2, 2] - m[0, 0] - m[1, 1] @@ -1074,7 +1074,7 @@ quaternion_from_matrix3 :: proc{ @(require_results) -quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaternionf16) { +quaternion_between_two_vector3_f16 :: proc "contextless" (from, to: Vector3f16) -> (q: Quaternionf16) { x := normalize(from) y := normalize(to) @@ -1096,7 +1096,7 @@ quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaterni return normalize(q) } @(require_results) -quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaternionf32) { +quaternion_between_two_vector3_f32 :: proc "contextless" (from, to: Vector3f32) -> (q: Quaternionf32) { x := normalize(from) y := normalize(to) @@ -1118,7 +1118,7 @@ quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaterni return normalize(q) } @(require_results) -quaternion_between_two_vector3_f64 :: proc(from, to: Vector3f64) -> (q: Quaternionf64) { +quaternion_between_two_vector3_f64 :: proc "contextless" (from, to: Vector3f64) -> (q: Quaternionf64) { x := normalize(from) y := normalize(to) @@ -1147,7 +1147,7 @@ quaternion_between_two_vector3 :: proc{ @(require_results) -matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { +matrix2_inverse_transpose_f16 :: proc "contextless" (m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1157,7 +1157,7 @@ matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { return c } @(require_results) -matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { +matrix2_inverse_transpose_f32 :: proc "contextless" (m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1167,7 +1167,7 @@ matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { return c } @(require_results) -matrix2_inverse_transpose_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { +matrix2_inverse_transpose_f64 :: proc "contextless" (m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1184,15 +1184,15 @@ matrix2_inverse_transpose :: proc{ @(require_results) -matrix2_determinant_f16 :: proc(m: Matrix2f16) -> f16 { +matrix2_determinant_f16 :: proc "contextless" (m: Matrix2f16) -> f16 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } @(require_results) -matrix2_determinant_f32 :: proc(m: Matrix2f32) -> f32 { +matrix2_determinant_f32 :: proc "contextless" (m: Matrix2f32) -> f32 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } @(require_results) -matrix2_determinant_f64 :: proc(m: Matrix2f64) -> f64 { +matrix2_determinant_f64 :: proc "contextless" (m: Matrix2f64) -> f64 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } matrix2_determinant :: proc{ @@ -1203,7 +1203,7 @@ matrix2_determinant :: proc{ @(require_results) -matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { +matrix2_inverse_f16 :: proc "contextless" (m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1213,7 +1213,7 @@ matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { return c } @(require_results) -matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { +matrix2_inverse_f32 :: proc "contextless" (m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1223,7 +1223,7 @@ matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { return c } @(require_results) -matrix2_inverse_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { +matrix2_inverse_f64 :: proc "contextless" (m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d c[0, 0] = +m[1, 1] * id @@ -1240,7 +1240,7 @@ matrix2_inverse :: proc{ @(require_results) -matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { +matrix2_adjoint_f16 :: proc "contextless" (m: Matrix2f16) -> (c: Matrix2f16) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] c[0, 1] = -m[1, 0] @@ -1248,7 +1248,7 @@ matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { return c } @(require_results) -matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { +matrix2_adjoint_f32 :: proc "contextless" (m: Matrix2f32) -> (c: Matrix2f32) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] c[0, 1] = -m[1, 0] @@ -1256,7 +1256,7 @@ matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { return c } @(require_results) -matrix2_adjoint_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { +matrix2_adjoint_f64 :: proc "contextless" (m: Matrix2f64) -> (c: Matrix2f64) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] c[0, 1] = -m[1, 0] @@ -1271,7 +1271,7 @@ matrix2_adjoint :: proc{ @(require_results) -matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { +matrix3_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (m: Matrix3f16) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1296,7 +1296,7 @@ matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { return m } @(require_results) -matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { +matrix3_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (m: Matrix3f32) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1321,7 +1321,7 @@ matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { return m } @(require_results) -matrix3_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix3f64) { +matrix3_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (m: Matrix3f64) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1353,15 +1353,15 @@ matrix3_from_quaternion :: proc{ @(require_results) -matrix3_inverse_f16 :: proc(m: Matrix3f16) -> Matrix3f16 { +matrix3_inverse_f16 :: proc "contextless" (m: Matrix3f16) -> Matrix3f16 { return transpose(matrix3_inverse_transpose(m)) } @(require_results) -matrix3_inverse_f32 :: proc(m: Matrix3f32) -> Matrix3f32 { +matrix3_inverse_f32 :: proc "contextless" (m: Matrix3f32) -> Matrix3f32 { return transpose(matrix3_inverse_transpose(m)) } @(require_results) -matrix3_inverse_f64 :: proc(m: Matrix3f64) -> Matrix3f64 { +matrix3_inverse_f64 :: proc "contextless" (m: Matrix3f64) -> Matrix3f64 { return transpose(matrix3_inverse_transpose(m)) } matrix3_inverse :: proc{ @@ -1372,21 +1372,21 @@ matrix3_inverse :: proc{ @(require_results) -matrix3_determinant_f16 :: proc(m: Matrix3f16) -> f16 { +matrix3_determinant_f16 :: proc "contextless" (m: Matrix3f16) -> f16 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } @(require_results) -matrix3_determinant_f32 :: proc(m: Matrix3f32) -> f32 { +matrix3_determinant_f32 :: proc "contextless" (m: Matrix3f32) -> f32 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } @(require_results) -matrix3_determinant_f64 :: proc(m: Matrix3f64) -> f64 { +matrix3_determinant_f64 :: proc "contextless" (m: Matrix3f64) -> f64 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) @@ -1400,7 +1400,7 @@ matrix3_determinant :: proc{ @(require_results) -matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { +matrix3_adjoint_f16 :: proc "contextless" (m: Matrix3f16) -> (adjoint: Matrix3f16) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) adjoint[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) @@ -1413,7 +1413,7 @@ matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { return adjoint } @(require_results) -matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { +matrix3_adjoint_f32 :: proc "contextless" (m: Matrix3f32) -> (adjoint: Matrix3f32) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) adjoint[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) @@ -1426,7 +1426,7 @@ matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { return adjoint } @(require_results) -matrix3_adjoint_f64 :: proc(m: Matrix3f64) -> (adjoint: Matrix3f64) { +matrix3_adjoint_f64 :: proc "contextless" (m: Matrix3f64) -> (adjoint: Matrix3f64) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) adjoint[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) @@ -1447,15 +1447,15 @@ matrix3_adjoint :: proc{ @(require_results) -matrix3_inverse_transpose_f16 :: proc(m: Matrix3f16) -> (inverse_transpose: Matrix3f16) { +matrix3_inverse_transpose_f16 :: proc "contextless" (m: Matrix3f16) -> (inverse_transpose: Matrix3f16) { return builtin.inverse_transpose(m) } @(require_results) -matrix3_inverse_transpose_f32 :: proc(m: Matrix3f32) -> (inverse_transpose: Matrix3f32) { +matrix3_inverse_transpose_f32 :: proc "contextless" (m: Matrix3f32) -> (inverse_transpose: Matrix3f32) { return builtin.inverse_transpose(m) } @(require_results) -matrix3_inverse_transpose_f64 :: proc(m: Matrix3f64) -> (inverse_transpose: Matrix3f64) { +matrix3_inverse_transpose_f64 :: proc "contextless" (m: Matrix3f64) -> (inverse_transpose: Matrix3f64) { return builtin.inverse_transpose(m) } matrix3_inverse_transpose :: proc{ @@ -1466,21 +1466,21 @@ matrix3_inverse_transpose :: proc{ @(require_results) -matrix3_scale_f16 :: proc(s: Vector3f16) -> (m: Matrix3f16) { +matrix3_scale_f16 :: proc "contextless" (s: Vector3f16) -> (m: Matrix3f16) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } @(require_results) -matrix3_scale_f32 :: proc(s: Vector3f32) -> (m: Matrix3f32) { +matrix3_scale_f32 :: proc "contextless" (s: Vector3f32) -> (m: Matrix3f32) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } @(require_results) -matrix3_scale_f64 :: proc(s: Vector3f64) -> (m: Matrix3f64) { +matrix3_scale_f64 :: proc "contextless" (s: Vector3f64) -> (m: Matrix3f64) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] @@ -1494,7 +1494,7 @@ matrix3_scale :: proc{ @(require_results) -matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f16) { +matrix3_rotate_f16 :: proc "contextless" (angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f16) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1516,7 +1516,7 @@ matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f1 return rot } @(require_results) -matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f32) { +matrix3_rotate_f32 :: proc "contextless" (angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f32) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1538,7 +1538,7 @@ matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f3 return rot } @(require_results) -matrix3_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> (rot: Matrix3f64) { +matrix3_rotate_f64 :: proc "contextless" (angle_radians: f64, v: Vector3f64) -> (rot: Matrix3f64) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1567,7 +1567,7 @@ matrix3_rotate :: proc{ @(require_results) -matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { +matrix3_look_at_f16 :: proc "contextless" (eye, centre, up: Vector3f16) -> Matrix3f16 { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -1578,7 +1578,7 @@ matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { } } @(require_results) -matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { +matrix3_look_at_f32 :: proc "contextless" (eye, centre, up: Vector3f32) -> Matrix3f32 { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -1589,7 +1589,7 @@ matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { } } @(require_results) -matrix3_look_at_f64 :: proc(eye, centre, up: Vector3f64) -> Matrix3f64 { +matrix3_look_at_f64 :: proc "contextless" (eye, centre, up: Vector3f64) -> Matrix3f64 { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -1607,7 +1607,7 @@ matrix3_look_at :: proc{ @(require_results) -matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { +matrix4_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (m: Matrix4f16) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1635,7 +1635,7 @@ matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { return m } @(require_results) -matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { +matrix4_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (m: Matrix4f32) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1663,7 +1663,7 @@ matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { return m } @(require_results) -matrix4_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix4f64) { +matrix4_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (m: Matrix4f64) { qxx := q.x * q.x qyy := q.y * q.y qzz := q.z * q.z @@ -1698,21 +1698,21 @@ matrix4_from_quaternion :: proc{ @(require_results) -matrix4_from_trs_f16 :: proc(t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4f16 { +matrix4_from_trs_f16 :: proc "contextless" (t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4f16 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } @(require_results) -matrix4_from_trs_f32 :: proc(t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4f32 { +matrix4_from_trs_f32 :: proc "contextless" (t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4f32 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } @(require_results) -matrix4_from_trs_f64 :: proc(t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4f64 { +matrix4_from_trs_f64 :: proc "contextless" (t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4f64 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) @@ -1727,15 +1727,15 @@ matrix4_from_trs :: proc{ @(require_results) -matrix4_inverse_f16 :: proc(m: Matrix4f16) -> Matrix4f16 { +matrix4_inverse_f16 :: proc "contextless" (m: Matrix4f16) -> Matrix4f16 { return transpose(matrix4_inverse_transpose(m)) } @(require_results) -matrix4_inverse_f32 :: proc(m: Matrix4f32) -> Matrix4f32 { +matrix4_inverse_f32 :: proc "contextless" (m: Matrix4f32) -> Matrix4f32 { return transpose(matrix4_inverse_transpose(m)) } @(require_results) -matrix4_inverse_f64 :: proc(m: Matrix4f64) -> Matrix4f64 { +matrix4_inverse_f64 :: proc "contextless" (m: Matrix4f64) -> Matrix4f64 { return transpose(matrix4_inverse_transpose(m)) } matrix4_inverse :: proc{ @@ -1746,7 +1746,7 @@ matrix4_inverse :: proc{ @(require_results) -matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { +matrix4_minor_f16 :: proc "contextless" (m: Matrix4f16, c, r: int) -> f16 { cut_down: Matrix3f16 for i in 0..<3 { col := i if i < c else i+1 @@ -1758,7 +1758,7 @@ matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { return matrix3_determinant(cut_down) } @(require_results) -matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { +matrix4_minor_f32 :: proc "contextless" (m: Matrix4f32, c, r: int) -> f32 { cut_down: Matrix3f32 for i in 0..<3 { col := i if i < c else i+1 @@ -1770,7 +1770,7 @@ matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { return matrix3_determinant(cut_down) } @(require_results) -matrix4_minor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { +matrix4_minor_f64 :: proc "contextless" (m: Matrix4f64, c, r: int) -> f64 { cut_down: Matrix3f64 for i in 0..<3 { col := i if i < c else i+1 @@ -1789,21 +1789,21 @@ matrix4_minor :: proc{ @(require_results) -matrix4_cofactor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { +matrix4_cofactor_f16 :: proc "contextless" (m: Matrix4f16, c, r: int) -> f16 { sign, minor: f16 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } @(require_results) -matrix4_cofactor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { +matrix4_cofactor_f32 :: proc "contextless" (m: Matrix4f32, c, r: int) -> f32 { sign, minor: f32 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } @(require_results) -matrix4_cofactor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { +matrix4_cofactor_f64 :: proc "contextless" (m: Matrix4f64, c, r: int) -> f64 { sign, minor: f64 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) @@ -1817,7 +1817,7 @@ matrix4_cofactor :: proc{ @(require_results) -matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { +matrix4_adjoint_f16 :: proc "contextless" (m: Matrix4f16) -> (adjoint: Matrix4f16) { for i in 0..<4 { for j in 0..<4 { adjoint[i][j] = matrix4_cofactor(m, i, j) @@ -1826,7 +1826,7 @@ matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { return } @(require_results) -matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { +matrix4_adjoint_f32 :: proc "contextless" (m: Matrix4f32) -> (adjoint: Matrix4f32) { for i in 0..<4 { for j in 0..<4 { adjoint[i][j] = matrix4_cofactor(m, i, j) @@ -1835,7 +1835,7 @@ matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { return } @(require_results) -matrix4_adjoint_f64 :: proc(m: Matrix4f64) -> (adjoint: Matrix4f64) { +matrix4_adjoint_f64 :: proc "contextless" (m: Matrix4f64) -> (adjoint: Matrix4f64) { for i in 0..<4 { for j in 0..<4 { adjoint[i][j] = matrix4_cofactor(m, i, j) @@ -1851,7 +1851,7 @@ matrix4_adjoint :: proc{ @(require_results) -matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { +matrix4_determinant_f16 :: proc "contextless" (m: Matrix4f16) -> (determinant: f16) { adjoint := matrix4_adjoint(m) for i in 0..<4 { determinant += m[i][0] * adjoint[i][0] @@ -1859,7 +1859,7 @@ matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { return } @(require_results) -matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { +matrix4_determinant_f32 :: proc "contextless" (m: Matrix4f32) -> (determinant: f32) { adjoint := matrix4_adjoint(m) for i in 0..<4 { determinant += m[i][0] * adjoint[i][0] @@ -1867,7 +1867,7 @@ matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { return } @(require_results) -matrix4_determinant_f64 :: proc(m: Matrix4f64) -> (determinant: f64) { +matrix4_determinant_f64 :: proc "contextless" (m: Matrix4f64) -> (determinant: f64) { adjoint := matrix4_adjoint(m) for i in 0..<4 { determinant += m[i][0] * adjoint[i][0] @@ -1882,7 +1882,7 @@ matrix4_determinant :: proc{ @(require_results) -matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matrix4f16) { +matrix4_inverse_transpose_f16 :: proc "contextless" (m: Matrix4f16) -> (inverse_transpose: Matrix4f16) { adjoint := matrix4_adjoint(m) determinant: f16 = 0 for i in 0..<4 { @@ -1897,7 +1897,7 @@ matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matr return } @(require_results) -matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matrix4f32) { +matrix4_inverse_transpose_f32 :: proc "contextless" (m: Matrix4f32) -> (inverse_transpose: Matrix4f32) { adjoint := matrix4_adjoint(m) determinant: f32 = 0 for i in 0..<4 { @@ -1912,7 +1912,7 @@ matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matr return } @(require_results) -matrix4_inverse_transpose_f64 :: proc(m: Matrix4f64) -> (inverse_transpose: Matrix4f64) { +matrix4_inverse_transpose_f64 :: proc "contextless" (m: Matrix4f64) -> (inverse_transpose: Matrix4f64) { adjoint := matrix4_adjoint(m) determinant: f64 = 0 for i in 0..<4 { @@ -1934,7 +1934,7 @@ matrix4_inverse_transpose :: proc{ @(require_results) -matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { +matrix4_translate_f16 :: proc "contextless" (v: Vector3f16) -> Matrix4f16 { m := MATRIX4F16_IDENTITY m[3][0] = v[0] m[3][1] = v[1] @@ -1942,7 +1942,7 @@ matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { return m } @(require_results) -matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { +matrix4_translate_f32 :: proc "contextless" (v: Vector3f32) -> Matrix4f32 { m := MATRIX4F32_IDENTITY m[3][0] = v[0] m[3][1] = v[1] @@ -1950,7 +1950,7 @@ matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { return m } @(require_results) -matrix4_translate_f64 :: proc(v: Vector3f64) -> Matrix4f64 { +matrix4_translate_f64 :: proc "contextless" (v: Vector3f64) -> Matrix4f64 { m := MATRIX4F64_IDENTITY m[3][0] = v[0] m[3][1] = v[1] @@ -1965,7 +1965,7 @@ matrix4_translate :: proc{ @(require_results) -matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { +matrix4_rotate_f16 :: proc "contextless" (angle_radians: f16, v: Vector3f16) -> Matrix4f16 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1992,7 +1992,7 @@ matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { return rot } @(require_results) -matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { +matrix4_rotate_f32 :: proc "contextless" (angle_radians: f32, v: Vector3f32) -> Matrix4f32 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -2019,7 +2019,7 @@ matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { return rot } @(require_results) -matrix4_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> Matrix4f64 { +matrix4_rotate_f64 :: proc "contextless" (angle_radians: f64, v: Vector3f64) -> Matrix4f64 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -2053,7 +2053,7 @@ matrix4_rotate :: proc{ @(require_results) -matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { +matrix4_scale_f16 :: proc "contextless" (v: Vector3f16) -> (m: Matrix4f16) { m[0][0] = v[0] m[1][1] = v[1] m[2][2] = v[2] @@ -2061,7 +2061,7 @@ matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { return } @(require_results) -matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { +matrix4_scale_f32 :: proc "contextless" (v: Vector3f32) -> (m: Matrix4f32) { m[0][0] = v[0] m[1][1] = v[1] m[2][2] = v[2] @@ -2069,7 +2069,7 @@ matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { return } @(require_results) -matrix4_scale_f64 :: proc(v: Vector3f64) -> (m: Matrix4f64) { +matrix4_scale_f64 :: proc "contextless" (v: Vector3f64) -> (m: Matrix4f64) { m[0][0] = v[0] m[1][1] = v[1] m[2][2] = v[2] @@ -2084,7 +2084,7 @@ matrix4_scale :: proc{ @(require_results) -matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { +matrix4_look_at_f16 :: proc "contextless" (eye, centre, up: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -2099,7 +2099,7 @@ matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> } } @(require_results) -matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { +matrix4_look_at_f32 :: proc "contextless" (eye, centre, up: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -2114,7 +2114,7 @@ matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> } } @(require_results) -matrix4_look_at_f64 :: proc(eye, centre, up: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { +matrix4_look_at_f64 :: proc "contextless" (eye, centre, up: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f := normalize(centre - eye) s := normalize(cross(f, up)) u := cross(s, f) @@ -2136,7 +2136,7 @@ matrix4_look_at :: proc{ @(require_results) -matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { +matrix4_look_at_from_fru_f16 :: proc "contextless" (eye, f, r, u: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f, s, u := f, r, u f = normalize(f) s = normalize(s) @@ -2151,7 +2151,7 @@ matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := tr } } @(require_results) -matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { +matrix4_look_at_from_fru_f32 :: proc "contextless" (eye, f, r, u: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f, s, u := f, r, u f = normalize(f) s = normalize(s) @@ -2166,7 +2166,7 @@ matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := tr } } @(require_results) -matrix4_look_at_from_fru_f64 :: proc(eye, f, r, u: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { +matrix4_look_at_from_fru_f64 :: proc "contextless" (eye, f, r, u: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f, s, u := f, r, u f = normalize(f) s = normalize(s) @@ -2188,7 +2188,7 @@ matrix4_look_at_from_fru :: proc{ @(require_results) -matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { +matrix4_perspective_f16 :: proc "contextless" (fovy, aspect, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2203,7 +2203,7 @@ matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := tru return } @(require_results) -matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { +matrix4_perspective_f32 :: proc "contextless" (fovy, aspect, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2218,7 +2218,7 @@ matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := tru return } @(require_results) -matrix4_perspective_f64 :: proc(fovy, aspect, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { +matrix4_perspective_f64 :: proc "contextless" (fovy, aspect, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2241,7 +2241,7 @@ matrix4_perspective :: proc{ @(require_results) -matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { +matrix_ortho3d_f16 :: proc "contextless" (left, right, bottom, top, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) m[2, 2] = +2 / (far - near) @@ -2257,7 +2257,7 @@ matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis return } @(require_results) -matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { +matrix_ortho3d_f32 :: proc "contextless" (left, right, bottom, top, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) m[2, 2] = +2 / (far - near) @@ -2273,7 +2273,7 @@ matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis return } @(require_results) -matrix_ortho3d_f64 :: proc(left, right, bottom, top, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { +matrix_ortho3d_f64 :: proc "contextless" (left, right, bottom, top, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) m[2, 2] = +2 / (far - near) @@ -2297,7 +2297,7 @@ matrix_ortho3d :: proc{ @(require_results) -matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := true) -> (m: Matrix4f16) { +matrix4_infinite_perspective_f16 :: proc "contextless" (fovy, aspect, near: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2312,7 +2312,7 @@ matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := return } @(require_results) -matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := true) -> (m: Matrix4f32) { +matrix4_infinite_perspective_f32 :: proc "contextless" (fovy, aspect, near: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2327,7 +2327,7 @@ matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := return } @(require_results) -matrix4_infinite_perspective_f64 :: proc(fovy, aspect, near: f64, flip_z_axis := true) -> (m: Matrix4f64) { +matrix4_infinite_perspective_f64 :: proc "contextless" (fovy, aspect, near: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) m[1, 1] = 1 / (tan_half_fovy) @@ -2350,19 +2350,19 @@ matrix4_infinite_perspective :: proc{ @(require_results) -matrix2_from_scalar_f16 :: proc(f: f16) -> (m: Matrix2f16) { +matrix2_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix2f16) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } @(require_results) -matrix2_from_scalar_f32 :: proc(f: f32) -> (m: Matrix2f32) { +matrix2_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix2f32) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } @(require_results) -matrix2_from_scalar_f64 :: proc(f: f64) -> (m: Matrix2f64) { +matrix2_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix2f64) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return @@ -2375,21 +2375,21 @@ matrix2_from_scalar :: proc{ @(require_results) -matrix3_from_scalar_f16 :: proc(f: f16) -> (m: Matrix3f16) { +matrix3_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix3f16) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } @(require_results) -matrix3_from_scalar_f32 :: proc(f: f32) -> (m: Matrix3f32) { +matrix3_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix3f32) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } @(require_results) -matrix3_from_scalar_f64 :: proc(f: f64) -> (m: Matrix3f64) { +matrix3_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix3f64) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f @@ -2403,7 +2403,7 @@ matrix3_from_scalar :: proc{ @(require_results) -matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { +matrix4_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: Matrix4f16) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 m[0, 2], m[1, 2], m[2, 2], m[3, 2] = 0, 0, f, 0 @@ -2411,7 +2411,7 @@ matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { return } @(require_results) -matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { +matrix4_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: Matrix4f32) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 m[0, 2], m[1, 2], m[2, 2], m[3, 2] = 0, 0, f, 0 @@ -2419,7 +2419,7 @@ matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { return } @(require_results) -matrix4_from_scalar_f64 :: proc(f: f64) -> (m: Matrix4f64) { +matrix4_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: Matrix4f64) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 m[0, 2], m[1, 2], m[2, 2], m[3, 2] = 0, 0, f, 0 @@ -2434,19 +2434,19 @@ matrix4_from_scalar :: proc{ @(require_results) -matrix2_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix2f16) { +matrix2_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } @(require_results) -matrix2_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix2f32) { +matrix2_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } @(require_results) -matrix2_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix2f64) { +matrix2_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return @@ -2459,19 +2459,19 @@ matrix2_from_matrix3 :: proc{ @(require_results) -matrix2_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix2f16) { +matrix2_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } @(require_results) -matrix2_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix2f32) { +matrix2_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } @(require_results) -matrix2_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix2f64) { +matrix2_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return @@ -2484,21 +2484,21 @@ matrix2_from_matrix4 :: proc{ @(require_results) -matrix3_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix3f16) { +matrix3_from_matrix2_f16 :: proc "contextless" (m: Matrix2f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } @(require_results) -matrix3_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix3f32) { +matrix3_from_matrix2_f32 :: proc "contextless" (m: Matrix2f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } @(require_results) -matrix3_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix3f64) { +matrix3_from_matrix2_f64 :: proc "contextless" (m: Matrix2f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 @@ -2512,21 +2512,21 @@ matrix3_from_matrix2 :: proc{ @(require_results) -matrix3_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix3f16) { +matrix3_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } @(require_results) -matrix3_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix3f32) { +matrix3_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } @(require_results) -matrix3_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix3f64) { +matrix3_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] @@ -2540,7 +2540,7 @@ matrix3_from_matrix4 :: proc{ @(require_results) -matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { +matrix4_from_matrix2_f16 :: proc "contextless" (m: Matrix2f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = 0, 0, 1, 0 @@ -2548,7 +2548,7 @@ matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { return } @(require_results) -matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { +matrix4_from_matrix2_f32 :: proc "contextless" (m: Matrix2f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = 0, 0, 1, 0 @@ -2556,7 +2556,7 @@ matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { return } @(require_results) -matrix4_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix4f64) { +matrix4_from_matrix2_f64 :: proc "contextless" (m: Matrix2f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = 0, 0, 1, 0 @@ -2571,7 +2571,7 @@ matrix4_from_matrix2 :: proc{ @(require_results) -matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { +matrix4_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = m[0, 2], m[1, 2], m[2, 2], 0 @@ -2579,7 +2579,7 @@ matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { return } @(require_results) -matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { +matrix4_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = m[0, 2], m[1, 2], m[2, 2], 0 @@ -2587,7 +2587,7 @@ matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { return } @(require_results) -matrix4_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix4f64) { +matrix4_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 r[0, 2], r[1, 2], r[2, 2], r[3, 2] = m[0, 2], m[1, 2], m[2, 2], 0 @@ -2602,17 +2602,17 @@ matrix4_from_matrix3 :: proc{ @(require_results) -quaternion_from_scalar_f16 :: proc(f: f16) -> (q: Quaternionf16) { +quaternion_from_scalar_f16 :: proc "contextless" (f: f16) -> (q: Quaternionf16) { q.w = f return } @(require_results) -quaternion_from_scalar_f32 :: proc(f: f32) -> (q: Quaternionf32) { +quaternion_from_scalar_f32 :: proc "contextless" (f: f32) -> (q: Quaternionf32) { q.w = f return } @(require_results) -quaternion_from_scalar_f64 :: proc(f: f64) -> (q: Quaternionf64) { +quaternion_from_scalar_f64 :: proc "contextless" (f: f64) -> (q: Quaternionf64) { q.w = f return } @@ -2673,7 +2673,7 @@ to_quaternion :: proc{ @(require_results) -matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { +matrix2_orthonormalize_f16 :: proc "contextless" (m: Matrix2f16) -> (r: Matrix2f16) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2683,7 +2683,7 @@ matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { return } @(require_results) -matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { +matrix2_orthonormalize_f32 :: proc "contextless" (m: Matrix2f32) -> (r: Matrix2f32) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2693,7 +2693,7 @@ matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { return } @(require_results) -matrix2_orthonormalize_f64 :: proc(m: Matrix2f64) -> (r: Matrix2f64) { +matrix2_orthonormalize_f64 :: proc "contextless" (m: Matrix2f64) -> (r: Matrix2f64) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2710,7 +2710,7 @@ matrix2_orthonormalize :: proc{ @(require_results) -matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { +matrix3_orthonormalize_f16 :: proc "contextless" (m: Matrix3f16) -> (r: Matrix3f16) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2725,7 +2725,7 @@ matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { return } @(require_results) -matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { +matrix3_orthonormalize_f32 :: proc "contextless" (m: Matrix3f32) -> (r: Matrix3f32) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2740,7 +2740,7 @@ matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { return } @(require_results) -matrix3_orthonormalize_f64 :: proc(m: Matrix3f64) -> (r: Matrix3f64) { +matrix3_orthonormalize_f64 :: proc "contextless" (m: Matrix3f64) -> (r: Matrix3f64) { r[0] = normalize(m[0]) d0 := dot(r[0], r[1]) @@ -2762,15 +2762,15 @@ matrix3_orthonormalize :: proc{ @(require_results) -vector3_orthonormalize_f16 :: proc(x, y: Vector3f16) -> (z: Vector3f16) { +vector3_orthonormalize_f16 :: proc "contextless" (x, y: Vector3f16) -> (z: Vector3f16) { return normalize(x - y * dot(y, x)) } @(require_results) -vector3_orthonormalize_f32 :: proc(x, y: Vector3f32) -> (z: Vector3f32) { +vector3_orthonormalize_f32 :: proc "contextless" (x, y: Vector3f32) -> (z: Vector3f32) { return normalize(x - y * dot(y, x)) } @(require_results) -vector3_orthonormalize_f64 :: proc(x, y: Vector3f64) -> (z: Vector3f64) { +vector3_orthonormalize_f64 :: proc "contextless" (x, y: Vector3f64) -> (z: Vector3f64) { return normalize(x - y * dot(y, x)) } vector3_orthonormalize :: proc{ @@ -2788,7 +2788,7 @@ orthonormalize :: proc{ @(require_results) -matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { +matrix4_orientation_f16 :: proc "contextless" (normal, up: Vector3f16) -> Matrix4f16 { if all(equal(normal, up)) { return MATRIX4F16_IDENTITY } @@ -2799,7 +2799,7 @@ matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { return matrix4_rotate(angle, rotation_axis) } @(require_results) -matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { +matrix4_orientation_f32 :: proc "contextless" (normal, up: Vector3f32) -> Matrix4f32 { if all(equal(normal, up)) { return MATRIX4F32_IDENTITY } @@ -2810,7 +2810,7 @@ matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { return matrix4_rotate(angle, rotation_axis) } @(require_results) -matrix4_orientation_f64 :: proc(normal, up: Vector3f64) -> Matrix4f64 { +matrix4_orientation_f64 :: proc "contextless" (normal, up: Vector3f64) -> Matrix4f64 { if all(equal(normal, up)) { return MATRIX4F64_IDENTITY } @@ -2828,7 +2828,7 @@ matrix4_orientation :: proc{ @(require_results) -euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { +euclidean_from_polar_f16 :: proc "contextless" (polar: Vector2f16) -> Vector3f16 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) cy, sy := math.cos(longitude), math.sin(longitude) @@ -2840,7 +2840,7 @@ euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { } } @(require_results) -euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { +euclidean_from_polar_f32 :: proc "contextless" (polar: Vector2f32) -> Vector3f32 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) cy, sy := math.cos(longitude), math.sin(longitude) @@ -2852,7 +2852,7 @@ euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { } } @(require_results) -euclidean_from_polar_f64 :: proc(polar: Vector2f64) -> Vector3f64 { +euclidean_from_polar_f64 :: proc "contextless" (polar: Vector2f64) -> Vector3f64 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) cy, sy := math.cos(longitude), math.sin(longitude) @@ -2871,7 +2871,7 @@ euclidean_from_polar :: proc{ @(require_results) -polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { +polar_from_euclidean_f16 :: proc "contextless" (euclidean: Vector3f16) -> Vector3f16 { n := length(euclidean) tmp := euclidean / n @@ -2884,7 +2884,7 @@ polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { } } @(require_results) -polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { +polar_from_euclidean_f32 :: proc "contextless" (euclidean: Vector3f32) -> Vector3f32 { n := length(euclidean) tmp := euclidean / n @@ -2897,7 +2897,7 @@ polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { } } @(require_results) -polar_from_euclidean_f64 :: proc(euclidean: Vector3f64) -> Vector3f64 { +polar_from_euclidean_f64 :: proc "contextless" (euclidean: Vector3f64) -> Vector3f64 { n := length(euclidean) tmp := euclidean / n diff --git a/core/math/linalg/specific_euler_angles_f16.odin b/core/math/linalg/specific_euler_angles_f16.odin index e26860882..bacda163e 100644 --- a/core/math/linalg/specific_euler_angles_f16.odin +++ b/core/math/linalg/specific_euler_angles_f16.odin @@ -3,7 +3,7 @@ package linalg import "core:math" @(require_results) -euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { +euler_angles_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix3(m) @@ -21,7 +21,7 @@ euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { +euler_angles_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4(m) @@ -39,7 +39,7 @@ euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { +euler_angles_from_quaternion_f16 :: proc "contextless" (m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion(m) @@ -58,7 +58,7 @@ euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Or } @(require_results) -matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3f16) { +matrix3_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3f16) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix3_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -76,7 +76,7 @@ matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) return } @(require_results) -matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4f16) { +matrix4_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4f16) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix4_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -95,7 +95,7 @@ matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) } @(require_results) -quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 { +quaternion_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y Z :: quaternion_from_euler_angle_z @@ -124,20 +124,20 @@ quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Ord // Quaternionf16s @(require_results) -quaternion_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (q: Quaternionf16) { +quaternion_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_x, {1, 0, 0}) } @(require_results) -quaternion_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (q: Quaternionf16) { +quaternion_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_y, {0, 1, 0}) } @(require_results) -quaternion_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (q: Quaternionf16) { +quaternion_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_z, {0, 0, 1}) } @(require_results) -quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf16 { +quaternion_from_pitch_yaw_roll_f16 :: proc "contextless" (pitch, yaw, roll: f16) -> Quaternionf16 { a, b, c := pitch, yaw, roll ca, sa := math.cos(a*0.5), math.sin(a*0.5) @@ -153,12 +153,12 @@ quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf } @(require_results) -roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { +roll_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } @(require_results) -pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { +pitch_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -170,13 +170,13 @@ pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { } @(require_results) -yaw_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { +yaw_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> f16 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } @(require_results) -pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, roll: f16) { +pitch_yaw_roll_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (pitch, yaw, roll: f16) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) roll = roll_from_quaternion(q) @@ -184,51 +184,51 @@ pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, rol } @(require_results) -euler_angles_xyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_xyz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_yxz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_xzx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_xyx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_yxy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_yzy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_zyz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_zxz_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_xzy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_yzx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_zyx_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { +euler_angles_zxy_from_quaternion_f16 :: proc "contextless" (q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -237,7 +237,7 @@ euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f @(require_results) -matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -247,7 +247,7 @@ matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { return } @(require_results) -matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (m: Matrix3f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -257,7 +257,7 @@ matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { return } @(require_results) -matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (m: Matrix3f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -269,7 +269,7 @@ matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { @(require_results) -matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3f16) { +matrix3_from_derived_euler_angle_x_f16 :: proc "contextless" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -280,7 +280,7 @@ matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: return } @(require_results) -matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3f16) { +matrix3_from_derived_euler_angle_y_f16 :: proc "contextless" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -291,7 +291,7 @@ matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: return } @(require_results) -matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3f16) { +matrix3_from_derived_euler_angle_z_f16 :: proc "contextless" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -304,7 +304,7 @@ matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: @(require_results) -matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xy_f16 :: proc "contextless" (angle_x, angle_y: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -320,7 +320,7 @@ matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f1 @(require_results) -matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yx_f16 :: proc "contextless" (angle_y, angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -335,25 +335,25 @@ matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f1 } @(require_results) -matrix3_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xz_f16 :: proc "contextless" (angle_x, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zx_f16 :: proc "contextless" (angle_z, angle_x: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } @(require_results) -matrix3_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yz_f16 :: proc "contextless" (angle_y, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zy_f16 :: proc "contextless" (angle_z, angle_y: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } @(require_results) -matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -374,7 +374,7 @@ matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -395,7 +395,7 @@ matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f } @(require_results) -matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -416,7 +416,7 @@ matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -437,7 +437,7 @@ matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -458,7 +458,7 @@ matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -479,7 +479,7 @@ matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -500,7 +500,7 @@ matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zxz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -522,7 +522,7 @@ matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { @(require_results) -matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_xzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -543,7 +543,7 @@ matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_yzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -564,7 +564,7 @@ matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -585,7 +585,7 @@ matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } @(require_results) -matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { +matrix3_from_euler_angles_zxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -607,7 +607,7 @@ matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { @(require_results) -matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { +matrix3_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -628,7 +628,7 @@ matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16 } @(require_results) -euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_xyz_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -642,7 +642,7 @@ euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_yxz_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -656,7 +656,7 @@ euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_xzx_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -670,7 +670,7 @@ euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_xyx_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -684,7 +684,7 @@ euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_yxy_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -698,7 +698,7 @@ euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_yzy_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -711,7 +711,7 @@ euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } @(require_results) -euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_zyz_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -725,7 +725,7 @@ euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_zxz_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -739,7 +739,7 @@ euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_xzy_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -753,7 +753,7 @@ euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_yzx_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -767,7 +767,7 @@ euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_zyx_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -781,7 +781,7 @@ euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { +euler_angles_zxy_from_matrix3_f16 :: proc "contextless" (m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) @@ -799,7 +799,7 @@ euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { @(require_results) -matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -810,7 +810,7 @@ matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { return } @(require_results) -matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (m: Matrix4f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -821,7 +821,7 @@ matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { return } @(require_results) -matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (m: Matrix4f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -834,7 +834,7 @@ matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { @(require_results) -matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4f16) { +matrix4_from_derived_euler_angle_x_f16 :: proc "contextless" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -846,7 +846,7 @@ matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: return } @(require_results) -matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4f16) { +matrix4_from_derived_euler_angle_y_f16 :: proc "contextless" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -858,7 +858,7 @@ matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: return } @(require_results) -matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4f16) { +matrix4_from_derived_euler_angle_z_f16 :: proc "contextless" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -872,7 +872,7 @@ matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: @(require_results) -matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xy_f16 :: proc "contextless" (angle_x, angle_y: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -889,7 +889,7 @@ matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f1 @(require_results) -matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yx_f16 :: proc "contextless" (angle_y, angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -905,25 +905,25 @@ matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f1 } @(require_results) -matrix4_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xz_f16 :: proc "contextless" (angle_x, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zx_f16 :: proc "contextless" (angle_z, angle_x: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } @(require_results) -matrix4_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yz_f16 :: proc "contextless" (angle_y, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zy_f16 :: proc "contextless" (angle_z, angle_y: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } @(require_results) -matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -951,7 +951,7 @@ matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -979,7 +979,7 @@ matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f } @(require_results) -matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1007,7 +1007,7 @@ matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1035,7 +1035,7 @@ matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1063,7 +1063,7 @@ matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1091,7 +1091,7 @@ matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1119,7 +1119,7 @@ matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zxz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1148,7 +1148,7 @@ matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { @(require_results) -matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_xzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1176,7 +1176,7 @@ matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_yzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1204,7 +1204,7 @@ matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1232,7 +1232,7 @@ matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } @(require_results) -matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { +matrix4_from_euler_angles_zxy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1261,7 +1261,7 @@ matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { @(require_results) -matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { +matrix4_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -1289,7 +1289,7 @@ matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16 } @(require_results) -euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_xyz_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -1303,7 +1303,7 @@ euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_yxz_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -1317,7 +1317,7 @@ euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_xzx_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1331,7 +1331,7 @@ euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_xyx_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1345,7 +1345,7 @@ euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_yxy_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1359,7 +1359,7 @@ euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_yzy_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1372,7 +1372,7 @@ euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } @(require_results) -euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_zyz_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1386,7 +1386,7 @@ euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_zxz_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1400,7 +1400,7 @@ euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_xzy_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -1414,7 +1414,7 @@ euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_yzx_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -1428,7 +1428,7 @@ euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_zyx_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -1442,7 +1442,7 @@ euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { } @(require_results) -euler_angles_zxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { +euler_angles_zxy_from_matrix4_f16 :: proc "contextless" (m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) diff --git a/core/math/linalg/specific_euler_angles_f32.odin b/core/math/linalg/specific_euler_angles_f32.odin index 3cd076f0b..b9957034f 100644 --- a/core/math/linalg/specific_euler_angles_f32.odin +++ b/core/math/linalg/specific_euler_angles_f32.odin @@ -3,7 +3,7 @@ package linalg import "core:math" @(require_results) -euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { +euler_angles_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix3(m) @@ -21,7 +21,7 @@ euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { +euler_angles_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4(m) @@ -39,7 +39,7 @@ euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { +euler_angles_from_quaternion_f32 :: proc "contextless" (m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion(m) @@ -58,7 +58,7 @@ euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Or } @(require_results) -matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3f32) { +matrix3_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3f32) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix3_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -76,7 +76,7 @@ matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) return } @(require_results) -matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4f32) { +matrix4_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4f32) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix4_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -95,7 +95,7 @@ matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) } @(require_results) -quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 { +quaternion_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y Z :: quaternion_from_euler_angle_z @@ -124,20 +124,20 @@ quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Ord // Quaternionf32s @(require_results) -quaternion_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (q: Quaternionf32) { +quaternion_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_x, {1, 0, 0}) } @(require_results) -quaternion_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (q: Quaternionf32) { +quaternion_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_y, {0, 1, 0}) } @(require_results) -quaternion_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (q: Quaternionf32) { +quaternion_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_z, {0, 0, 1}) } @(require_results) -quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf32 { +quaternion_from_pitch_yaw_roll_f32 :: proc "contextless" (pitch, yaw, roll: f32) -> Quaternionf32 { a, b, c := pitch, yaw, roll ca, sa := math.cos(a*0.5), math.sin(a*0.5) @@ -153,12 +153,12 @@ quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf } @(require_results) -roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { +roll_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } @(require_results) -pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { +pitch_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -170,13 +170,13 @@ pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { } @(require_results) -yaw_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { +yaw_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> f32 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } @(require_results) -pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, roll: f32) { +pitch_yaw_roll_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (pitch, yaw, roll: f32) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) roll = roll_from_quaternion(q) @@ -184,51 +184,51 @@ pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, rol } @(require_results) -euler_angles_xyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_xyz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_yxz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_xzx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_xyx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_yxy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_yzy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_zyz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_zxz_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_xzy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_yzx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_zyx_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { +euler_angles_zxy_from_quaternion_f32 :: proc "contextless" (q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -237,7 +237,7 @@ euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f @(require_results) -matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -247,7 +247,7 @@ matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { return } @(require_results) -matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (m: Matrix3f32) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -257,7 +257,7 @@ matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { return } @(require_results) -matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (m: Matrix3f32) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -269,7 +269,7 @@ matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { @(require_results) -matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3f32) { +matrix3_from_derived_euler_angle_x_f32 :: proc "contextless" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3f32) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -280,7 +280,7 @@ matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: return } @(require_results) -matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3f32) { +matrix3_from_derived_euler_angle_y_f32 :: proc "contextless" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3f32) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -291,7 +291,7 @@ matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: return } @(require_results) -matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3f32) { +matrix3_from_derived_euler_angle_z_f32 :: proc "contextless" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3f32) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -304,7 +304,7 @@ matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: @(require_results) -matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xy_f32 :: proc "contextless" (angle_x, angle_y: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -320,7 +320,7 @@ matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f3 @(require_results) -matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yx_f32 :: proc "contextless" (angle_y, angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -335,25 +335,25 @@ matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f3 } @(require_results) -matrix3_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xz_f32 :: proc "contextless" (angle_x, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zx_f32 :: proc "contextless" (angle_z, angle_x: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } @(require_results) -matrix3_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yz_f32 :: proc "contextless" (angle_y, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zy_f32 :: proc "contextless" (angle_z, angle_y: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } @(require_results) -matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -374,7 +374,7 @@ matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -395,7 +395,7 @@ matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f } @(require_results) -matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -416,7 +416,7 @@ matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -437,7 +437,7 @@ matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -458,7 +458,7 @@ matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -479,7 +479,7 @@ matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -500,7 +500,7 @@ matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zxz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -522,7 +522,7 @@ matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { @(require_results) -matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_xzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -543,7 +543,7 @@ matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_yzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -564,7 +564,7 @@ matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -585,7 +585,7 @@ matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } @(require_results) -matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { +matrix3_from_euler_angles_zxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -607,7 +607,7 @@ matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { @(require_results) -matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { +matrix3_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -628,7 +628,7 @@ matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32 } @(require_results) -euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_xyz_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -642,7 +642,7 @@ euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_yxz_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -656,7 +656,7 @@ euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_xzx_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -670,7 +670,7 @@ euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_xyx_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -684,7 +684,7 @@ euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_yxy_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -698,7 +698,7 @@ euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_yzy_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -711,7 +711,7 @@ euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } @(require_results) -euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_zyz_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -725,7 +725,7 @@ euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_zxz_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -739,7 +739,7 @@ euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_xzy_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -753,7 +753,7 @@ euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_yzx_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -767,7 +767,7 @@ euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_zyx_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -781,7 +781,7 @@ euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { +euler_angles_zxy_from_matrix3_f32 :: proc "contextless" (m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) @@ -799,7 +799,7 @@ euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { @(require_results) -matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -810,7 +810,7 @@ matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) { return } @(require_results) -matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (m: Matrix4f32) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -821,7 +821,7 @@ matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) { return } @(require_results) -matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (m: Matrix4f32) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -834,7 +834,7 @@ matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) { @(require_results) -matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4f32) { +matrix4_from_derived_euler_angle_x_f32 :: proc "contextless" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4f32) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -846,7 +846,7 @@ matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: return } @(require_results) -matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4f32) { +matrix4_from_derived_euler_angle_y_f32 :: proc "contextless" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4f32) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -858,7 +858,7 @@ matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: return } @(require_results) -matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4f32) { +matrix4_from_derived_euler_angle_z_f32 :: proc "contextless" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4f32) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -872,7 +872,7 @@ matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: @(require_results) -matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xy_f32 :: proc "contextless" (angle_x, angle_y: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -889,7 +889,7 @@ matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f3 @(require_results) -matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yx_f32 :: proc "contextless" (angle_y, angle_x: f32) -> (m: Matrix4f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -905,25 +905,25 @@ matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f3 } @(require_results) -matrix4_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xz_f32 :: proc "contextless" (angle_x, angle_z: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zx_f32 :: proc "contextless" (angle_z, angle_x: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } @(require_results) -matrix4_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yz_f32 :: proc "contextless" (angle_y, angle_z: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zy_f32 :: proc "contextless" (angle_z, angle_y: f32) -> (m: Matrix4f32) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } @(require_results) -matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -951,7 +951,7 @@ matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -979,7 +979,7 @@ matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f } @(require_results) -matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1007,7 +1007,7 @@ matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1035,7 +1035,7 @@ matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1063,7 +1063,7 @@ matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1091,7 +1091,7 @@ matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1119,7 +1119,7 @@ matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zxz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1148,7 +1148,7 @@ matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { @(require_results) -matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_xzy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1176,7 +1176,7 @@ matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_yzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1204,7 +1204,7 @@ matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1232,7 +1232,7 @@ matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } @(require_results) -matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { +matrix4_from_euler_angles_zxy_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1261,7 +1261,7 @@ matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { @(require_results) -matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { +matrix4_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -1289,7 +1289,7 @@ matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32 } @(require_results) -euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_xyz_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -1303,7 +1303,7 @@ euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_yxz_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -1317,7 +1317,7 @@ euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_xzx_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1331,7 +1331,7 @@ euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_xyx_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1345,7 +1345,7 @@ euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_yxy_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1359,7 +1359,7 @@ euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_yzy_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1372,7 +1372,7 @@ euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } @(require_results) -euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_zyz_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1386,7 +1386,7 @@ euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_zxz_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1400,7 +1400,7 @@ euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_xzy_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -1414,7 +1414,7 @@ euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_yzx_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -1428,7 +1428,7 @@ euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_zyx_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -1442,7 +1442,7 @@ euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { } @(require_results) -euler_angles_zxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { +euler_angles_zxy_from_matrix4_f32 :: proc "contextless" (m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) diff --git a/core/math/linalg/specific_euler_angles_f64.odin b/core/math/linalg/specific_euler_angles_f64.odin index a97f1757d..8001d080a 100644 --- a/core/math/linalg/specific_euler_angles_f64.odin +++ b/core/math/linalg/specific_euler_angles_f64.odin @@ -3,7 +3,7 @@ package linalg import "core:math" @(require_results) -euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { +euler_angles_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix3(m) @@ -21,7 +21,7 @@ euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { +euler_angles_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4(m) @@ -39,7 +39,7 @@ euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) - return } @(require_results) -euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { +euler_angles_from_quaternion_f64 :: proc "contextless" (m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion(m) @@ -58,7 +58,7 @@ euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Or } @(require_results) -matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3f64) { +matrix3_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3f64) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix3_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -76,7 +76,7 @@ matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) return } @(require_results) -matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4f64) { +matrix4_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4f64) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); case .XZY: return matrix4_from_euler_angles_xzy(t1, t2, t3) // m1, m2, m3 = X(t1), Z(t2), Y(t3); @@ -95,7 +95,7 @@ matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) } @(require_results) -quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 { +quaternion_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y Z :: quaternion_from_euler_angle_z @@ -124,20 +124,20 @@ quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Ord // Quaternionf64s @(require_results) -quaternion_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (q: Quaternionf64) { +quaternion_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_x, {1, 0, 0}) } @(require_results) -quaternion_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (q: Quaternionf64) { +quaternion_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_y, {0, 1, 0}) } @(require_results) -quaternion_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (q: Quaternionf64) { +quaternion_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_z, {0, 0, 1}) } @(require_results) -quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf64 { +quaternion_from_pitch_yaw_roll_f64 :: proc "contextless" (pitch, yaw, roll: f64) -> Quaternionf64 { a, b, c := pitch, yaw, roll ca, sa := math.cos(a*0.5), math.sin(a*0.5) @@ -153,12 +153,12 @@ quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf } @(require_results) -roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { +roll_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 { return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z) } @(require_results) -pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { +pitch_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 { y := 2 * (q.y*q.z + q.w*q.w) x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z @@ -170,13 +170,13 @@ pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { } @(require_results) -yaw_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { +yaw_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> f64 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } @(require_results) -pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, roll: f64) { +pitch_yaw_roll_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (pitch, yaw, roll: f64) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) roll = roll_from_quaternion(q) @@ -184,51 +184,51 @@ pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, rol } @(require_results) -euler_angles_xyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_xyz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_yxz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_xzx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_xyx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_yxy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_yzy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_zyz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_zxz_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_xzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_xzy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_yzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_yzx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_zyx_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } @(require_results) -euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { +euler_angles_zxy_from_quaternion_f64 :: proc "contextless" (q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -237,7 +237,7 @@ euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f @(require_results) -matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -247,7 +247,7 @@ matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { return } @(require_results) -matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (m: Matrix3f64) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -257,7 +257,7 @@ matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { return } @(require_results) -matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (m: Matrix3f64) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -269,7 +269,7 @@ matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { @(require_results) -matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3f64) { +matrix3_from_derived_euler_angle_x_f64 :: proc "contextless" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3f64) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -280,7 +280,7 @@ matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: return } @(require_results) -matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3f64) { +matrix3_from_derived_euler_angle_y_f64 :: proc "contextless" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3f64) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -291,7 +291,7 @@ matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: return } @(require_results) -matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3f64) { +matrix3_from_derived_euler_angle_z_f64 :: proc "contextless" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3f64) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -304,7 +304,7 @@ matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: @(require_results) -matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xy_f64 :: proc "contextless" (angle_x, angle_y: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -320,7 +320,7 @@ matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f6 @(require_results) -matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yx_f64 :: proc "contextless" (angle_y, angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -335,25 +335,25 @@ matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f6 } @(require_results) -matrix3_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xz_f64 :: proc "contextless" (angle_x, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zx_f64 :: proc "contextless" (angle_z, angle_x: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } @(require_results) -matrix3_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yz_f64 :: proc "contextless" (angle_y, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } @(require_results) -matrix3_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zy_f64 :: proc "contextless" (angle_z, angle_y: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } @(require_results) -matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -374,7 +374,7 @@ matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -395,7 +395,7 @@ matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f } @(require_results) -matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -416,7 +416,7 @@ matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -437,7 +437,7 @@ matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -458,7 +458,7 @@ matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -479,7 +479,7 @@ matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -500,7 +500,7 @@ matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zxz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -522,7 +522,7 @@ matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { @(require_results) -matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_xzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -543,7 +543,7 @@ matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_yzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -564,7 +564,7 @@ matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -585,7 +585,7 @@ matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } @(require_results) -matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { +matrix3_from_euler_angles_zxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -607,7 +607,7 @@ matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { @(require_results) -matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { +matrix3_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -628,7 +628,7 @@ matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64 } @(require_results) -euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_xyz_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -642,7 +642,7 @@ euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_yxz_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -656,7 +656,7 @@ euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_xzx_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -670,7 +670,7 @@ euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_xyx_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -684,7 +684,7 @@ euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_yxy_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -698,7 +698,7 @@ euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_yzy_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -711,7 +711,7 @@ euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } @(require_results) -euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_zyz_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -725,7 +725,7 @@ euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_zxz_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -739,7 +739,7 @@ euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_xzy_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -753,7 +753,7 @@ euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_yzx_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -767,7 +767,7 @@ euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_zyx_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -781,7 +781,7 @@ euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { +euler_angles_zxy_from_matrix3_f64 :: proc "contextless" (m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) @@ -799,7 +799,7 @@ euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { @(require_results) -matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 m[1, 1] = +cos_x @@ -810,7 +810,7 @@ matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) { return } @(require_results) -matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (m: Matrix4f64) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y m[0, 2] = -sin_y @@ -821,7 +821,7 @@ matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) { return } @(require_results) -matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (m: Matrix4f64) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z m[0, 1] = +sin_z @@ -834,7 +834,7 @@ matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) { @(require_results) -matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4f64) { +matrix4_from_derived_euler_angle_x_f64 :: proc "contextless" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4f64) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x m[0, 0] = 1 @@ -846,7 +846,7 @@ matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: return } @(require_results) -matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4f64) { +matrix4_from_derived_euler_angle_y_f64 :: proc "contextless" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4f64) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y m[0, 0] = +cos_y @@ -858,7 +858,7 @@ matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: return } @(require_results) -matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4f64) { +matrix4_from_derived_euler_angle_z_f64 :: proc "contextless" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4f64) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z m[0, 0] = +cos_z @@ -872,7 +872,7 @@ matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: @(require_results) -matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xy_f64 :: proc "contextless" (angle_x, angle_y: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -889,7 +889,7 @@ matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f6 @(require_results) -matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yx_f64 :: proc "contextless" (angle_y, angle_x: f64) -> (m: Matrix4f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = cos_y @@ -905,25 +905,25 @@ matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f6 } @(require_results) -matrix4_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xz_f64 :: proc "contextless" (angle_x, angle_z: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zx_f64 :: proc "contextless" (angle_z, angle_x: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } @(require_results) -matrix4_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yz_f64 :: proc "contextless" (angle_y, angle_z: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } @(require_results) -matrix4_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zy_f64 :: proc "contextless" (angle_z, angle_y: f64) -> (m: Matrix4f64) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } @(require_results) -matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) c3 := math.cos(-t3) @@ -951,7 +951,7 @@ matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -979,7 +979,7 @@ matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f } @(require_results) -matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1007,7 +1007,7 @@ matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1035,7 +1035,7 @@ matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1063,7 +1063,7 @@ matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1091,7 +1091,7 @@ matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1119,7 +1119,7 @@ matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zxz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1148,7 +1148,7 @@ matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { @(require_results) -matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_xzy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1176,7 +1176,7 @@ matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_yzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1204,7 +1204,7 @@ matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1232,7 +1232,7 @@ matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } @(require_results) -matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { +matrix4_from_euler_angles_zxy_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) c2 := math.cos(t2) @@ -1261,7 +1261,7 @@ matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { @(require_results) -matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { +matrix4_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) cp := math.cos(pitch) @@ -1289,7 +1289,7 @@ matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64 } @(require_results) -euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_xyz_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) T2 := math.atan2(-m[0, 2], C2) @@ -1303,7 +1303,7 @@ euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_yxz_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) T2 := math.atan2(-m[1, 2], C2) @@ -1317,7 +1317,7 @@ euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_xzx_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1331,7 +1331,7 @@ euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_xyx_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) T2 := math.atan2(S2, m[0, 0]) @@ -1345,7 +1345,7 @@ euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_yxy_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1359,7 +1359,7 @@ euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_yzy_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) T2 := math.atan2(S2, m[1, 1]) @@ -1372,7 +1372,7 @@ euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } @(require_results) -euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_zyz_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1386,7 +1386,7 @@ euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_zxz_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) T2 := math.atan2(S2, m[2, 2]) @@ -1400,7 +1400,7 @@ euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_xzy_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) T2 := math.atan2(-m[0, 1], C2) @@ -1414,7 +1414,7 @@ euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_yzx_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) T2 := math.atan2(m[1, 0], C2) @@ -1428,7 +1428,7 @@ euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_zyx_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) T2 := math.atan2(-m[2, 0], C2) @@ -1442,7 +1442,7 @@ euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { } @(require_results) -euler_angles_zxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { +euler_angles_zxy_from_matrix4_f64 :: proc "contextless" (m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) T2 := math.atan2(m[2, 1], C2) diff --git a/core/math/linalg/swizzle.odin b/core/math/linalg/swizzle.odin index 8c2072193..f1dafbeca 100644 --- a/core/math/linalg/swizzle.odin +++ b/core/math/linalg/swizzle.odin @@ -38,141 +38,141 @@ Vector4_Components :: enum u8 { } @(require_results) -scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> f32 { +scalar_f32_swizzle1 :: proc "contextless" (f: f32, c0: Scalar_Components) -> f32 { return f } @(require_results) -scalar_f32_swizzle2 :: proc(f: f32, c0, c1: Scalar_Components) -> Vector2f32 { +scalar_f32_swizzle2 :: proc "contextless" (f: f32, c0, c1: Scalar_Components) -> Vector2f32 { return {f, f} } @(require_results) -scalar_f32_swizzle3 :: proc(f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 { +scalar_f32_swizzle3 :: proc "contextless" (f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 { return {f, f, f} } @(require_results) -scalar_f32_swizzle4 :: proc(f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 { +scalar_f32_swizzle4 :: proc "contextless" (f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 { return {f, f, f, f} } @(require_results) -vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> f32 { +vector2f32_swizzle1 :: proc "contextless" (v: Vector2f32, c0: Vector2_Components) -> f32 { return v[c0] } @(require_results) -vector2f32_swizzle2 :: proc(v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 { +vector2f32_swizzle2 :: proc "contextless" (v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 { return {v[c0], v[c1]} } @(require_results) -vector2f32_swizzle3 :: proc(v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 { +vector2f32_swizzle3 :: proc "contextless" (v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector2f32_swizzle4 :: proc(v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 { +vector2f32_swizzle4 :: proc "contextless" (v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } @(require_results) -vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> f32 { +vector3f32_swizzle1 :: proc "contextless" (v: Vector3f32, c0: Vector3_Components) -> f32 { return v[c0] } @(require_results) -vector3f32_swizzle2 :: proc(v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 { +vector3f32_swizzle2 :: proc "contextless" (v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 { return {v[c0], v[c1]} } @(require_results) -vector3f32_swizzle3 :: proc(v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 { +vector3f32_swizzle3 :: proc "contextless" (v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector3f32_swizzle4 :: proc(v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 { +vector3f32_swizzle4 :: proc "contextless" (v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } @(require_results) -vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> f32 { +vector4f32_swizzle1 :: proc "contextless" (v: Vector4f32, c0: Vector4_Components) -> f32 { return v[c0] } @(require_results) -vector4f32_swizzle2 :: proc(v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 { +vector4f32_swizzle2 :: proc "contextless" (v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 { return {v[c0], v[c1]} } @(require_results) -vector4f32_swizzle3 :: proc(v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 { +vector4f32_swizzle3 :: proc "contextless" (v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector4f32_swizzle4 :: proc(v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 { +vector4f32_swizzle4 :: proc "contextless" (v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } @(require_results) -scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> f64 { +scalar_f64_swizzle1 :: proc "contextless" (f: f64, c0: Scalar_Components) -> f64 { return f } @(require_results) -scalar_f64_swizzle2 :: proc(f: f64, c0, c1: Scalar_Components) -> Vector2f64 { +scalar_f64_swizzle2 :: proc "contextless" (f: f64, c0, c1: Scalar_Components) -> Vector2f64 { return {f, f} } @(require_results) -scalar_f64_swizzle3 :: proc(f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 { +scalar_f64_swizzle3 :: proc "contextless" (f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 { return {f, f, f} } @(require_results) -scalar_f64_swizzle4 :: proc(f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 { +scalar_f64_swizzle4 :: proc "contextless" (f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 { return {f, f, f, f} } @(require_results) -vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> f64 { +vector2f64_swizzle1 :: proc "contextless" (v: Vector2f64, c0: Vector2_Components) -> f64 { return v[c0] } @(require_results) -vector2f64_swizzle2 :: proc(v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 { +vector2f64_swizzle2 :: proc "contextless" (v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 { return {v[c0], v[c1]} } @(require_results) -vector2f64_swizzle3 :: proc(v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 { +vector2f64_swizzle3 :: proc "contextless" (v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector2f64_swizzle4 :: proc(v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 { +vector2f64_swizzle4 :: proc "contextless" (v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } @(require_results) -vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> f64 { +vector3f64_swizzle1 :: proc "contextless" (v: Vector3f64, c0: Vector3_Components) -> f64 { return v[c0] } @(require_results) -vector3f64_swizzle2 :: proc(v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 { +vector3f64_swizzle2 :: proc "contextless" (v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 { return {v[c0], v[c1]} } @(require_results) -vector3f64_swizzle3 :: proc(v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 { +vector3f64_swizzle3 :: proc "contextless" (v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector3f64_swizzle4 :: proc(v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 { +vector3f64_swizzle4 :: proc "contextless" (v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } @(require_results) -vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> f64 { +vector4f64_swizzle1 :: proc "contextless" (v: Vector4f64, c0: Vector4_Components) -> f64 { return v[c0] } @(require_results) -vector4f64_swizzle2 :: proc(v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 { +vector4f64_swizzle2 :: proc "contextless" (v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 { return {v[c0], v[c1]} } @(require_results) -vector4f64_swizzle3 :: proc(v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 { +vector4f64_swizzle3 :: proc "contextless" (v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } @(require_results) -vector4f64_swizzle4 :: proc(v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 { +vector4f64_swizzle4 :: proc "contextless" (v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } From 396debb9cb2c3aea3ed447cbd2d02cd162e9466e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:11:18 +0100 Subject: [PATCH 049/108] Add `@(require_results)` to `core:math/linalg`'s `glsl` and `hlsl` packages --- core/math/linalg/glsl/linalg_glsl.odin | 994 +++++++------- core/math/linalg/glsl/linalg_glsl_math.odin | 98 +- core/math/linalg/hlsl/linalg_hlsl.odin | 1366 ++++++++++--------- core/math/linalg/hlsl/linalg_hlsl_math.odin | 114 +- 4 files changed, 1307 insertions(+), 1265 deletions(-) diff --git a/core/math/linalg/glsl/linalg_glsl.odin b/core/math/linalg/glsl/linalg_glsl.odin index 0c3f56636..0d91ad4a3 100644 --- a/core/math/linalg/glsl/linalg_glsl.odin +++ b/core/math/linalg/glsl/linalg_glsl.odin @@ -89,12 +89,12 @@ cos :: proc{ cos_dvec3, cos_dvec4, } -cos_vec2 :: proc "c" (x: vec2) -> vec2 { return {cos(x.x), cos(x.y)} } -cos_vec3 :: proc "c" (x: vec3) -> vec3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_vec4 :: proc "c" (x: vec4) -> vec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } -cos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cos(x.x), cos(x.y)} } -cos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_vec2 :: proc "c" (x: vec2) -> vec2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_vec3 :: proc "c" (x: vec3) -> vec3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_vec4 :: proc "c" (x: vec4) -> vec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } sin :: proc{ sin_f32, @@ -106,12 +106,12 @@ sin :: proc{ sin_dvec3, sin_dvec4, } -sin_vec2 :: proc "c" (x: vec2) -> vec2 { return {sin(x.x), sin(x.y)} } -sin_vec3 :: proc "c" (x: vec3) -> vec3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_vec4 :: proc "c" (x: vec4) -> vec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } -sin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sin(x.x), sin(x.y)} } -sin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_vec2 :: proc "c" (x: vec2) -> vec2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_vec3 :: proc "c" (x: vec3) -> vec3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_vec4 :: proc "c" (x: vec4) -> vec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } tan :: proc{ tan_f32, @@ -123,12 +123,12 @@ tan :: proc{ tan_dvec3, tan_dvec4, } -tan_vec2 :: proc "c" (x: vec2) -> vec2 { return {tan(x.x), tan(x.y)} } -tan_vec3 :: proc "c" (x: vec3) -> vec3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_vec4 :: proc "c" (x: vec4) -> vec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } -tan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tan(x.x), tan(x.y)} } -tan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_vec2 :: proc "c" (x: vec2) -> vec2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_vec3 :: proc "c" (x: vec3) -> vec3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_vec4 :: proc "c" (x: vec4) -> vec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } acos :: proc{ acos_f32, @@ -140,12 +140,12 @@ acos :: proc{ acos_dvec3, acos_dvec4, } -acos_vec2 :: proc "c" (x: vec2) -> vec2 { return {acos(x.x), acos(x.y)} } -acos_vec3 :: proc "c" (x: vec3) -> vec3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_vec4 :: proc "c" (x: vec4) -> vec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } -acos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acos(x.x), acos(x.y)} } -acos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_vec2 :: proc "c" (x: vec2) -> vec2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_vec3 :: proc "c" (x: vec3) -> vec3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_vec4 :: proc "c" (x: vec4) -> vec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } asin :: proc{ asin_f32, @@ -157,12 +157,12 @@ asin :: proc{ asin_dvec3, asin_dvec4, } -asin_vec2 :: proc "c" (x: vec2) -> vec2 { return {asin(x.x), asin(x.y)} } -asin_vec3 :: proc "c" (x: vec3) -> vec3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_vec4 :: proc "c" (x: vec4) -> vec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } -asin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asin(x.x), asin(x.y)} } -asin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_vec2 :: proc "c" (x: vec2) -> vec2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_vec3 :: proc "c" (x: vec3) -> vec3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_vec4 :: proc "c" (x: vec4) -> vec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } atan :: proc{ atan_f32, @@ -182,12 +182,12 @@ atan :: proc{ atan2_dvec3, atan2_dvec4, } -atan_vec2 :: proc "c" (x: vec2) -> vec2 { return {atan(x.x), atan(x.y)} } -atan_vec3 :: proc "c" (x: vec3) -> vec3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_vec4 :: proc "c" (x: vec4) -> vec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } -atan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atan(x.x), atan(x.y)} } -atan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_vec2 :: proc "c" (x: vec2) -> vec2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_vec3 :: proc "c" (x: vec3) -> vec3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_vec4 :: proc "c" (x: vec4) -> vec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } atan2 :: proc{ atan2_f32, @@ -199,12 +199,12 @@ atan2 :: proc{ atan2_dvec3, atan2_dvec4, } -atan2_vec2 :: proc "c" (y, x: vec2) -> vec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_vec3 :: proc "c" (y, x: vec3) -> vec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_vec4 :: proc "c" (y, x: vec4) -> vec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } -atan2_dvec2 :: proc "c" (y, x: dvec2) -> dvec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_dvec3 :: proc "c" (y, x: dvec3) -> dvec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_dvec4 :: proc "c" (y, x: dvec4) -> dvec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_vec2 :: proc "c" (y, x: vec2) -> vec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_vec3 :: proc "c" (y, x: vec3) -> vec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_vec4 :: proc "c" (y, x: vec4) -> vec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_dvec2 :: proc "c" (y, x: dvec2) -> dvec2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_dvec3 :: proc "c" (y, x: dvec3) -> dvec3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_dvec4 :: proc "c" (y, x: dvec4) -> dvec4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @@ -218,12 +218,12 @@ cosh :: proc{ cosh_dvec3, cosh_dvec4, } -cosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {cosh(x.x), cosh(x.y)} } -cosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } -cosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cosh(x.x), cosh(x.y)} } -cosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } sinh :: proc{ @@ -236,12 +236,12 @@ sinh :: proc{ sinh_dvec3, sinh_dvec4, } -sinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {sinh(x.x), sinh(x.y)} } -sinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } -sinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sinh(x.x), sinh(x.y)} } -sinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } tanh :: proc{ tanh_f32, @@ -253,12 +253,12 @@ tanh :: proc{ tanh_dvec3, tanh_dvec4, } -tanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {tanh(x.x), tanh(x.y)} } -tanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } -tanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tanh(x.x), tanh(x.y)} } -tanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } acosh :: proc{ acosh_f32, @@ -270,12 +270,12 @@ acosh :: proc{ acosh_dvec3, acosh_dvec4, } -acosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {acosh(x.x), acosh(x.y)} } -acosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } -acosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acosh(x.x), acosh(x.y)} } -acosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_vec2 :: proc "c" (x: vec2) -> vec2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_vec3 :: proc "c" (x: vec3) -> vec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_vec4 :: proc "c" (x: vec4) -> vec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } asinh :: proc{ asinh_f32, @@ -287,12 +287,12 @@ asinh :: proc{ asinh_dvec3, asinh_dvec4, } -asinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {asinh(x.x), asinh(x.y)} } -asinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } -asinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asinh(x.x), asinh(x.y)} } -asinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_vec2 :: proc "c" (x: vec2) -> vec2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_vec3 :: proc "c" (x: vec3) -> vec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_vec4 :: proc "c" (x: vec4) -> vec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } atanh :: proc{ atanh_f32, @@ -304,12 +304,12 @@ atanh :: proc{ atanh_dvec3, atanh_dvec4, } -atanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {atanh(x.x), atanh(x.y)} } -atanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } -atanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atanh(x.x), atanh(x.y)} } -atanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_vec2 :: proc "c" (x: vec2) -> vec2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_vec3 :: proc "c" (x: vec3) -> vec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_vec4 :: proc "c" (x: vec4) -> vec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } sqrt :: proc{ sqrt_f32, @@ -321,12 +321,12 @@ sqrt :: proc{ sqrt_dvec3, sqrt_dvec4, } -sqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } -sqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } rsqrt :: inversesqrt inversesqrt :: proc{ @@ -339,12 +339,12 @@ inversesqrt :: proc{ inversesqrt_dvec3, inversesqrt_dvec4, } -inversesqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } -inversesqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } -inversesqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } -inversesqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } -inversesqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } -inversesqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } +@(require_results) inversesqrt_vec2 :: proc "c" (x: vec2) -> vec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } +@(require_results) inversesqrt_vec3 :: proc "c" (x: vec3) -> vec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } +@(require_results) inversesqrt_vec4 :: proc "c" (x: vec4) -> vec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } +@(require_results) inversesqrt_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {inversesqrt(x.x), inversesqrt(x.y)} } +@(require_results) inversesqrt_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z)} } +@(require_results) inversesqrt_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {inversesqrt(x.x), inversesqrt(x.y), inversesqrt(x.z), inversesqrt(x.w)} } pow :: proc{ @@ -357,12 +357,12 @@ pow :: proc{ pow_dvec3, pow_dvec4, } -pow_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } -pow_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @@ -376,12 +376,12 @@ exp :: proc{ exp_dvec3, exp_dvec4, } -exp_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp(x.x), exp(x.y)} } -exp_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } -exp_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp(x.x), exp(x.y)} } -exp_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @@ -395,12 +395,12 @@ log :: proc{ log_dvec3, log_dvec4, } -log_vec2 :: proc "c" (x: vec2) -> vec2 { return {log(x.x), log(x.y)} } -log_vec3 :: proc "c" (x: vec3) -> vec3 { return {log(x.x), log(x.y), log(x.z)} } -log_vec4 :: proc "c" (x: vec4) -> vec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } -log_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {log(x.x), log(x.y)} } -log_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {log(x.x), log(x.y), log(x.z)} } -log_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_vec2 :: proc "c" (x: vec2) -> vec2 { return {log(x.x), log(x.y)} } +@(require_results) log_vec3 :: proc "c" (x: vec3) -> vec3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_vec4 :: proc "c" (x: vec4) -> vec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {log(x.x), log(x.y)} } +@(require_results) log_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } @@ -414,12 +414,12 @@ exp2 :: proc{ exp2_dvec3, exp2_dvec4, } -exp2_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp2(x.x), exp2(x.y)} } -exp2_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } -exp2_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp2(x.x), exp2(x.y)} } -exp2_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_vec2 :: proc "c" (x: vec2) -> vec2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_vec3 :: proc "c" (x: vec3) -> vec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_vec4 :: proc "c" (x: vec4) -> vec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } sign :: proc{ @@ -440,20 +440,20 @@ sign :: proc{ sign_uvec3, sign_uvec4, } -sign_i32 :: proc "c" (x: i32) -> i32 { return -1 if x < 0 else +1 if x > 0 else 0 } -sign_u32 :: proc "c" (x: u32) -> u32 { return +1 if x > 0 else 0 } -sign_vec2 :: proc "c" (x: vec2) -> vec2 { return {sign(x.x), sign(x.y)} } -sign_vec3 :: proc "c" (x: vec3) -> vec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_vec4 :: proc "c" (x: vec4) -> vec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sign(x.x), sign(x.y)} } -sign_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {sign(x.x), sign(x.y)} } -sign_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return {sign(x.x), sign(x.y)} } -sign_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_i32 :: proc "c" (x: i32) -> i32 { return -1 if x < 0 else +1 if x > 0 else 0 } +@(require_results) sign_u32 :: proc "c" (x: u32) -> u32 { return +1 if x > 0 else 0 } +@(require_results) sign_vec2 :: proc "c" (x: vec2) -> vec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_vec3 :: proc "c" (x: vec3) -> vec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_vec4 :: proc "c" (x: vec4) -> vec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } floor :: proc{ floor_f32, @@ -465,12 +465,12 @@ floor :: proc{ floor_dvec3, floor_dvec4, } -floor_vec2 :: proc "c" (x: vec2) -> vec2 { return {floor(x.x), floor(x.y)} } -floor_vec3 :: proc "c" (x: vec3) -> vec3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_vec4 :: proc "c" (x: vec4) -> vec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } -floor_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {floor(x.x), floor(x.y)} } -floor_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_vec2 :: proc "c" (x: vec2) -> vec2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_vec3 :: proc "c" (x: vec3) -> vec3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_vec4 :: proc "c" (x: vec4) -> vec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } @@ -484,12 +484,12 @@ round :: proc{ round_dvec3, round_dvec4, } -round_vec2 :: proc "c" (x: vec2) -> vec2 { return {round(x.x), round(x.y)} } -round_vec3 :: proc "c" (x: vec3) -> vec3 { return {round(x.x), round(x.y), round(x.z)} } -round_vec4 :: proc "c" (x: vec4) -> vec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } -round_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {round(x.x), round(x.y)} } -round_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {round(x.x), round(x.y), round(x.z)} } -round_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_vec2 :: proc "c" (x: vec2) -> vec2 { return {round(x.x), round(x.y)} } +@(require_results) round_vec3 :: proc "c" (x: vec3) -> vec3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_vec4 :: proc "c" (x: vec4) -> vec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {round(x.x), round(x.y)} } +@(require_results) round_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } ceil :: proc{ @@ -502,12 +502,12 @@ ceil :: proc{ ceil_dvec3, ceil_dvec4, } -ceil_vec2 :: proc "c" (x: vec2) -> vec2 { return {ceil(x.x), ceil(x.y)} } -ceil_vec3 :: proc "c" (x: vec3) -> vec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_vec4 :: proc "c" (x: vec4) -> vec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -ceil_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {ceil(x.x), ceil(x.y)} } -ceil_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_vec2 :: proc "c" (x: vec2) -> vec2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_vec3 :: proc "c" (x: vec3) -> vec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_vec4 :: proc "c" (x: vec4) -> vec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } mod :: proc{ @@ -520,12 +520,12 @@ mod :: proc{ mod_dvec3, mod_dvec4, } -mod_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } -mod_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } -mod_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } -mod_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } -mod_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } -mod_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } +@(require_results) mod_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } +@(require_results) mod_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } +@(require_results) mod_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } +@(require_results) mod_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {mod(x.x, y.x), mod(x.y, y.y)} } +@(require_results) mod_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z)} } +@(require_results) mod_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {mod(x.x, y.x), mod(x.y, y.y), mod(x.z, y.z), mod(x.w, y.w)} } fract :: proc{ @@ -538,12 +538,12 @@ fract :: proc{ fract_dvec3, fract_dvec4, } -fract_vec2 :: proc "c" (x: vec2) -> vec2 { return {fract(x.x), fract(x.y)} } -fract_vec3 :: proc "c" (x: vec3) -> vec3 { return {fract(x.x), fract(x.y), fract(x.z)} } -fract_vec4 :: proc "c" (x: vec4) -> vec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } -fract_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {fract(x.x), fract(x.y)} } -fract_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {fract(x.x), fract(x.y), fract(x.z)} } -fract_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } +@(require_results) fract_vec2 :: proc "c" (x: vec2) -> vec2 { return {fract(x.x), fract(x.y)} } +@(require_results) fract_vec3 :: proc "c" (x: vec3) -> vec3 { return {fract(x.x), fract(x.y), fract(x.z)} } +@(require_results) fract_vec4 :: proc "c" (x: vec4) -> vec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } +@(require_results) fract_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {fract(x.x), fract(x.y)} } +@(require_results) fract_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {fract(x.x), fract(x.y), fract(x.z)} } +@(require_results) fract_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {fract(x.x), fract(x.y), fract(x.z), fract(x.w)} } @@ -557,14 +557,14 @@ radians :: proc{ radians_dvec3, radians_dvec4, } -radians_f32 :: proc "c" (degrees: f32) -> f32 { return degrees * TAU / 360.0 } -radians_f64 :: proc "c" (degrees: f64) -> f64 { return degrees * TAU / 360.0 } -radians_vec2 :: proc "c" (degrees: vec2) -> vec2 { return degrees * TAU / 360.0 } -radians_vec3 :: proc "c" (degrees: vec3) -> vec3 { return degrees * TAU / 360.0 } -radians_vec4 :: proc "c" (degrees: vec4) -> vec4 { return degrees * TAU / 360.0 } -radians_dvec2 :: proc "c" (degrees: dvec2) -> dvec2 { return degrees * TAU / 360.0 } -radians_dvec3 :: proc "c" (degrees: dvec3) -> dvec3 { return degrees * TAU / 360.0 } -radians_dvec4 :: proc "c" (degrees: dvec4) -> dvec4 { return degrees * TAU / 360.0 } +@(require_results) radians_f32 :: proc "c" (degrees: f32) -> f32 { return degrees * TAU / 360.0 } +@(require_results) radians_f64 :: proc "c" (degrees: f64) -> f64 { return degrees * TAU / 360.0 } +@(require_results) radians_vec2 :: proc "c" (degrees: vec2) -> vec2 { return degrees * TAU / 360.0 } +@(require_results) radians_vec3 :: proc "c" (degrees: vec3) -> vec3 { return degrees * TAU / 360.0 } +@(require_results) radians_vec4 :: proc "c" (degrees: vec4) -> vec4 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec2 :: proc "c" (degrees: dvec2) -> dvec2 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec3 :: proc "c" (degrees: dvec3) -> dvec3 { return degrees * TAU / 360.0 } +@(require_results) radians_dvec4 :: proc "c" (degrees: dvec4) -> dvec4 { return degrees * TAU / 360.0 } degrees :: proc{ @@ -577,14 +577,14 @@ degrees :: proc{ degrees_dvec3, degrees_dvec4, } -degrees_f32 :: proc "c" (radians: f32) -> f32 { return radians * 360.0 / TAU } -degrees_f64 :: proc "c" (radians: f64) -> f64 { return radians * 360.0 / TAU } -degrees_vec2 :: proc "c" (radians: vec2) -> vec2 { return radians * 360.0 / TAU } -degrees_vec3 :: proc "c" (radians: vec3) -> vec3 { return radians * 360.0 / TAU } -degrees_vec4 :: proc "c" (radians: vec4) -> vec4 { return radians * 360.0 / TAU } -degrees_dvec2 :: proc "c" (radians: dvec2) -> dvec2 { return radians * 360.0 / TAU } -degrees_dvec3 :: proc "c" (radians: dvec3) -> dvec3 { return radians * 360.0 / TAU } -degrees_dvec4 :: proc "c" (radians: dvec4) -> dvec4 { return radians * 360.0 / TAU } +@(require_results) degrees_f32 :: proc "c" (radians: f32) -> f32 { return radians * 360.0 / TAU } +@(require_results) degrees_f64 :: proc "c" (radians: f64) -> f64 { return radians * 360.0 / TAU } +@(require_results) degrees_vec2 :: proc "c" (radians: vec2) -> vec2 { return radians * 360.0 / TAU } +@(require_results) degrees_vec3 :: proc "c" (radians: vec3) -> vec3 { return radians * 360.0 / TAU } +@(require_results) degrees_vec4 :: proc "c" (radians: vec4) -> vec4 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec2 :: proc "c" (radians: dvec2) -> dvec2 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec3 :: proc "c" (radians: dvec3) -> dvec3 { return radians * 360.0 / TAU } +@(require_results) degrees_dvec4 :: proc "c" (radians: dvec4) -> dvec4 { return radians * 360.0 / TAU } min :: proc{ min_i32, @@ -604,22 +604,22 @@ min :: proc{ min_uvec3, min_uvec4, } -min_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.min(x, y) } -min_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.min(x, y) } -min_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.min(x, y) } -min_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.min(x, y) } -min_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.min(x, y) } +@(require_results) min_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.min(x, y) } +@(require_results) min_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.min(x, y) } +@(require_results) min_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.min(x, y) } +@(require_results) min_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } max :: proc{ @@ -640,22 +640,22 @@ max :: proc{ max_uvec3, max_uvec4, } -max_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.max(x, y) } -max_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.max(x, y) } -max_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.max(x, y) } -max_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.max(x, y) } -max_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_i32 :: proc "c" (x, y: i32) -> i32 { return builtin.max(x, y) } +@(require_results) max_u32 :: proc "c" (x, y: u32) -> u32 { return builtin.max(x, y) } +@(require_results) max_f32 :: proc "c" (x, y: f32) -> f32 { return builtin.max(x, y) } +@(require_results) max_f64 :: proc "c" (x, y: f64) -> f64 { return builtin.max(x, y) } +@(require_results) max_vec2 :: proc "c" (x, y: vec2) -> vec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_vec3 :: proc "c" (x, y: vec3) -> vec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_vec4 :: proc "c" (x, y: vec4) -> vec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_dvec2 :: proc "c" (x, y: dvec2) -> dvec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_dvec3 :: proc "c" (x, y: dvec3) -> dvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_dvec4 :: proc "c" (x, y: dvec4) -> dvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_ivec2 :: proc "c" (x, y: ivec2) -> ivec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_ivec3 :: proc "c" (x, y: ivec3) -> ivec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_ivec4 :: proc "c" (x, y: ivec4) -> ivec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_uvec2 :: proc "c" (x, y: uvec2) -> uvec2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_uvec3 :: proc "c" (x, y: uvec3) -> uvec3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_uvec4 :: proc "c" (x, y: uvec4) -> uvec4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @@ -677,22 +677,22 @@ clamp :: proc{ clamp_uvec3, clamp_uvec4, } -clamp_i32 :: proc "c" (x, y, z: i32) -> i32 { return builtin.clamp(x, y, z) } -clamp_u32 :: proc "c" (x, y, z: u32) -> u32 { return builtin.clamp(x, y, z) } -clamp_f32 :: proc "c" (x, y, z: f32) -> f32 { return builtin.clamp(x, y, z) } -clamp_f64 :: proc "c" (x, y, z: f64) -> f64 { return builtin.clamp(x, y, z) } -clamp_vec2 :: proc "c" (x, y, z: vec2) -> vec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_vec3 :: proc "c" (x, y, z: vec3) -> vec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_vec4 :: proc "c" (x, y, z: vec4) -> vec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_dvec2 :: proc "c" (x, y, z: dvec2) -> dvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_dvec3 :: proc "c" (x, y, z: dvec3) -> dvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_dvec4 :: proc "c" (x, y, z: dvec4) -> dvec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_ivec2 :: proc "c" (x, y, z: ivec2) -> ivec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_ivec3 :: proc "c" (x, y, z: ivec3) -> ivec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_ivec4 :: proc "c" (x, y, z: ivec4) -> ivec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_uvec2 :: proc "c" (x, y, z: uvec2) -> uvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_uvec3 :: proc "c" (x, y, z: uvec3) -> uvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_uvec4 :: proc "c" (x, y, z: uvec4) -> uvec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_i32 :: proc "c" (x, y, z: i32) -> i32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_u32 :: proc "c" (x, y, z: u32) -> u32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_f32 :: proc "c" (x, y, z: f32) -> f32 { return builtin.clamp(x, y, z) } +@(require_results) clamp_f64 :: proc "c" (x, y, z: f64) -> f64 { return builtin.clamp(x, y, z) } +@(require_results) clamp_vec2 :: proc "c" (x, y, z: vec2) -> vec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_vec3 :: proc "c" (x, y, z: vec3) -> vec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_vec4 :: proc "c" (x, y, z: vec4) -> vec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_dvec2 :: proc "c" (x, y, z: dvec2) -> dvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_dvec3 :: proc "c" (x, y, z: dvec3) -> dvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_dvec4 :: proc "c" (x, y, z: dvec4) -> dvec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_ivec2 :: proc "c" (x, y, z: ivec2) -> ivec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_ivec3 :: proc "c" (x, y, z: ivec3) -> ivec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_ivec4 :: proc "c" (x, y, z: ivec4) -> ivec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_uvec2 :: proc "c" (x, y, z: uvec2) -> uvec2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_uvec3 :: proc "c" (x, y, z: uvec3) -> uvec3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_uvec4 :: proc "c" (x, y, z: uvec4) -> uvec4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } saturate :: proc{ saturate_i32, @@ -712,22 +712,22 @@ saturate :: proc{ saturate_uvec3, saturate_uvec4, } -saturate_i32 :: proc "c" (v: i32) -> i32 { return builtin.clamp(v, 0, 1) } -saturate_u32 :: proc "c" (v: u32) -> u32 { return builtin.clamp(v, 0, 1) } -saturate_f32 :: proc "c" (v: f32) -> f32 { return builtin.clamp(v, 0, 1) } -saturate_f64 :: proc "c" (v: f64) -> f64 { return builtin.clamp(v, 0, 1) } -saturate_vec2 :: proc "c" (v: vec2) -> vec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_vec3 :: proc "c" (v: vec3) -> vec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_vec4 :: proc "c" (v: vec4) -> vec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_dvec2 :: proc "c" (v: dvec2) -> dvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_dvec3 :: proc "c" (v: dvec3) -> dvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_dvec4 :: proc "c" (v: dvec4) -> dvec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_ivec2 :: proc "c" (v: ivec2) -> ivec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_ivec3 :: proc "c" (v: ivec3) -> ivec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_ivec4 :: proc "c" (v: ivec4) -> ivec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_uvec2 :: proc "c" (v: uvec2) -> uvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_uvec3 :: proc "c" (v: uvec3) -> uvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_uvec4 :: proc "c" (v: uvec4) -> uvec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_i32 :: proc "c" (v: i32) -> i32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_u32 :: proc "c" (v: u32) -> u32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_f32 :: proc "c" (v: f32) -> f32 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_f64 :: proc "c" (v: f64) -> f64 { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_vec2 :: proc "c" (v: vec2) -> vec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_vec3 :: proc "c" (v: vec3) -> vec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_vec4 :: proc "c" (v: vec4) -> vec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_dvec2 :: proc "c" (v: dvec2) -> dvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_dvec3 :: proc "c" (v: dvec3) -> dvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_dvec4 :: proc "c" (v: dvec4) -> dvec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_ivec2 :: proc "c" (v: ivec2) -> ivec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_ivec3 :: proc "c" (v: ivec3) -> ivec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_ivec4 :: proc "c" (v: ivec4) -> ivec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_uvec2 :: proc "c" (v: uvec2) -> uvec2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_uvec3 :: proc "c" (v: uvec3) -> uvec3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_uvec4 :: proc "c" (v: uvec4) -> uvec4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } mix :: proc{ mix_f32, @@ -739,14 +739,14 @@ mix :: proc{ mix_dvec3, mix_dvec4, } -mix_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } -mix_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } -mix_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } -mix_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } -mix_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } -mix_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } -mix_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } -mix_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } +@(require_results) mix_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } +@(require_results) mix_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } +@(require_results) mix_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } +@(require_results) mix_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } +@(require_results) mix_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } +@(require_results) mix_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y)} } +@(require_results) mix_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, t.y), mix(x.z, y.z, t.z)} } +@(require_results) mix_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {mix(x.x, y.x, t.x), mix(x.y, y.y, y.y), mix(x.z, y.z, t.z), mix(x.w, y.w, t.w)} } lerp :: proc{ lerp_f32, @@ -758,14 +758,14 @@ lerp :: proc{ lerp_dvec3, lerp_dvec4, } -lerp_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } -lerp_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } -lerp_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } -lerp_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_f32 :: proc "c" (x, y, t: f32) -> f32 { return x*(1-t) + y*t } +@(require_results) lerp_f64 :: proc "c" (x, y, t: f64) -> f64 { return x*(1-t) + y*t } +@(require_results) lerp_vec2 :: proc "c" (x, y, t: vec2) -> vec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_vec3 :: proc "c" (x, y, t: vec3) -> vec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } +@(require_results) lerp_vec4 :: proc "c" (x, y, t: vec4) -> vec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_dvec2 :: proc "c" (x, y, t: dvec2) -> dvec2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_dvec3 :: proc "c" (x, y, t: dvec3) -> dvec3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } +@(require_results) lerp_dvec4 :: proc "c" (x, y, t: dvec4) -> dvec4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } step :: proc{ @@ -778,14 +778,14 @@ step :: proc{ step_dvec3, step_dvec4, } -step_f32 :: proc "c" (edge, x: f32) -> f32 { return 0 if x < edge else 1 } -step_f64 :: proc "c" (edge, x: f64) -> f64 { return 0 if x < edge else 1 } -step_vec2 :: proc "c" (edge, x: vec2) -> vec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_vec3 :: proc "c" (edge, x: vec3) -> vec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_vec4 :: proc "c" (edge, x: vec4) -> vec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } -step_dvec2 :: proc "c" (edge, x: dvec2) -> dvec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_dvec3 :: proc "c" (edge, x: dvec3) -> dvec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_dvec4 :: proc "c" (edge, x: dvec4) -> dvec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_f32 :: proc "c" (edge, x: f32) -> f32 { return 0 if x < edge else 1 } +@(require_results) step_f64 :: proc "c" (edge, x: f64) -> f64 { return 0 if x < edge else 1 } +@(require_results) step_vec2 :: proc "c" (edge, x: vec2) -> vec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_vec3 :: proc "c" (edge, x: vec3) -> vec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_vec4 :: proc "c" (edge, x: vec4) -> vec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_dvec2 :: proc "c" (edge, x: dvec2) -> dvec2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_dvec3 :: proc "c" (edge, x: dvec3) -> dvec3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_dvec4 :: proc "c" (edge, x: dvec4) -> dvec4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } smoothstep :: proc{ smoothstep_f32, @@ -797,20 +797,20 @@ smoothstep :: proc{ smoothstep_dvec3, smoothstep_dvec4, } -smoothstep_f32 :: proc "c" (edge0, edge1, x: f32) -> f32 { +@(require_results) smoothstep_f32 :: proc "c" (edge0, edge1, x: f32) -> f32 { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_f64 :: proc "c" (edge0, edge1, x: f64) -> f64 { +@(require_results) smoothstep_f64 :: proc "c" (edge0, edge1, x: f64) -> f64 { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_vec2 :: proc "c" (edge0, edge1, x: vec2) -> vec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_vec3 :: proc "c" (edge0, edge1, x: vec3) -> vec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_vec4 :: proc "c" (edge0, edge1, x: vec4) -> vec4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } -smoothstep_dvec2 :: proc "c" (edge0, edge1, x: dvec2) -> dvec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_dvec3 :: proc "c" (edge0, edge1, x: dvec3) -> dvec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_dvec4 :: proc "c" (edge0, edge1, x: dvec4) -> dvec4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } +@(require_results) smoothstep_vec2 :: proc "c" (edge0, edge1, x: vec2) -> vec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_vec3 :: proc "c" (edge0, edge1, x: vec3) -> vec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } +@(require_results) smoothstep_vec4 :: proc "c" (edge0, edge1, x: vec4) -> vec4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } +@(require_results) smoothstep_dvec2 :: proc "c" (edge0, edge1, x: dvec2) -> dvec2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_dvec3 :: proc "c" (edge0, edge1, x: dvec3) -> dvec3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } +@(require_results) smoothstep_dvec4 :: proc "c" (edge0, edge1, x: dvec4) -> dvec4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } abs :: proc{ @@ -831,22 +831,22 @@ abs :: proc{ abs_uvec3, abs_uvec4, } -abs_i32 :: proc "c" (x: i32) -> i32 { return builtin.abs(x) } -abs_u32 :: proc "c" (x: u32) -> u32 { return x } -abs_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } -abs_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } -abs_vec2 :: proc "c" (x: vec2) -> vec2 { return {abs(x.x), abs(x.y)} } -abs_vec3 :: proc "c" (x: vec3) -> vec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_vec4 :: proc "c" (x: vec4) -> vec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {abs(x.x), abs(x.y)} } -abs_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {abs(x.x), abs(x.y)} } -abs_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return x } -abs_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return x } -abs_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return x } +@(require_results) abs_i32 :: proc "c" (x: i32) -> i32 { return builtin.abs(x) } +@(require_results) abs_u32 :: proc "c" (x: u32) -> u32 { return x } +@(require_results) abs_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } +@(require_results) abs_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } +@(require_results) abs_vec2 :: proc "c" (x: vec2) -> vec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_vec3 :: proc "c" (x: vec3) -> vec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_vec4 :: proc "c" (x: vec4) -> vec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_ivec2 :: proc "c" (x: ivec2) -> ivec2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_ivec3 :: proc "c" (x: ivec3) -> ivec3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_ivec4 :: proc "c" (x: ivec4) -> ivec4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_uvec2 :: proc "c" (x: uvec2) -> uvec2 { return x } +@(require_results) abs_uvec3 :: proc "c" (x: uvec3) -> uvec3 { return x } +@(require_results) abs_uvec4 :: proc "c" (x: uvec4) -> uvec4 { return x } dot :: proc{ dot_i32, @@ -868,24 +868,24 @@ dot :: proc{ dot_quat, dot_dquat, } -dot_i32 :: proc "c" (a, b: i32) -> i32 { return a*b } -dot_u32 :: proc "c" (a, b: u32) -> u32 { return a*b } -dot_f32 :: proc "c" (a, b: f32) -> f32 { return a*b } -dot_f64 :: proc "c" (a, b: f64) -> f64 { return a*b } -dot_vec2 :: proc "c" (a, b: vec2) -> f32 { return a.x*b.x + a.y*b.y } -dot_vec3 :: proc "c" (a, b: vec3) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_vec4 :: proc "c" (a, b: vec4) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_dvec2 :: proc "c" (a, b: dvec2) -> f64 { return a.x*b.x + a.y*b.y } -dot_dvec3 :: proc "c" (a, b: dvec3) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_dvec4 :: proc "c" (a, b: dvec4) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_ivec2 :: proc "c" (a, b: ivec2) -> i32 { return a.x*b.x + a.y*b.y } -dot_ivec3 :: proc "c" (a, b: ivec3) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_ivec4 :: proc "c" (a, b: ivec4) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_uvec2 :: proc "c" (a, b: uvec2) -> u32 { return a.x*b.x + a.y*b.y } -dot_uvec3 :: proc "c" (a, b: uvec3) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_uvec4 :: proc "c" (a, b: uvec4) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_quat :: proc "c" (a, b: quat) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_dquat :: proc "c" (a, b: dquat) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_i32 :: proc "c" (a, b: i32) -> i32 { return a*b } +@(require_results) dot_u32 :: proc "c" (a, b: u32) -> u32 { return a*b } +@(require_results) dot_f32 :: proc "c" (a, b: f32) -> f32 { return a*b } +@(require_results) dot_f64 :: proc "c" (a, b: f64) -> f64 { return a*b } +@(require_results) dot_vec2 :: proc "c" (a, b: vec2) -> f32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_vec3 :: proc "c" (a, b: vec3) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_vec4 :: proc "c" (a, b: vec4) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_dvec2 :: proc "c" (a, b: dvec2) -> f64 { return a.x*b.x + a.y*b.y } +@(require_results) dot_dvec3 :: proc "c" (a, b: dvec3) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_dvec4 :: proc "c" (a, b: dvec4) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_ivec2 :: proc "c" (a, b: ivec2) -> i32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_ivec3 :: proc "c" (a, b: ivec3) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_ivec4 :: proc "c" (a, b: ivec4) -> i32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_uvec2 :: proc "c" (a, b: uvec2) -> u32 { return a.x*b.x + a.y*b.y } +@(require_results) dot_uvec3 :: proc "c" (a, b: uvec3) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_uvec4 :: proc "c" (a, b: uvec4) -> u32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_quat :: proc "c" (a, b: quat) -> f32 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_dquat :: proc "c" (a, b: dquat) -> f64 { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } length :: proc{ length_f32, @@ -899,16 +899,16 @@ length :: proc{ length_quat, length_dquat, } -length_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } -length_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } -length_vec2 :: proc "c" (x: vec2) -> f32 { return sqrt(x.x*x.x + x.y*x.y) } -length_vec3 :: proc "c" (x: vec3) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_vec4 :: proc "c" (x: vec4) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_dvec2 :: proc "c" (x: dvec2) -> f64 { return sqrt(x.x*x.x + x.y*x.y) } -length_dvec3 :: proc "c" (x: dvec3) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_dvec4 :: proc "c" (x: dvec4) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_quat :: proc "c" (x: quat) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_dquat :: proc "c" (x: dquat) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_f32 :: proc "c" (x: f32) -> f32 { return builtin.abs(x) } +@(require_results) length_f64 :: proc "c" (x: f64) -> f64 { return builtin.abs(x) } +@(require_results) length_vec2 :: proc "c" (x: vec2) -> f32 { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_vec3 :: proc "c" (x: vec3) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_vec4 :: proc "c" (x: vec4) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_dvec2 :: proc "c" (x: dvec2) -> f64 { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_dvec3 :: proc "c" (x: dvec3) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_dvec4 :: proc "c" (x: dvec4) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_quat :: proc "c" (x: quat) -> f32 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_dquat :: proc "c" (x: dquat) -> f64 { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } distance :: proc{ @@ -921,14 +921,14 @@ distance :: proc{ distance_dvec3, distance_dvec4, } -distance_f32 :: proc "c" (x, y: f32) -> f32 { return length(y-x) } -distance_f64 :: proc "c" (x, y: f64) -> f64 { return length(y-x) } -distance_vec2 :: proc "c" (x, y: vec2) -> f32 { return length(y-x) } -distance_vec3 :: proc "c" (x, y: vec3) -> f32 { return length(y-x) } -distance_vec4 :: proc "c" (x, y: vec4) -> f32 { return length(y-x) } -distance_dvec2 :: proc "c" (x, y: dvec2) -> f64 { return length(y-x) } -distance_dvec3 :: proc "c" (x, y: dvec3) -> f64 { return length(y-x) } -distance_dvec4 :: proc "c" (x, y: dvec4) -> f64 { return length(y-x) } +@(require_results) distance_f32 :: proc "c" (x, y: f32) -> f32 { return length(y-x) } +@(require_results) distance_f64 :: proc "c" (x, y: f64) -> f64 { return length(y-x) } +@(require_results) distance_vec2 :: proc "c" (x, y: vec2) -> f32 { return length(y-x) } +@(require_results) distance_vec3 :: proc "c" (x, y: vec3) -> f32 { return length(y-x) } +@(require_results) distance_vec4 :: proc "c" (x, y: vec4) -> f32 { return length(y-x) } +@(require_results) distance_dvec2 :: proc "c" (x, y: dvec2) -> f64 { return length(y-x) } +@(require_results) distance_dvec3 :: proc "c" (x, y: dvec3) -> f64 { return length(y-x) } +@(require_results) distance_dvec4 :: proc "c" (x, y: dvec4) -> f64 { return length(y-x) } cross :: proc{ @@ -937,19 +937,19 @@ cross :: proc{ cross_ivec3, } -cross_vec3 :: proc "c" (a, b: vec3) -> (c: vec3) { +@(require_results) cross_vec3 :: proc "c" (a, b: vec3) -> (c: vec3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y return } -cross_dvec3 :: proc "c" (a, b: dvec3) -> (c: dvec3) { +@(require_results) cross_dvec3 :: proc "c" (a, b: dvec3) -> (c: dvec3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y return } -cross_ivec3 :: proc "c" (a, b: ivec3) -> (c: ivec3) { +@(require_results) cross_ivec3 :: proc "c" (a, b: ivec3) -> (c: ivec3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y @@ -968,16 +968,16 @@ normalize :: proc{ normalize_quat, normalize_dquat, } -normalize_f32 :: proc "c" (x: f32) -> f32 { return 1.0 } -normalize_f64 :: proc "c" (x: f64) -> f64 { return 1.0 } -normalize_vec2 :: proc "c" (x: vec2) -> vec2 { return x / length(x) } -normalize_vec3 :: proc "c" (x: vec3) -> vec3 { return x / length(x) } -normalize_vec4 :: proc "c" (x: vec4) -> vec4 { return x / length(x) } -normalize_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return x / length(x) } -normalize_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return x / length(x) } -normalize_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return x / length(x) } -normalize_quat :: proc "c" (x: quat) -> quat { return x / quat(length(x)) } -normalize_dquat :: proc "c" (x: dquat) -> dquat { return x / dquat(length(x)) } +@(require_results) normalize_f32 :: proc "c" (x: f32) -> f32 { return 1.0 } +@(require_results) normalize_f64 :: proc "c" (x: f64) -> f64 { return 1.0 } +@(require_results) normalize_vec2 :: proc "c" (x: vec2) -> vec2 { return x / length(x) } +@(require_results) normalize_vec3 :: proc "c" (x: vec3) -> vec3 { return x / length(x) } +@(require_results) normalize_vec4 :: proc "c" (x: vec4) -> vec4 { return x / length(x) } +@(require_results) normalize_dvec2 :: proc "c" (x: dvec2) -> dvec2 { return x / length(x) } +@(require_results) normalize_dvec3 :: proc "c" (x: dvec3) -> dvec3 { return x / length(x) } +@(require_results) normalize_dvec4 :: proc "c" (x: dvec4) -> dvec4 { return x / length(x) } +@(require_results) normalize_quat :: proc "c" (x: quat) -> quat { return x / quat(length(x)) } +@(require_results) normalize_dquat :: proc "c" (x: dquat) -> dquat { return x / dquat(length(x)) } faceForward :: proc{ @@ -990,14 +990,14 @@ faceForward :: proc{ faceForward_dvec3, faceForward_dvec4, } -faceForward_f32 :: proc "c" (N, I, Nref: f32) -> f32 { return N if dot(I, Nref) < 0 else -N } -faceForward_f64 :: proc "c" (N, I, Nref: f64) -> f64 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec2 :: proc "c" (N, I, Nref: vec2) -> vec2 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec3 :: proc "c" (N, I, Nref: vec3) -> vec3 { return N if dot(I, Nref) < 0 else -N } -faceForward_vec4 :: proc "c" (N, I, Nref: vec4) -> vec4 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec2 :: proc "c" (N, I, Nref: dvec2) -> dvec2 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec3 :: proc "c" (N, I, Nref: dvec3) -> dvec3 { return N if dot(I, Nref) < 0 else -N } -faceForward_dvec4 :: proc "c" (N, I, Nref: dvec4) -> dvec4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_f32 :: proc "c" (N, I, Nref: f32) -> f32 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_f64 :: proc "c" (N, I, Nref: f64) -> f64 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec2 :: proc "c" (N, I, Nref: vec2) -> vec2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec3 :: proc "c" (N, I, Nref: vec3) -> vec3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_vec4 :: proc "c" (N, I, Nref: vec4) -> vec4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec2 :: proc "c" (N, I, Nref: dvec2) -> dvec2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec3 :: proc "c" (N, I, Nref: dvec3) -> dvec3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceForward_dvec4 :: proc "c" (N, I, Nref: dvec4) -> dvec4 { return N if dot(I, Nref) < 0 else -N } reflect :: proc{ @@ -1010,14 +1010,14 @@ reflect :: proc{ reflect_dvec3, reflect_dvec4, } -reflect_f32 :: proc "c" (I, N: f32) -> f32 { return I - 2*N*dot(N, I) } -reflect_f64 :: proc "c" (I, N: f64) -> f64 { return I - 2*N*dot(N, I) } -reflect_vec2 :: proc "c" (I, N: vec2) -> vec2 { return I - 2*N*dot(N, I) } -reflect_vec3 :: proc "c" (I, N: vec3) -> vec3 { return I - 2*N*dot(N, I) } -reflect_vec4 :: proc "c" (I, N: vec4) -> vec4 { return I - 2*N*dot(N, I) } -reflect_dvec2 :: proc "c" (I, N: dvec2) -> dvec2 { return I - 2*N*dot(N, I) } -reflect_dvec3 :: proc "c" (I, N: dvec3) -> dvec3 { return I - 2*N*dot(N, I) } -reflect_dvec4 :: proc "c" (I, N: dvec4) -> dvec4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_f32 :: proc "c" (I, N: f32) -> f32 { return I - 2*N*dot(N, I) } +@(require_results) reflect_f64 :: proc "c" (I, N: f64) -> f64 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec2 :: proc "c" (I, N: vec2) -> vec2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec3 :: proc "c" (I, N: vec3) -> vec3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_vec4 :: proc "c" (I, N: vec4) -> vec4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec2 :: proc "c" (I, N: dvec2) -> dvec2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec3 :: proc "c" (I, N: dvec3) -> dvec3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_dvec4 :: proc "c" (I, N: dvec4) -> dvec4 { return I - 2*N*dot(N, I) } @@ -1032,49 +1032,49 @@ refract :: proc{ refract_dvec3, refract_dvec4, } -refract_f32 :: proc "c" (i, n, eta: f32) -> f32 { +@(require_results) refract_f32 :: proc "c" (i, n, eta: f32) -> f32 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * f32(i32(cost2 > 0)) } -refract_f64 :: proc "c" (i, n, eta: f64) -> f64 { +@(require_results) refract_f64 :: proc "c" (i, n, eta: f64) -> f64 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * f64(i32(cost2 > 0)) } -refract_vec2 :: proc "c" (i, n, eta: vec2) -> vec2 { +@(require_results) refract_vec2 :: proc "c" (i, n, eta: vec2) -> vec2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec2{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0))} } -refract_vec3 :: proc "c" (i, n, eta: vec3) -> vec3 { +@(require_results) refract_vec3 :: proc "c" (i, n, eta: vec3) -> vec3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec3{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0)), f32(i32(cost2.z > 0))} } -refract_vec4 :: proc "c" (i, n, eta: vec4) -> vec4 { +@(require_results) refract_vec4 :: proc "c" (i, n, eta: vec4) -> vec4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * vec4{f32(i32(cost2.x > 0)), f32(i32(cost2.y > 0)), f32(i32(cost2.z > 0)), f32(i32(cost2.w > 0))} } -refract_dvec2 :: proc "c" (i, n, eta: dvec2) -> dvec2 { +@(require_results) refract_dvec2 :: proc "c" (i, n, eta: dvec2) -> dvec2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * dvec2{f64(i32(cost2.x > 0)), f64(i32(cost2.y > 0))} } -refract_dvec3 :: proc "c" (i, n, eta: dvec3) -> dvec3 { +@(require_results) refract_dvec3 :: proc "c" (i, n, eta: dvec3) -> dvec3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * dvec3{f64(i32(cost2.x > 0)), f64(i32(cost2.y > 0)), f64(i32(cost2.z > 0))} } -refract_dvec4 :: proc "c" (i, n, eta: dvec4) -> dvec4 { +@(require_results) refract_dvec4 :: proc "c" (i, n, eta: dvec4) -> dvec4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) @@ -1086,18 +1086,18 @@ scalarTripleProduct :: proc{ scalarTripleProduct_dvec3, scalarTripleProduct_ivec3, } -scalarTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> f32 { return dot(a, cross(b, c)) } -scalarTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> f64 { return dot(a, cross(b, c)) } -scalarTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> i32 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> f32 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> f64 { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> i32 { return dot(a, cross(b, c)) } vectorTripleProduct :: proc { vectorTripleProduct_vec3, vectorTripleProduct_dvec3, vectorTripleProduct_ivec3, } -vectorTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> vec3 { return cross(a, cross(b, c)) } -vectorTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> dvec3 { return cross(a, cross(b, c)) } -vectorTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> ivec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_vec3 :: proc "c" (a, b, c: vec3) -> vec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_dvec3 :: proc "c" (a, b, c: dvec3) -> dvec3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_ivec3 :: proc "c" (a, b, c: ivec3) -> ivec3 { return cross(a, cross(b, c)) } // Vector Relational Procedures @@ -1120,22 +1120,22 @@ lessThan :: proc{ lessThan_ivec4, lessThan_uvec4, } -lessThan_f32 :: proc "c" (a, b: f32) -> bool { return a < b } -lessThan_f64 :: proc "c" (a, b: f64) -> bool { return a < b } -lessThan_i32 :: proc "c" (a, b: i32) -> bool { return a < b } -lessThan_u32 :: proc "c" (a, b: u32) -> bool { return a < b } -lessThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } -lessThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_f32 :: proc "c" (a, b: f32) -> bool { return a < b } +@(require_results) lessThan_f64 :: proc "c" (a, b: f64) -> bool { return a < b } +@(require_results) lessThan_i32 :: proc "c" (a, b: i32) -> bool { return a < b } +@(require_results) lessThan_u32 :: proc "c" (a, b: u32) -> bool { return a < b } +@(require_results) lessThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } lessThanEqual :: proc{ @@ -1156,22 +1156,22 @@ lessThanEqual :: proc{ lessThanEqual_ivec4, lessThanEqual_uvec4, } -lessThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a <= b } -lessThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a <= b } -lessThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a <= b } -lessThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a <= b } -lessThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a <= b } +@(require_results) lessThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a <= b } +@(require_results) lessThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a <= b } +@(require_results) lessThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a <= b } +@(require_results) lessThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } greaterThan :: proc{ @@ -1192,22 +1192,22 @@ greaterThan :: proc{ greaterThan_ivec4, greaterThan_uvec4, } -greaterThan_f32 :: proc "c" (a, b: f32) -> bool { return a > b } -greaterThan_f64 :: proc "c" (a, b: f64) -> bool { return a > b } -greaterThan_i32 :: proc "c" (a, b: i32) -> bool { return a > b } -greaterThan_u32 :: proc "c" (a, b: u32) -> bool { return a > b } -greaterThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } -greaterThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_f32 :: proc "c" (a, b: f32) -> bool { return a > b } +@(require_results) greaterThan_f64 :: proc "c" (a, b: f64) -> bool { return a > b } +@(require_results) greaterThan_i32 :: proc "c" (a, b: i32) -> bool { return a > b } +@(require_results) greaterThan_u32 :: proc "c" (a, b: u32) -> bool { return a > b } +@(require_results) greaterThan_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } greaterThanEqual :: proc{ @@ -1228,22 +1228,22 @@ greaterThanEqual :: proc{ greaterThanEqual_ivec4, greaterThanEqual_uvec4, } -greaterThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a >= b } -greaterThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a >= b } -greaterThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a >= b } -greaterThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a >= b } -greaterThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_f32 :: proc "c" (a, b: f32) -> bool { return a >= b } +@(require_results) greaterThanEqual_f64 :: proc "c" (a, b: f64) -> bool { return a >= b } +@(require_results) greaterThanEqual_i32 :: proc "c" (a, b: i32) -> bool { return a >= b } +@(require_results) greaterThanEqual_u32 :: proc "c" (a, b: u32) -> bool { return a >= b } +@(require_results) greaterThanEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } equal :: proc{ @@ -1264,22 +1264,22 @@ equal :: proc{ equal_ivec4, equal_uvec4, } -equal_f32 :: proc "c" (a, b: f32) -> bool { return a == b } -equal_f64 :: proc "c" (a, b: f64) -> bool { return a == b } -equal_i32 :: proc "c" (a, b: i32) -> bool { return a == b } -equal_u32 :: proc "c" (a, b: u32) -> bool { return a == b } -equal_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } -equal_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_f32 :: proc "c" (a, b: f32) -> bool { return a == b } +@(require_results) equal_f64 :: proc "c" (a, b: f64) -> bool { return a == b } +@(require_results) equal_i32 :: proc "c" (a, b: i32) -> bool { return a == b } +@(require_results) equal_u32 :: proc "c" (a, b: u32) -> bool { return a == b } +@(require_results) equal_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } notEqual :: proc{ notEqual_f32, @@ -1299,22 +1299,22 @@ notEqual :: proc{ notEqual_ivec4, notEqual_uvec4, } -notEqual_f32 :: proc "c" (a, b: f32) -> bool { return a != b } -notEqual_f64 :: proc "c" (a, b: f64) -> bool { return a != b } -notEqual_i32 :: proc "c" (a, b: i32) -> bool { return a != b } -notEqual_u32 :: proc "c" (a, b: u32) -> bool { return a != b } -notEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } -notEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_f32 :: proc "c" (a, b: f32) -> bool { return a != b } +@(require_results) notEqual_f64 :: proc "c" (a, b: f64) -> bool { return a != b } +@(require_results) notEqual_i32 :: proc "c" (a, b: i32) -> bool { return a != b } +@(require_results) notEqual_u32 :: proc "c" (a, b: u32) -> bool { return a != b } +@(require_results) notEqual_vec2 :: proc "c" (a, b: vec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_dvec2 :: proc "c" (a, b: dvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_ivec2 :: proc "c" (a, b: ivec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_uvec2 :: proc "c" (a, b: uvec2) -> bvec2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_vec3 :: proc "c" (a, b: vec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_dvec3 :: proc "c" (a, b: dvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_ivec3 :: proc "c" (a, b: ivec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_uvec3 :: proc "c" (a, b: uvec3) -> bvec3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_vec4 :: proc "c" (a, b: vec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_dvec4 :: proc "c" (a, b: dvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_ivec4 :: proc "c" (a, b: ivec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_uvec4 :: proc "c" (a, b: uvec4) -> bvec4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } any :: proc{ @@ -1323,10 +1323,10 @@ any :: proc{ any_bvec3, any_bvec4, } -any_bool :: proc "c" (v: bool) -> bool { return v } -any_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x || v.y } -any_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x || v.y || v.z } -any_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x || v.y || v.z || v.w } +@(require_results) any_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) any_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x || v.y } +@(require_results) any_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x || v.y || v.z } +@(require_results) any_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x || v.y || v.z || v.w } all :: proc{ all_bool, @@ -1334,10 +1334,10 @@ all :: proc{ all_bvec3, all_bvec4, } -all_bool :: proc "c" (v: bool) -> bool { return v } -all_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x && v.y } -all_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x && v.y && v.z } -all_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x && v.y && v.z && v.w } +@(require_results) all_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) all_bvec2 :: proc "c" (v: bvec2) -> bool { return v.x && v.y } +@(require_results) all_bvec3 :: proc "c" (v: bvec3) -> bool { return v.x && v.y && v.z } +@(require_results) all_bvec4 :: proc "c" (v: bvec4) -> bool { return v.x && v.y && v.z && v.w } not :: proc{ not_bool, @@ -1345,17 +1345,18 @@ not :: proc{ not_bvec3, not_bvec4, } -not_bool :: proc "c" (v: bool) -> bool { return !v } -not_bvec2 :: proc "c" (v: bvec2) -> bvec2 { return {!v.x, !v.y} } -not_bvec3 :: proc "c" (v: bvec3) -> bvec3 { return {!v.x, !v.y, !v.z} } -not_bvec4 :: proc "c" (v: bvec4) -> bvec4 { return {!v.x, !v.y, !v.z, !v.w} } +@(require_results) not_bool :: proc "c" (v: bool) -> bool { return !v } +@(require_results) not_bvec2 :: proc "c" (v: bvec2) -> bvec2 { return {!v.x, !v.y} } +@(require_results) not_bvec3 :: proc "c" (v: bvec3) -> bvec3 { return {!v.x, !v.y, !v.z} } +@(require_results) not_bvec4 :: proc "c" (v: bvec4) -> bvec4 { return {!v.x, !v.y, !v.z, !v.w} } /// Matrix Utilities -identity :: proc "c" ($M: typeid/matrix[$N, N]$T) -> M { return 1 } +@(require_results) identity :: proc "c" ($M: typeid/matrix[$N, N]$T) -> M { return 1 } +@(require_results) mat4Perspective :: proc "c" (fovy, aspect, near, far: f32) -> (m: mat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1365,6 +1366,7 @@ mat4Perspective :: proc "c" (fovy, aspect, near, far: f32) -> (m: mat4) { m[2, 3] = -2*far*near / (far - near) return } +@(require_results) mat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f32) -> (m: mat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1374,6 +1376,7 @@ mat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f32) -> (m: mat4) { m[2, 3] = -2*near return } +@(require_results) mat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f32) -> (m: mat4) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -1384,6 +1387,7 @@ mat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f32) -> (m: mat4) m[3, 3] = 1 return m } +@(require_results) mat4LookAt :: proc "c" (eye, centre, up: vec3) -> (m: mat4) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1397,6 +1401,7 @@ mat4LookAt :: proc "c" (eye, centre, up: vec3) -> (m: mat4) { m[3] = {-dot(s, eye), -dot(u, eye), +fe, 1} return } +@(require_results) mat4Rotate :: proc "c" (v: vec3, radians: f32) -> (rot: mat4) { c := cos(radians) s := sin(radians) @@ -1423,11 +1428,13 @@ mat4Rotate :: proc "c" (v: vec3, radians: f32) -> (rot: mat4) { return rot } +@(require_results) mat4Translate :: proc "c" (v: vec3) -> (m: mat4) { m = 1 m[3].xyz = v.xyz return } +@(require_results) mat4Scale :: proc "c" (v: vec3) -> (m: mat4) { m[0, 0] = v[0] m[1, 1] = v[1] @@ -1435,6 +1442,7 @@ mat4Scale :: proc "c" (v: vec3) -> (m: mat4) { m[3, 3] = 1 return } +@(require_results) mat4Orientation :: proc "c" (normal, up: vec3) -> mat4 { if normal == up { return 1 @@ -1445,6 +1453,7 @@ mat4Orientation :: proc "c" (normal, up: vec3) -> mat4 { return mat4Rotate(rotation_axis, angle) } +@(require_results) mat4FromQuat :: proc "c" (q: quat) -> (m: mat4) { qxx := q.x * q.x qyy := q.y * q.y @@ -1474,6 +1483,7 @@ mat4FromQuat :: proc "c" (q: quat) -> (m: mat4) { } +@(require_results) dmat4Perspective :: proc "c" (fovy, aspect, near, far: f64) -> (m: dmat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1483,6 +1493,7 @@ dmat4Perspective :: proc "c" (fovy, aspect, near, far: f64) -> (m: dmat4) { m[2, 3] = -2*far*near / (far - near) return } +@(require_results) dmat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f64) -> (m: dmat4) { tan_half_fovy := tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -1492,6 +1503,7 @@ dmat4PerspectiveInfinite :: proc "c" (fovy, aspect, near: f64) -> (m: dmat4) { m[2, 3] = -2*near return } +@(require_results) dmat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f64) -> (m: dmat4) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -1502,6 +1514,7 @@ dmat4Ortho3d :: proc "c" (left, right, bottom, top, near, far: f64) -> (m: dmat4 m[3, 3] = 1 return m } +@(require_results) dmat4LookAt :: proc "c" (eye, centre, up: dvec3) -> (m: dmat4) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1515,6 +1528,7 @@ dmat4LookAt :: proc "c" (eye, centre, up: dvec3) -> (m: dmat4) { m[3] = {-dot(s, eye), -dot(u, eye), +fe, 1} return } +@(require_results) dmat4Rotate :: proc "c" (v: dvec3, radians: f64) -> (rot: dmat4) { c := cos(radians) s := sin(radians) @@ -1541,11 +1555,13 @@ dmat4Rotate :: proc "c" (v: dvec3, radians: f64) -> (rot: dmat4) { return rot } +@(require_results) dmat4Translate :: proc "c" (v: dvec3) -> (m: dmat4) { m = 1 m[3].xyz = v.xyz return } +@(require_results) dmat4Scale :: proc "c" (v: dvec3) -> (m: dmat4) { m[0, 0] = v[0] m[1, 1] = v[1] @@ -1553,6 +1569,7 @@ dmat4Scale :: proc "c" (v: dvec3) -> (m: dmat4) { m[3, 3] = 1 return } +@(require_results) dmat4Orientation :: proc "c" (normal, up: dvec3) -> dmat4 { if normal == up { return 1 @@ -1563,6 +1580,7 @@ dmat4Orientation :: proc "c" (normal, up: dvec3) -> dmat4 { return dmat4Rotate(rotation_axis, angle) } +@(require_results) dmat4FromDquat :: proc "c" (q: dquat) -> (m: dmat4) { qxx := q.x * q.x qyy := q.y * q.y @@ -1601,6 +1619,7 @@ slerp :: proc{ } +@(require_results) quatAxisAngle :: proc "c" (axis: vec3, radians: f32) -> (q: quat) { t := radians*0.5 v := normalize(axis) * sin(t) @@ -1610,6 +1629,7 @@ quatAxisAngle :: proc "c" (axis: vec3, radians: f32) -> (q: quat) { q.w = cos(t) return } +@(require_results) quatNlerp :: proc "c" (a, b: quat, t: f32) -> (c: quat) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -1618,6 +1638,7 @@ quatNlerp :: proc "c" (a, b: quat, t: f32) -> (c: quat) { return c/quat(builtin.abs(c)) } +@(require_results) quatSlerp :: proc "c" (x, y: quat, t: f32) -> (q: quat) { a, b := x, y cos_angle := dot(a, b) @@ -1644,6 +1665,7 @@ quatSlerp :: proc "c" (x, y: quat, t: f32) -> (q: quat) { q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quatFromMat3 :: proc "c" (m: mat3) -> (q: quat) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1693,16 +1715,19 @@ quatFromMat3 :: proc "c" (m: mat3) -> (q: quat) { } return } +@(require_results) quatFromMat4 :: proc "c" (m: mat4) -> (q: quat) { return quatFromMat3(mat3(m)) } +@(require_results) quatMulVec3 :: proc "c" (q: quat, v: vec3) -> vec3 { xyz := vec3{q.x, q.y, q.z} t := cross(xyz, v) return v + q.w*t + cross(xyz, t) } +@(require_results) dquatAxisAngle :: proc "c" (axis: dvec3, radians: f64) -> (q: dquat) { t := radians*0.5 v := normalize(axis) * sin(t) @@ -1712,6 +1737,7 @@ dquatAxisAngle :: proc "c" (axis: dvec3, radians: f64) -> (q: dquat) { q.w = cos(t) return } +@(require_results) dquatNlerp :: proc "c" (a, b: dquat, t: f64) -> (c: dquat) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -1720,6 +1746,7 @@ dquatNlerp :: proc "c" (a, b: dquat, t: f64) -> (c: dquat) { return c/dquat(builtin.abs(c)) } +@(require_results) dquatSlerp :: proc "c" (x, y: dquat, t: f64) -> (q: dquat) { a, b := x, y cos_angle := dot(a, b) @@ -1746,6 +1773,7 @@ dquatSlerp :: proc "c" (x, y: dquat, t: f64) -> (q: dquat) { q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) dquatFromdMat3 :: proc "c" (m: dmat3) -> (q: dquat) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1795,10 +1823,12 @@ dquatFromdMat3 :: proc "c" (m: dmat3) -> (q: dquat) { } return } +@(require_results) dquatFromDmat4 :: proc "c" (m: dmat4) -> (q: dquat) { return dquatFromdMat3(dmat3(m)) } +@(require_results) dquatMulDvec3 :: proc "c" (q: dquat, v: dvec3) -> dvec3 { xyz := dvec3{q.x, q.y, q.z} t := cross(xyz, v) @@ -1808,14 +1838,14 @@ dquatMulDvec3 :: proc "c" (q: dquat, v: dvec3) -> dvec3 { -inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return builtin.inverse(m) } -inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return builtin.inverse(m) } -inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return builtin.inverse(m) } -inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return builtin.inverse(m) } -inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return builtin.inverse(m) } -inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return builtin.inverse(m) } -inverse_quat :: proc "c" (q: quat) -> quat { return 1/q } -inverse_dquat :: proc "c" (q: dquat) -> dquat { return 1/q } +@(require_results) inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return builtin.inverse(m) } +@(require_results) inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return builtin.inverse(m) } +@(require_results) inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return builtin.inverse(m) } +@(require_results) inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return builtin.inverse(m) } +@(require_results) inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return builtin.inverse(m) } +@(require_results) inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return builtin.inverse(m) } +@(require_results) inverse_quat :: proc "c" (q: quat) -> quat { return 1/q } +@(require_results) inverse_dquat :: proc "c" (q: dquat) -> dquat { return 1/q } inverse :: proc{ inverse_mat2, diff --git a/core/math/linalg/glsl/linalg_glsl_math.odin b/core/math/linalg/glsl/linalg_glsl_math.odin index 968a3fa5e..82b1857ab 100644 --- a/core/math/linalg/glsl/linalg_glsl_math.odin +++ b/core/math/linalg/glsl/linalg_glsl_math.odin @@ -2,30 +2,31 @@ package math_linalg_glsl import "core:math" -cos_f32 :: proc "c" (x: f32) -> f32 { return math.cos(x) } -sin_f32 :: proc "c" (x: f32) -> f32 { return math.sin(x) } -tan_f32 :: proc "c" (x: f32) -> f32 { return math.tan(x) } -acos_f32 :: proc "c" (x: f32) -> f32 { return math.acos(x) } -asin_f32 :: proc "c" (x: f32) -> f32 { return math.asin(x) } -atan_f32 :: proc "c" (x: f32) -> f32 { return math.atan(x) } -atan2_f32 :: proc "c" (y, x: f32) -> f32 { return math.atan2(y, x) } -cosh_f32 :: proc "c" (x: f32) -> f32 { return math.cosh(x) } -sinh_f32 :: proc "c" (x: f32) -> f32 { return math.sinh(x) } -tanh_f32 :: proc "c" (x: f32) -> f32 { return math.tanh(x) } -acosh_f32 :: proc "c" (x: f32) -> f32 { return math.acosh(x) } -asinh_f32 :: proc "c" (x: f32) -> f32 { return math.asinh(x) } -atanh_f32 :: proc "c" (x: f32) -> f32 { return math.atanh(x) } -sqrt_f32 :: proc "c" (x: f32) -> f32 { return math.sqrt(x) } -inversesqrt_f32 :: proc "c" (x: f32) -> f32 { return 1.0/math.sqrt(x) } -pow_f32 :: proc "c" (x, y: f32) -> f32 { return math.pow(x, y) } -exp_f32 :: proc "c" (x: f32) -> f32 { return math.exp(x) } -log_f32 :: proc "c" (x: f32) -> f32 { return math.ln(x) } -exp2_f32 :: proc "c" (x: f32) -> f32 { return math.pow(f32(2), x) } -sign_f32 :: proc "c" (x: f32) -> f32 { return math.sign(x) } -floor_f32 :: proc "c" (x: f32) -> f32 { return math.floor(x) } -round_f32 :: proc "c" (x: f32) -> f32 { return math.round(x) } -ceil_f32 :: proc "c" (x: f32) -> f32 { return math.ceil(x) } -mod_f32 :: proc "c" (x, y: f32) -> f32 { return math.mod(x, y) } +@(require_results) cos_f32 :: proc "c" (x: f32) -> f32 { return math.cos(x) } +@(require_results) sin_f32 :: proc "c" (x: f32) -> f32 { return math.sin(x) } +@(require_results) tan_f32 :: proc "c" (x: f32) -> f32 { return math.tan(x) } +@(require_results) acos_f32 :: proc "c" (x: f32) -> f32 { return math.acos(x) } +@(require_results) asin_f32 :: proc "c" (x: f32) -> f32 { return math.asin(x) } +@(require_results) atan_f32 :: proc "c" (x: f32) -> f32 { return math.atan(x) } +@(require_results) atan2_f32 :: proc "c" (y, x: f32) -> f32 { return math.atan2(y, x) } +@(require_results) cosh_f32 :: proc "c" (x: f32) -> f32 { return math.cosh(x) } +@(require_results) sinh_f32 :: proc "c" (x: f32) -> f32 { return math.sinh(x) } +@(require_results) tanh_f32 :: proc "c" (x: f32) -> f32 { return math.tanh(x) } +@(require_results) acosh_f32 :: proc "c" (x: f32) -> f32 { return math.acosh(x) } +@(require_results) asinh_f32 :: proc "c" (x: f32) -> f32 { return math.asinh(x) } +@(require_results) atanh_f32 :: proc "c" (x: f32) -> f32 { return math.atanh(x) } +@(require_results) sqrt_f32 :: proc "c" (x: f32) -> f32 { return math.sqrt(x) } +@(require_results) inversesqrt_f32 :: proc "c" (x: f32) -> f32 { return 1.0/math.sqrt(x) } +@(require_results) pow_f32 :: proc "c" (x, y: f32) -> f32 { return math.pow(x, y) } +@(require_results) exp_f32 :: proc "c" (x: f32) -> f32 { return math.exp(x) } +@(require_results) log_f32 :: proc "c" (x: f32) -> f32 { return math.ln(x) } +@(require_results) exp2_f32 :: proc "c" (x: f32) -> f32 { return math.pow(f32(2), x) } +@(require_results) sign_f32 :: proc "c" (x: f32) -> f32 { return math.sign(x) } +@(require_results) floor_f32 :: proc "c" (x: f32) -> f32 { return math.floor(x) } +@(require_results) round_f32 :: proc "c" (x: f32) -> f32 { return math.round(x) } +@(require_results) ceil_f32 :: proc "c" (x: f32) -> f32 { return math.ceil(x) } +@(require_results) mod_f32 :: proc "c" (x, y: f32) -> f32 { return math.mod(x, y) } +@(require_results) fract_f32 :: proc "c" (x: f32) -> f32 { if x >= 0 { return x - math.trunc(x) @@ -33,30 +34,31 @@ fract_f32 :: proc "c" (x: f32) -> f32 { return math.trunc(-x) + x } -cos_f64 :: proc "c" (x: f64) -> f64 { return math.cos(x) } -sin_f64 :: proc "c" (x: f64) -> f64 { return math.sin(x) } -tan_f64 :: proc "c" (x: f64) -> f64 { return math.tan(x) } -acos_f64 :: proc "c" (x: f64) -> f64 { return math.acos(x) } -asin_f64 :: proc "c" (x: f64) -> f64 { return math.asin(x) } -atan_f64 :: proc "c" (x: f64) -> f64 { return math.atan(x) } -atan2_f64 :: proc "c" (y, x: f64) -> f64 { return math.atan2(y, x) } -cosh_f64 :: proc "c" (x: f64) -> f64 { return math.cosh(x) } -sinh_f64 :: proc "c" (x: f64) -> f64 { return math.sinh(x) } -tanh_f64 :: proc "c" (x: f64) -> f64 { return math.tanh(x) } -acosh_f64 :: proc "c" (x: f64) -> f64 { return math.acosh(x) } -asinh_f64 :: proc "c" (x: f64) -> f64 { return math.asinh(x) } -atanh_f64 :: proc "c" (x: f64) -> f64 { return math.atanh(x) } -sqrt_f64 :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } -inversesqrt_f64 :: proc "c" (x: f64) -> f64 { return 1.0/math.sqrt(x) } -pow_f64 :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } -exp_f64 :: proc "c" (x: f64) -> f64 { return math.exp(x) } -log_f64 :: proc "c" (x: f64) -> f64 { return math.ln(x) } -exp2_f64 :: proc "c" (x: f64) -> f64 { return math.pow(f64(2), x) } -sign_f64 :: proc "c" (x: f64) -> f64 { return math.sign(x) } -floor_f64 :: proc "c" (x: f64) -> f64 { return math.floor(x) } -round_f64 :: proc "c" (x: f64) -> f64 { return math.round(x) } -ceil_f64 :: proc "c" (x: f64) -> f64 { return math.ceil(x) } -mod_f64 :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) } +@(require_results) cos_f64 :: proc "c" (x: f64) -> f64 { return math.cos(x) } +@(require_results) sin_f64 :: proc "c" (x: f64) -> f64 { return math.sin(x) } +@(require_results) tan_f64 :: proc "c" (x: f64) -> f64 { return math.tan(x) } +@(require_results) acos_f64 :: proc "c" (x: f64) -> f64 { return math.acos(x) } +@(require_results) asin_f64 :: proc "c" (x: f64) -> f64 { return math.asin(x) } +@(require_results) atan_f64 :: proc "c" (x: f64) -> f64 { return math.atan(x) } +@(require_results) atan2_f64 :: proc "c" (y, x: f64) -> f64 { return math.atan2(y, x) } +@(require_results) cosh_f64 :: proc "c" (x: f64) -> f64 { return math.cosh(x) } +@(require_results) sinh_f64 :: proc "c" (x: f64) -> f64 { return math.sinh(x) } +@(require_results) tanh_f64 :: proc "c" (x: f64) -> f64 { return math.tanh(x) } +@(require_results) acosh_f64 :: proc "c" (x: f64) -> f64 { return math.acosh(x) } +@(require_results) asinh_f64 :: proc "c" (x: f64) -> f64 { return math.asinh(x) } +@(require_results) atanh_f64 :: proc "c" (x: f64) -> f64 { return math.atanh(x) } +@(require_results) sqrt_f64 :: proc "c" (x: f64) -> f64 { return math.sqrt(x) } +@(require_results) inversesqrt_f64 :: proc "c" (x: f64) -> f64 { return 1.0/math.sqrt(x) } +@(require_results) pow_f64 :: proc "c" (x, y: f64) -> f64 { return math.pow(x, y) } +@(require_results) exp_f64 :: proc "c" (x: f64) -> f64 { return math.exp(x) } +@(require_results) log_f64 :: proc "c" (x: f64) -> f64 { return math.ln(x) } +@(require_results) exp2_f64 :: proc "c" (x: f64) -> f64 { return math.pow(f64(2), x) } +@(require_results) sign_f64 :: proc "c" (x: f64) -> f64 { return math.sign(x) } +@(require_results) floor_f64 :: proc "c" (x: f64) -> f64 { return math.floor(x) } +@(require_results) round_f64 :: proc "c" (x: f64) -> f64 { return math.round(x) } +@(require_results) ceil_f64 :: proc "c" (x: f64) -> f64 { return math.ceil(x) } +@(require_results) mod_f64 :: proc "c" (x, y: f64) -> f64 { return math.mod(x, y) } +@(require_results) fract_f64 :: proc "c" (x: f64) -> f64 { if x >= 0 { return x - math.trunc(x) diff --git a/core/math/linalg/hlsl/linalg_hlsl.odin b/core/math/linalg/hlsl/linalg_hlsl.odin index 3f73dcd1f..351aa7ea3 100644 --- a/core/math/linalg/hlsl/linalg_hlsl.odin +++ b/core/math/linalg/hlsl/linalg_hlsl.odin @@ -114,12 +114,12 @@ cos :: proc{ cos_double3, cos_double4, } -cos_float2 :: proc "c" (x: float2) -> float2 { return {cos(x.x), cos(x.y)} } -cos_float3 :: proc "c" (x: float3) -> float3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_float4 :: proc "c" (x: float4) -> float4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } -cos_double2 :: proc "c" (x: double2) -> double2 { return {cos(x.x), cos(x.y)} } -cos_double3 :: proc "c" (x: double3) -> double3 { return {cos(x.x), cos(x.y), cos(x.z)} } -cos_double4 :: proc "c" (x: double4) -> double4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_float2 :: proc "c" (x: float2) -> float2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_float3 :: proc "c" (x: float3) -> float3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_float4 :: proc "c" (x: float4) -> float4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } +@(require_results) cos_double2 :: proc "c" (x: double2) -> double2 { return {cos(x.x), cos(x.y)} } +@(require_results) cos_double3 :: proc "c" (x: double3) -> double3 { return {cos(x.x), cos(x.y), cos(x.z)} } +@(require_results) cos_double4 :: proc "c" (x: double4) -> double4 { return {cos(x.x), cos(x.y), cos(x.z), cos(x.w)} } sin :: proc{ sin_float, @@ -131,12 +131,12 @@ sin :: proc{ sin_double3, sin_double4, } -sin_float2 :: proc "c" (x: float2) -> float2 { return {sin(x.x), sin(x.y)} } -sin_float3 :: proc "c" (x: float3) -> float3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_float4 :: proc "c" (x: float4) -> float4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } -sin_double2 :: proc "c" (x: double2) -> double2 { return {sin(x.x), sin(x.y)} } -sin_double3 :: proc "c" (x: double3) -> double3 { return {sin(x.x), sin(x.y), sin(x.z)} } -sin_double4 :: proc "c" (x: double4) -> double4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_float2 :: proc "c" (x: float2) -> float2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_float3 :: proc "c" (x: float3) -> float3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_float4 :: proc "c" (x: float4) -> float4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } +@(require_results) sin_double2 :: proc "c" (x: double2) -> double2 { return {sin(x.x), sin(x.y)} } +@(require_results) sin_double3 :: proc "c" (x: double3) -> double3 { return {sin(x.x), sin(x.y), sin(x.z)} } +@(require_results) sin_double4 :: proc "c" (x: double4) -> double4 { return {sin(x.x), sin(x.y), sin(x.z), sin(x.w)} } tan :: proc{ tan_float, @@ -148,12 +148,12 @@ tan :: proc{ tan_double3, tan_double4, } -tan_float2 :: proc "c" (x: float2) -> float2 { return {tan(x.x), tan(x.y)} } -tan_float3 :: proc "c" (x: float3) -> float3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_float4 :: proc "c" (x: float4) -> float4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } -tan_double2 :: proc "c" (x: double2) -> double2 { return {tan(x.x), tan(x.y)} } -tan_double3 :: proc "c" (x: double3) -> double3 { return {tan(x.x), tan(x.y), tan(x.z)} } -tan_double4 :: proc "c" (x: double4) -> double4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_float2 :: proc "c" (x: float2) -> float2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_float3 :: proc "c" (x: float3) -> float3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_float4 :: proc "c" (x: float4) -> float4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } +@(require_results) tan_double2 :: proc "c" (x: double2) -> double2 { return {tan(x.x), tan(x.y)} } +@(require_results) tan_double3 :: proc "c" (x: double3) -> double3 { return {tan(x.x), tan(x.y), tan(x.z)} } +@(require_results) tan_double4 :: proc "c" (x: double4) -> double4 { return {tan(x.x), tan(x.y), tan(x.z), tan(x.w)} } acos :: proc{ acos_float, @@ -165,12 +165,12 @@ acos :: proc{ acos_double3, acos_double4, } -acos_float2 :: proc "c" (x: float2) -> float2 { return {acos(x.x), acos(x.y)} } -acos_float3 :: proc "c" (x: float3) -> float3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_float4 :: proc "c" (x: float4) -> float4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } -acos_double2 :: proc "c" (x: double2) -> double2 { return {acos(x.x), acos(x.y)} } -acos_double3 :: proc "c" (x: double3) -> double3 { return {acos(x.x), acos(x.y), acos(x.z)} } -acos_double4 :: proc "c" (x: double4) -> double4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_float2 :: proc "c" (x: float2) -> float2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_float3 :: proc "c" (x: float3) -> float3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_float4 :: proc "c" (x: float4) -> float4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } +@(require_results) acos_double2 :: proc "c" (x: double2) -> double2 { return {acos(x.x), acos(x.y)} } +@(require_results) acos_double3 :: proc "c" (x: double3) -> double3 { return {acos(x.x), acos(x.y), acos(x.z)} } +@(require_results) acos_double4 :: proc "c" (x: double4) -> double4 { return {acos(x.x), acos(x.y), acos(x.z), acos(x.w)} } asin :: proc{ asin_float, @@ -182,12 +182,12 @@ asin :: proc{ asin_double3, asin_double4, } -asin_float2 :: proc "c" (x: float2) -> float2 { return {asin(x.x), asin(x.y)} } -asin_float3 :: proc "c" (x: float3) -> float3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_float4 :: proc "c" (x: float4) -> float4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } -asin_double2 :: proc "c" (x: double2) -> double2 { return {asin(x.x), asin(x.y)} } -asin_double3 :: proc "c" (x: double3) -> double3 { return {asin(x.x), asin(x.y), asin(x.z)} } -asin_double4 :: proc "c" (x: double4) -> double4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_float2 :: proc "c" (x: float2) -> float2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_float3 :: proc "c" (x: float3) -> float3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_float4 :: proc "c" (x: float4) -> float4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } +@(require_results) asin_double2 :: proc "c" (x: double2) -> double2 { return {asin(x.x), asin(x.y)} } +@(require_results) asin_double3 :: proc "c" (x: double3) -> double3 { return {asin(x.x), asin(x.y), asin(x.z)} } +@(require_results) asin_double4 :: proc "c" (x: double4) -> double4 { return {asin(x.x), asin(x.y), asin(x.z), asin(x.w)} } atan :: proc{ atan_float, @@ -207,12 +207,12 @@ atan :: proc{ atan2_double3, atan2_double4, } -atan_float2 :: proc "c" (x: float2) -> float2 { return {atan(x.x), atan(x.y)} } -atan_float3 :: proc "c" (x: float3) -> float3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_float4 :: proc "c" (x: float4) -> float4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } -atan_double2 :: proc "c" (x: double2) -> double2 { return {atan(x.x), atan(x.y)} } -atan_double3 :: proc "c" (x: double3) -> double3 { return {atan(x.x), atan(x.y), atan(x.z)} } -atan_double4 :: proc "c" (x: double4) -> double4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_float2 :: proc "c" (x: float2) -> float2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_float3 :: proc "c" (x: float3) -> float3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_float4 :: proc "c" (x: float4) -> float4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } +@(require_results) atan_double2 :: proc "c" (x: double2) -> double2 { return {atan(x.x), atan(x.y)} } +@(require_results) atan_double3 :: proc "c" (x: double3) -> double3 { return {atan(x.x), atan(x.y), atan(x.z)} } +@(require_results) atan_double4 :: proc "c" (x: double4) -> double4 { return {atan(x.x), atan(x.y), atan(x.z), atan(x.w)} } atan2 :: proc{ atan2_float, @@ -224,12 +224,12 @@ atan2 :: proc{ atan2_double3, atan2_double4, } -atan2_float2 :: proc "c" (y, x: float2) -> float2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_float3 :: proc "c" (y, x: float3) -> float3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_float4 :: proc "c" (y, x: float4) -> float4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } -atan2_double2 :: proc "c" (y, x: double2) -> double2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } -atan2_double3 :: proc "c" (y, x: double3) -> double3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } -atan2_double4 :: proc "c" (y, x: double4) -> double4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_float2 :: proc "c" (y, x: float2) -> float2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_float3 :: proc "c" (y, x: float3) -> float3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_float4 :: proc "c" (y, x: float4) -> float4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } +@(require_results) atan2_double2 :: proc "c" (y, x: double2) -> double2 { return {atan2(y.x, x.x), atan2(y.y, x.y)} } +@(require_results) atan2_double3 :: proc "c" (y, x: double3) -> double3 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)} } +@(require_results) atan2_double4 :: proc "c" (y, x: double4) -> double4 { return {atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)} } @@ -243,12 +243,12 @@ cosh :: proc{ cosh_double3, cosh_double4, } -cosh_float2 :: proc "c" (x: float2) -> float2 { return {cosh(x.x), cosh(x.y)} } -cosh_float3 :: proc "c" (x: float3) -> float3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_float4 :: proc "c" (x: float4) -> float4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } -cosh_double2 :: proc "c" (x: double2) -> double2 { return {cosh(x.x), cosh(x.y)} } -cosh_double3 :: proc "c" (x: double3) -> double3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } -cosh_double4 :: proc "c" (x: double4) -> double4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_float2 :: proc "c" (x: float2) -> float2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_float3 :: proc "c" (x: float3) -> float3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_float4 :: proc "c" (x: float4) -> float4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } +@(require_results) cosh_double2 :: proc "c" (x: double2) -> double2 { return {cosh(x.x), cosh(x.y)} } +@(require_results) cosh_double3 :: proc "c" (x: double3) -> double3 { return {cosh(x.x), cosh(x.y), cosh(x.z)} } +@(require_results) cosh_double4 :: proc "c" (x: double4) -> double4 { return {cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)} } sinh :: proc{ @@ -261,12 +261,12 @@ sinh :: proc{ sinh_double3, sinh_double4, } -sinh_float2 :: proc "c" (x: float2) -> float2 { return {sinh(x.x), sinh(x.y)} } -sinh_float3 :: proc "c" (x: float3) -> float3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_float4 :: proc "c" (x: float4) -> float4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } -sinh_double2 :: proc "c" (x: double2) -> double2 { return {sinh(x.x), sinh(x.y)} } -sinh_double3 :: proc "c" (x: double3) -> double3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } -sinh_double4 :: proc "c" (x: double4) -> double4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_float2 :: proc "c" (x: float2) -> float2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_float3 :: proc "c" (x: float3) -> float3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_float4 :: proc "c" (x: float4) -> float4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } +@(require_results) sinh_double2 :: proc "c" (x: double2) -> double2 { return {sinh(x.x), sinh(x.y)} } +@(require_results) sinh_double3 :: proc "c" (x: double3) -> double3 { return {sinh(x.x), sinh(x.y), sinh(x.z)} } +@(require_results) sinh_double4 :: proc "c" (x: double4) -> double4 { return {sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)} } tanh :: proc{ tanh_float, @@ -278,12 +278,12 @@ tanh :: proc{ tanh_double3, tanh_double4, } -tanh_float2 :: proc "c" (x: float2) -> float2 { return {tanh(x.x), tanh(x.y)} } -tanh_float3 :: proc "c" (x: float3) -> float3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_float4 :: proc "c" (x: float4) -> float4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } -tanh_double2 :: proc "c" (x: double2) -> double2 { return {tanh(x.x), tanh(x.y)} } -tanh_double3 :: proc "c" (x: double3) -> double3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } -tanh_double4 :: proc "c" (x: double4) -> double4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_float2 :: proc "c" (x: float2) -> float2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_float3 :: proc "c" (x: float3) -> float3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_float4 :: proc "c" (x: float4) -> float4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } +@(require_results) tanh_double2 :: proc "c" (x: double2) -> double2 { return {tanh(x.x), tanh(x.y)} } +@(require_results) tanh_double3 :: proc "c" (x: double3) -> double3 { return {tanh(x.x), tanh(x.y), tanh(x.z)} } +@(require_results) tanh_double4 :: proc "c" (x: double4) -> double4 { return {tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)} } acosh :: proc{ acosh_float, @@ -295,12 +295,12 @@ acosh :: proc{ acosh_double3, acosh_double4, } -acosh_float2 :: proc "c" (x: float2) -> float2 { return {acosh(x.x), acosh(x.y)} } -acosh_float3 :: proc "c" (x: float3) -> float3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_float4 :: proc "c" (x: float4) -> float4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } -acosh_double2 :: proc "c" (x: double2) -> double2 { return {acosh(x.x), acosh(x.y)} } -acosh_double3 :: proc "c" (x: double3) -> double3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } -acosh_double4 :: proc "c" (x: double4) -> double4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_float2 :: proc "c" (x: float2) -> float2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_float3 :: proc "c" (x: float3) -> float3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_float4 :: proc "c" (x: float4) -> float4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } +@(require_results) acosh_double2 :: proc "c" (x: double2) -> double2 { return {acosh(x.x), acosh(x.y)} } +@(require_results) acosh_double3 :: proc "c" (x: double3) -> double3 { return {acosh(x.x), acosh(x.y), acosh(x.z)} } +@(require_results) acosh_double4 :: proc "c" (x: double4) -> double4 { return {acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)} } asinh :: proc{ asinh_float, @@ -312,12 +312,12 @@ asinh :: proc{ asinh_double3, asinh_double4, } -asinh_float2 :: proc "c" (x: float2) -> float2 { return {asinh(x.x), asinh(x.y)} } -asinh_float3 :: proc "c" (x: float3) -> float3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_float4 :: proc "c" (x: float4) -> float4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } -asinh_double2 :: proc "c" (x: double2) -> double2 { return {asinh(x.x), asinh(x.y)} } -asinh_double3 :: proc "c" (x: double3) -> double3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } -asinh_double4 :: proc "c" (x: double4) -> double4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_float2 :: proc "c" (x: float2) -> float2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_float3 :: proc "c" (x: float3) -> float3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_float4 :: proc "c" (x: float4) -> float4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } +@(require_results) asinh_double2 :: proc "c" (x: double2) -> double2 { return {asinh(x.x), asinh(x.y)} } +@(require_results) asinh_double3 :: proc "c" (x: double3) -> double3 { return {asinh(x.x), asinh(x.y), asinh(x.z)} } +@(require_results) asinh_double4 :: proc "c" (x: double4) -> double4 { return {asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)} } atanh :: proc{ atanh_float, @@ -329,12 +329,12 @@ atanh :: proc{ atanh_double3, atanh_double4, } -atanh_float2 :: proc "c" (x: float2) -> float2 { return {atanh(x.x), atanh(x.y)} } -atanh_float3 :: proc "c" (x: float3) -> float3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_float4 :: proc "c" (x: float4) -> float4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } -atanh_double2 :: proc "c" (x: double2) -> double2 { return {atanh(x.x), atanh(x.y)} } -atanh_double3 :: proc "c" (x: double3) -> double3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } -atanh_double4 :: proc "c" (x: double4) -> double4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_float2 :: proc "c" (x: float2) -> float2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_float3 :: proc "c" (x: float3) -> float3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_float4 :: proc "c" (x: float4) -> float4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } +@(require_results) atanh_double2 :: proc "c" (x: double2) -> double2 { return {atanh(x.x), atanh(x.y)} } +@(require_results) atanh_double3 :: proc "c" (x: double3) -> double3 { return {atanh(x.x), atanh(x.y), atanh(x.z)} } +@(require_results) atanh_double4 :: proc "c" (x: double4) -> double4 { return {atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)} } sqrt :: proc{ sqrt_float, @@ -346,12 +346,12 @@ sqrt :: proc{ sqrt_double3, sqrt_double4, } -sqrt_float2 :: proc "c" (x: float2) -> float2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_float3 :: proc "c" (x: float3) -> float3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_float4 :: proc "c" (x: float4) -> float4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } -sqrt_double2 :: proc "c" (x: double2) -> double2 { return {sqrt(x.x), sqrt(x.y)} } -sqrt_double3 :: proc "c" (x: double3) -> double3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } -sqrt_double4 :: proc "c" (x: double4) -> double4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_float2 :: proc "c" (x: float2) -> float2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_float3 :: proc "c" (x: float3) -> float3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_float4 :: proc "c" (x: float4) -> float4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } +@(require_results) sqrt_double2 :: proc "c" (x: double2) -> double2 { return {sqrt(x.x), sqrt(x.y)} } +@(require_results) sqrt_double3 :: proc "c" (x: double3) -> double3 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z)} } +@(require_results) sqrt_double4 :: proc "c" (x: double4) -> double4 { return {sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)} } rsqrt :: proc{ rsqrt_float, @@ -363,12 +363,12 @@ rsqrt :: proc{ rsqrt_double3, rsqrt_double4, } -rsqrt_float2 :: proc "c" (x: float2) -> float2 { return {rsqrt(x.x), rsqrt(x.y)} } -rsqrt_float3 :: proc "c" (x: float3) -> float3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } -rsqrt_float4 :: proc "c" (x: float4) -> float4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } -rsqrt_double2 :: proc "c" (x: double2) -> double2 { return {rsqrt(x.x), rsqrt(x.y)} } -rsqrt_double3 :: proc "c" (x: double3) -> double3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } -rsqrt_double4 :: proc "c" (x: double4) -> double4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } +@(require_results) rsqrt_float2 :: proc "c" (x: float2) -> float2 { return {rsqrt(x.x), rsqrt(x.y)} } +@(require_results) rsqrt_float3 :: proc "c" (x: float3) -> float3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } +@(require_results) rsqrt_float4 :: proc "c" (x: float4) -> float4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } +@(require_results) rsqrt_double2 :: proc "c" (x: double2) -> double2 { return {rsqrt(x.x), rsqrt(x.y)} } +@(require_results) rsqrt_double3 :: proc "c" (x: double3) -> double3 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z)} } +@(require_results) rsqrt_double4 :: proc "c" (x: double4) -> double4 { return {rsqrt(x.x), rsqrt(x.y), rsqrt(x.z), rsqrt(x.w)} } rcp :: proc{ rcp_float, @@ -380,12 +380,12 @@ rcp :: proc{ rcp_double3, rcp_double4, } -rcp_float2 :: proc "c" (x: float2) -> float2 { return {rcp(x.x), rcp(x.y)} } -rcp_float3 :: proc "c" (x: float3) -> float3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } -rcp_float4 :: proc "c" (x: float4) -> float4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } -rcp_double2 :: proc "c" (x: double2) -> double2 { return {rcp(x.x), rcp(x.y)} } -rcp_double3 :: proc "c" (x: double3) -> double3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } -rcp_double4 :: proc "c" (x: double4) -> double4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } +@(require_results) rcp_float2 :: proc "c" (x: float2) -> float2 { return {rcp(x.x), rcp(x.y)} } +@(require_results) rcp_float3 :: proc "c" (x: float3) -> float3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } +@(require_results) rcp_float4 :: proc "c" (x: float4) -> float4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } +@(require_results) rcp_double2 :: proc "c" (x: double2) -> double2 { return {rcp(x.x), rcp(x.y)} } +@(require_results) rcp_double3 :: proc "c" (x: double3) -> double3 { return {rcp(x.x), rcp(x.y), rcp(x.z)} } +@(require_results) rcp_double4 :: proc "c" (x: double4) -> double4 { return {rcp(x.x), rcp(x.y), rcp(x.z), rcp(x.w)} } pow :: proc{ @@ -398,12 +398,12 @@ pow :: proc{ pow_double3, pow_double4, } -pow_float2 :: proc "c" (x, y: float2) -> float2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_float3 :: proc "c" (x, y: float3) -> float3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_float4 :: proc "c" (x, y: float4) -> float4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } -pow_double2 :: proc "c" (x, y: double2) -> double2 { return {pow(x.x, y.x), pow(x.y, y.y)} } -pow_double3 :: proc "c" (x, y: double3) -> double3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } -pow_double4 :: proc "c" (x, y: double4) -> double4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_float2 :: proc "c" (x, y: float2) -> float2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_float3 :: proc "c" (x, y: float3) -> float3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_float4 :: proc "c" (x, y: float4) -> float4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } +@(require_results) pow_double2 :: proc "c" (x, y: double2) -> double2 { return {pow(x.x, y.x), pow(x.y, y.y)} } +@(require_results) pow_double3 :: proc "c" (x, y: double3) -> double3 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)} } +@(require_results) pow_double4 :: proc "c" (x, y: double4) -> double4 { return {pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)} } @@ -417,12 +417,12 @@ exp :: proc{ exp_double3, exp_double4, } -exp_float2 :: proc "c" (x: float2) -> float2 { return {exp(x.x), exp(x.y)} } -exp_float3 :: proc "c" (x: float3) -> float3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_float4 :: proc "c" (x: float4) -> float4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } -exp_double2 :: proc "c" (x: double2) -> double2 { return {exp(x.x), exp(x.y)} } -exp_double3 :: proc "c" (x: double3) -> double3 { return {exp(x.x), exp(x.y), exp(x.z)} } -exp_double4 :: proc "c" (x: double4) -> double4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_float2 :: proc "c" (x: float2) -> float2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_float3 :: proc "c" (x: float3) -> float3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_float4 :: proc "c" (x: float4) -> float4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } +@(require_results) exp_double2 :: proc "c" (x: double2) -> double2 { return {exp(x.x), exp(x.y)} } +@(require_results) exp_double3 :: proc "c" (x: double3) -> double3 { return {exp(x.x), exp(x.y), exp(x.z)} } +@(require_results) exp_double4 :: proc "c" (x: double4) -> double4 { return {exp(x.x), exp(x.y), exp(x.z), exp(x.w)} } @@ -436,12 +436,12 @@ log :: proc{ log_double3, log_double4, } -log_float2 :: proc "c" (x: float2) -> float2 { return {log(x.x), log(x.y)} } -log_float3 :: proc "c" (x: float3) -> float3 { return {log(x.x), log(x.y), log(x.z)} } -log_float4 :: proc "c" (x: float4) -> float4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } -log_double2 :: proc "c" (x: double2) -> double2 { return {log(x.x), log(x.y)} } -log_double3 :: proc "c" (x: double3) -> double3 { return {log(x.x), log(x.y), log(x.z)} } -log_double4 :: proc "c" (x: double4) -> double4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_float2 :: proc "c" (x: float2) -> float2 { return {log(x.x), log(x.y)} } +@(require_results) log_float3 :: proc "c" (x: float3) -> float3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_float4 :: proc "c" (x: float4) -> float4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } +@(require_results) log_double2 :: proc "c" (x: double2) -> double2 { return {log(x.x), log(x.y)} } +@(require_results) log_double3 :: proc "c" (x: double3) -> double3 { return {log(x.x), log(x.y), log(x.z)} } +@(require_results) log_double4 :: proc "c" (x: double4) -> double4 { return {log(x.x), log(x.y), log(x.z), log(x.w)} } log2 :: proc{ @@ -454,12 +454,12 @@ log2 :: proc{ log2_double3, log2_double4, } -log2_float2 :: proc "c" (x: float2) -> float2 { return {log2(x.x), log2(x.y)} } -log2_float3 :: proc "c" (x: float3) -> float3 { return {log2(x.x), log2(x.y), log2(x.z)} } -log2_float4 :: proc "c" (x: float4) -> float4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } -log2_double2 :: proc "c" (x: double2) -> double2 { return {log2(x.x), log2(x.y)} } -log2_double3 :: proc "c" (x: double3) -> double3 { return {log2(x.x), log2(x.y), log2(x.z)} } -log2_double4 :: proc "c" (x: double4) -> double4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } +@(require_results) log2_float2 :: proc "c" (x: float2) -> float2 { return {log2(x.x), log2(x.y)} } +@(require_results) log2_float3 :: proc "c" (x: float3) -> float3 { return {log2(x.x), log2(x.y), log2(x.z)} } +@(require_results) log2_float4 :: proc "c" (x: float4) -> float4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } +@(require_results) log2_double2 :: proc "c" (x: double2) -> double2 { return {log2(x.x), log2(x.y)} } +@(require_results) log2_double3 :: proc "c" (x: double3) -> double3 { return {log2(x.x), log2(x.y), log2(x.z)} } +@(require_results) log2_double4 :: proc "c" (x: double4) -> double4 { return {log2(x.x), log2(x.y), log2(x.z), log2(x.w)} } @@ -473,12 +473,12 @@ log10 :: proc{ log10_double3, log10_double4, } -log10_float2 :: proc "c" (x: float2) -> float2 { return {log10(x.x), log10(x.y)} } -log10_float3 :: proc "c" (x: float3) -> float3 { return {log10(x.x), log10(x.y), log10(x.z)} } -log10_float4 :: proc "c" (x: float4) -> float4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } -log10_double2 :: proc "c" (x: double2) -> double2 { return {log10(x.x), log10(x.y)} } -log10_double3 :: proc "c" (x: double3) -> double3 { return {log10(x.x), log10(x.y), log10(x.z)} } -log10_double4 :: proc "c" (x: double4) -> double4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } +@(require_results) log10_float2 :: proc "c" (x: float2) -> float2 { return {log10(x.x), log10(x.y)} } +@(require_results) log10_float3 :: proc "c" (x: float3) -> float3 { return {log10(x.x), log10(x.y), log10(x.z)} } +@(require_results) log10_float4 :: proc "c" (x: float4) -> float4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } +@(require_results) log10_double2 :: proc "c" (x: double2) -> double2 { return {log10(x.x), log10(x.y)} } +@(require_results) log10_double3 :: proc "c" (x: double3) -> double3 { return {log10(x.x), log10(x.y), log10(x.z)} } +@(require_results) log10_double4 :: proc "c" (x: double4) -> double4 { return {log10(x.x), log10(x.y), log10(x.z), log10(x.w)} } @@ -493,12 +493,12 @@ exp2 :: proc{ exp2_double3, exp2_double4, } -exp2_float2 :: proc "c" (x: float2) -> float2 { return {exp2(x.x), exp2(x.y)} } -exp2_float3 :: proc "c" (x: float3) -> float3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_float4 :: proc "c" (x: float4) -> float4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } -exp2_double2 :: proc "c" (x: double2) -> double2 { return {exp2(x.x), exp2(x.y)} } -exp2_double3 :: proc "c" (x: double3) -> double3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } -exp2_double4 :: proc "c" (x: double4) -> double4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_float2 :: proc "c" (x: float2) -> float2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_float3 :: proc "c" (x: float3) -> float3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_float4 :: proc "c" (x: float4) -> float4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } +@(require_results) exp2_double2 :: proc "c" (x: double2) -> double2 { return {exp2(x.x), exp2(x.y)} } +@(require_results) exp2_double3 :: proc "c" (x: double3) -> double3 { return {exp2(x.x), exp2(x.y), exp2(x.z)} } +@(require_results) exp2_double4 :: proc "c" (x: double4) -> double4 { return {exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)} } sign :: proc{ @@ -519,20 +519,20 @@ sign :: proc{ sign_uint3, sign_uint4, } -sign_int :: proc "c" (x: int) -> int { return -1 if x < 0 else +1 if x > 0 else 0 } -sign_uint :: proc "c" (x: uint) -> uint { return +1 if x > 0 else 0 } -sign_float2 :: proc "c" (x: float2) -> float2 { return {sign(x.x), sign(x.y)} } -sign_float3 :: proc "c" (x: float3) -> float3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_float4 :: proc "c" (x: float4) -> float4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_double2 :: proc "c" (x: double2) -> double2 { return {sign(x.x), sign(x.y)} } -sign_double3 :: proc "c" (x: double3) -> double3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_double4 :: proc "c" (x: double4) -> double4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_int2 :: proc "c" (x: int2) -> int2 { return {sign(x.x), sign(x.y)} } -sign_int3 :: proc "c" (x: int3) -> int3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_int4 :: proc "c" (x: int4) -> int4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } -sign_uint2 :: proc "c" (x: uint2) -> uint2 { return {sign(x.x), sign(x.y)} } -sign_uint3 :: proc "c" (x: uint3) -> uint3 { return {sign(x.x), sign(x.y), sign(x.z)} } -sign_uint4 :: proc "c" (x: uint4) -> uint4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_int :: proc "c" (x: int) -> int { return -1 if x < 0 else +1 if x > 0 else 0 } +@(require_results) sign_uint :: proc "c" (x: uint) -> uint { return +1 if x > 0 else 0 } +@(require_results) sign_float2 :: proc "c" (x: float2) -> float2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_float3 :: proc "c" (x: float3) -> float3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_float4 :: proc "c" (x: float4) -> float4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_double2 :: proc "c" (x: double2) -> double2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_double3 :: proc "c" (x: double3) -> double3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_double4 :: proc "c" (x: double4) -> double4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_int2 :: proc "c" (x: int2) -> int2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_int3 :: proc "c" (x: int3) -> int3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_int4 :: proc "c" (x: int4) -> int4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } +@(require_results) sign_uint2 :: proc "c" (x: uint2) -> uint2 { return {sign(x.x), sign(x.y)} } +@(require_results) sign_uint3 :: proc "c" (x: uint3) -> uint3 { return {sign(x.x), sign(x.y), sign(x.z)} } +@(require_results) sign_uint4 :: proc "c" (x: uint4) -> uint4 { return {sign(x.x), sign(x.y), sign(x.z), sign(x.w)} } floor :: proc{ floor_float, @@ -544,12 +544,12 @@ floor :: proc{ floor_double3, floor_double4, } -floor_float2 :: proc "c" (x: float2) -> float2 { return {floor(x.x), floor(x.y)} } -floor_float3 :: proc "c" (x: float3) -> float3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_float4 :: proc "c" (x: float4) -> float4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } -floor_double2 :: proc "c" (x: double2) -> double2 { return {floor(x.x), floor(x.y)} } -floor_double3 :: proc "c" (x: double3) -> double3 { return {floor(x.x), floor(x.y), floor(x.z)} } -floor_double4 :: proc "c" (x: double4) -> double4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_float2 :: proc "c" (x: float2) -> float2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_float3 :: proc "c" (x: float3) -> float3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_float4 :: proc "c" (x: float4) -> float4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } +@(require_results) floor_double2 :: proc "c" (x: double2) -> double2 { return {floor(x.x), floor(x.y)} } +@(require_results) floor_double3 :: proc "c" (x: double3) -> double3 { return {floor(x.x), floor(x.y), floor(x.z)} } +@(require_results) floor_double4 :: proc "c" (x: double4) -> double4 { return {floor(x.x), floor(x.y), floor(x.z), floor(x.w)} } round :: proc{ round_float, @@ -561,12 +561,12 @@ round :: proc{ round_double3, round_double4, } -round_float2 :: proc "c" (x: float2) -> float2 { return {round(x.x), round(x.y)} } -round_float3 :: proc "c" (x: float3) -> float3 { return {round(x.x), round(x.y), round(x.z)} } -round_float4 :: proc "c" (x: float4) -> float4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } -round_double2 :: proc "c" (x: double2) -> double2 { return {round(x.x), round(x.y)} } -round_double3 :: proc "c" (x: double3) -> double3 { return {round(x.x), round(x.y), round(x.z)} } -round_double4 :: proc "c" (x: double4) -> double4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_float2 :: proc "c" (x: float2) -> float2 { return {round(x.x), round(x.y)} } +@(require_results) round_float3 :: proc "c" (x: float3) -> float3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_float4 :: proc "c" (x: float4) -> float4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } +@(require_results) round_double2 :: proc "c" (x: double2) -> double2 { return {round(x.x), round(x.y)} } +@(require_results) round_double3 :: proc "c" (x: double3) -> double3 { return {round(x.x), round(x.y), round(x.z)} } +@(require_results) round_double4 :: proc "c" (x: double4) -> double4 { return {round(x.x), round(x.y), round(x.z), round(x.w)} } ceil :: proc{ @@ -579,22 +579,22 @@ ceil :: proc{ ceil_double3, ceil_double4, } -ceil_float2 :: proc "c" (x: float2) -> float2 { return {ceil(x.x), ceil(x.y)} } -ceil_float3 :: proc "c" (x: float3) -> float3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_float4 :: proc "c" (x: float4) -> float4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -ceil_double2 :: proc "c" (x: double2) -> double2 { return {ceil(x.x), ceil(x.y)} } -ceil_double3 :: proc "c" (x: double3) -> double3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } -ceil_double4 :: proc "c" (x: double4) -> double4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_float2 :: proc "c" (x: float2) -> float2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_float3 :: proc "c" (x: float3) -> float3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_float4 :: proc "c" (x: float4) -> float4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } +@(require_results) ceil_double2 :: proc "c" (x: double2) -> double2 { return {ceil(x.x), ceil(x.y)} } +@(require_results) ceil_double3 :: proc "c" (x: double3) -> double3 { return {ceil(x.x), ceil(x.y), ceil(x.z)} } +@(require_results) ceil_double4 :: proc "c" (x: double4) -> double4 { return {ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)} } -isfinite_float :: proc "c" (x: float) -> bool { return !isinf_float(x) } -isfinite_float2 :: proc "c" (x: float2) -> bool2 { return {isfinite_float(x.x), isfinite_float(x.y)} } -isfinite_float3 :: proc "c" (x: float3) -> bool3 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z)} } -isfinite_float4 :: proc "c" (x: float4) -> bool4 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z), isfinite_float(x.w)} } -isfinite_double :: proc "c" (x: double) -> bool { return !isinf_double(x) } -isfinite_double2 :: proc "c" (x: double2) -> bool2 { return {isfinite_double(x.x), isfinite_double(x.y)} } -isfinite_double3 :: proc "c" (x: double3) -> bool3 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z)} } -isfinite_double4 :: proc "c" (x: double4) -> bool4 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z), isfinite_double(x.w)} } +@(require_results) isfinite_float :: proc "c" (x: float) -> bool { return !isinf_float(x) } +@(require_results) isfinite_float2 :: proc "c" (x: float2) -> bool2 { return {isfinite_float(x.x), isfinite_float(x.y)} } +@(require_results) isfinite_float3 :: proc "c" (x: float3) -> bool3 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z)} } +@(require_results) isfinite_float4 :: proc "c" (x: float4) -> bool4 { return {isfinite_float(x.x), isfinite_float(x.y), isfinite_float(x.z), isfinite_float(x.w)} } +@(require_results) isfinite_double :: proc "c" (x: double) -> bool { return !isinf_double(x) } +@(require_results) isfinite_double2 :: proc "c" (x: double2) -> bool2 { return {isfinite_double(x.x), isfinite_double(x.y)} } +@(require_results) isfinite_double3 :: proc "c" (x: double3) -> bool3 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z)} } +@(require_results) isfinite_double4 :: proc "c" (x: double4) -> bool4 { return {isfinite_double(x.x), isfinite_double(x.y), isfinite_double(x.z), isfinite_double(x.w)} } // isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite isfinite :: proc{ @@ -609,14 +609,14 @@ isfinite :: proc{ } -isinf_float :: proc "c" (x: float) -> bool { return x * 0.5 == x } -isinf_float2 :: proc "c" (x: float2) -> bool2 { return {isinf_float(x.x), isinf_float(x.y)} } -isinf_float3 :: proc "c" (x: float3) -> bool3 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z)} } -isinf_float4 :: proc "c" (x: float4) -> bool4 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z), isinf_float(x.w)} } -isinf_double :: proc "c" (x: double) -> bool { return x * 0.5 == x } -isinf_double2 :: proc "c" (x: double2) -> bool2 { return {isinf_double(x.x), isinf_double(x.y)} } -isinf_double3 :: proc "c" (x: double3) -> bool3 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z)} } -isinf_double4 :: proc "c" (x: double4) -> bool4 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z), isinf_double(x.w)} } +@(require_results) isinf_float :: proc "c" (x: float) -> bool { return x * 0.5 == x } +@(require_results) isinf_float2 :: proc "c" (x: float2) -> bool2 { return {isinf_float(x.x), isinf_float(x.y)} } +@(require_results) isinf_float3 :: proc "c" (x: float3) -> bool3 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z)} } +@(require_results) isinf_float4 :: proc "c" (x: float4) -> bool4 { return {isinf_float(x.x), isinf_float(x.y), isinf_float(x.z), isinf_float(x.w)} } +@(require_results) isinf_double :: proc "c" (x: double) -> bool { return x * 0.5 == x } +@(require_results) isinf_double2 :: proc "c" (x: double2) -> bool2 { return {isinf_double(x.x), isinf_double(x.y)} } +@(require_results) isinf_double3 :: proc "c" (x: double3) -> bool3 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z)} } +@(require_results) isinf_double4 :: proc "c" (x: double4) -> bool4 { return {isinf_double(x.x), isinf_double(x.y), isinf_double(x.z), isinf_double(x.w)} } // isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite isinf :: proc{ @@ -631,12 +631,12 @@ isinf :: proc{ } -isnan_float2 :: proc "c" (x: float2) -> bool2 { return {isnan_float(x.x), isnan_float(x.y)} } -isnan_float3 :: proc "c" (x: float3) -> bool3 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z)} } -isnan_float4 :: proc "c" (x: float4) -> bool4 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z), isnan_float(x.w)} } -isnan_double2 :: proc "c" (x: double2) -> bool2 { return {isnan_double(x.x), isnan_double(x.y)} } -isnan_double3 :: proc "c" (x: double3) -> bool3 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z)} } -isnan_double4 :: proc "c" (x: double4) -> bool4 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z), isnan_double(x.w)} } +@(require_results) isnan_float2 :: proc "c" (x: float2) -> bool2 { return {isnan_float(x.x), isnan_float(x.y)} } +@(require_results) isnan_float3 :: proc "c" (x: float3) -> bool3 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z)} } +@(require_results) isnan_float4 :: proc "c" (x: float4) -> bool4 { return {isnan_float(x.x), isnan_float(x.y), isnan_float(x.z), isnan_float(x.w)} } +@(require_results) isnan_double2 :: proc "c" (x: double2) -> bool2 { return {isnan_double(x.x), isnan_double(x.y)} } +@(require_results) isnan_double3 :: proc "c" (x: double3) -> bool3 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z)} } +@(require_results) isnan_double4 :: proc "c" (x: double4) -> bool4 { return {isnan_double(x.x), isnan_double(x.y), isnan_double(x.z), isnan_double(x.w)} } // isnan returns true if the input value is the special case of Not-A-Number isnan :: proc{ @@ -660,12 +660,12 @@ fmod :: proc{ fmod_double3, fmod_double4, } -fmod_float2 :: proc "c" (x, y: float2) -> float2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } -fmod_float3 :: proc "c" (x, y: float3) -> float3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } -fmod_float4 :: proc "c" (x, y: float4) -> float4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } -fmod_double2 :: proc "c" (x, y: double2) -> double2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } -fmod_double3 :: proc "c" (x, y: double3) -> double3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } -fmod_double4 :: proc "c" (x, y: double4) -> double4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } +@(require_results) fmod_float2 :: proc "c" (x, y: float2) -> float2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } +@(require_results) fmod_float3 :: proc "c" (x, y: float3) -> float3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } +@(require_results) fmod_float4 :: proc "c" (x, y: float4) -> float4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } +@(require_results) fmod_double2 :: proc "c" (x, y: double2) -> double2 { return {fmod(x.x, y.x), fmod(x.y, y.y)} } +@(require_results) fmod_double3 :: proc "c" (x, y: double3) -> double3 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z)} } +@(require_results) fmod_double4 :: proc "c" (x, y: double4) -> double4 { return {fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)} } frac :: proc{ @@ -678,12 +678,12 @@ frac :: proc{ frac_double3, frac_double4, } -frac_float2 :: proc "c" (x: float2) -> float2 { return {frac(x.x), frac(x.y)} } -frac_float3 :: proc "c" (x: float3) -> float3 { return {frac(x.x), frac(x.y), frac(x.z)} } -frac_float4 :: proc "c" (x: float4) -> float4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } -frac_double2 :: proc "c" (x: double2) -> double2 { return {frac(x.x), frac(x.y)} } -frac_double3 :: proc "c" (x: double3) -> double3 { return {frac(x.x), frac(x.y), frac(x.z)} } -frac_double4 :: proc "c" (x: double4) -> double4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } +@(require_results) frac_float2 :: proc "c" (x: float2) -> float2 { return {frac(x.x), frac(x.y)} } +@(require_results) frac_float3 :: proc "c" (x: float3) -> float3 { return {frac(x.x), frac(x.y), frac(x.z)} } +@(require_results) frac_float4 :: proc "c" (x: float4) -> float4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } +@(require_results) frac_double2 :: proc "c" (x: double2) -> double2 { return {frac(x.x), frac(x.y)} } +@(require_results) frac_double3 :: proc "c" (x: double3) -> double3 { return {frac(x.x), frac(x.y), frac(x.z)} } +@(require_results) frac_double4 :: proc "c" (x: double4) -> double4 { return {frac(x.x), frac(x.y), frac(x.z), frac(x.w)} } @@ -697,14 +697,14 @@ radians :: proc{ radians_double3, radians_double4, } -radians_float :: proc "c" (degrees: float) -> float { return degrees * TAU / 360.0 } -radians_double :: proc "c" (degrees: double) -> double { return degrees * TAU / 360.0 } -radians_float2 :: proc "c" (degrees: float2) -> float2 { return degrees * TAU / 360.0 } -radians_float3 :: proc "c" (degrees: float3) -> float3 { return degrees * TAU / 360.0 } -radians_float4 :: proc "c" (degrees: float4) -> float4 { return degrees * TAU / 360.0 } -radians_double2 :: proc "c" (degrees: double2) -> double2 { return degrees * TAU / 360.0 } -radians_double3 :: proc "c" (degrees: double3) -> double3 { return degrees * TAU / 360.0 } -radians_double4 :: proc "c" (degrees: double4) -> double4 { return degrees * TAU / 360.0 } +@(require_results) radians_float :: proc "c" (degrees: float) -> float { return degrees * TAU / 360.0 } +@(require_results) radians_double :: proc "c" (degrees: double) -> double { return degrees * TAU / 360.0 } +@(require_results) radians_float2 :: proc "c" (degrees: float2) -> float2 { return degrees * TAU / 360.0 } +@(require_results) radians_float3 :: proc "c" (degrees: float3) -> float3 { return degrees * TAU / 360.0 } +@(require_results) radians_float4 :: proc "c" (degrees: float4) -> float4 { return degrees * TAU / 360.0 } +@(require_results) radians_double2 :: proc "c" (degrees: double2) -> double2 { return degrees * TAU / 360.0 } +@(require_results) radians_double3 :: proc "c" (degrees: double3) -> double3 { return degrees * TAU / 360.0 } +@(require_results) radians_double4 :: proc "c" (degrees: double4) -> double4 { return degrees * TAU / 360.0 } degrees :: proc{ @@ -717,14 +717,14 @@ degrees :: proc{ degrees_double3, degrees_double4, } -degrees_float :: proc "c" (radians: float) -> float { return radians * 360.0 / TAU } -degrees_double :: proc "c" (radians: double) -> double { return radians * 360.0 / TAU } -degrees_float2 :: proc "c" (radians: float2) -> float2 { return radians * 360.0 / TAU } -degrees_float3 :: proc "c" (radians: float3) -> float3 { return radians * 360.0 / TAU } -degrees_float4 :: proc "c" (radians: float4) -> float4 { return radians * 360.0 / TAU } -degrees_double2 :: proc "c" (radians: double2) -> double2 { return radians * 360.0 / TAU } -degrees_double3 :: proc "c" (radians: double3) -> double3 { return radians * 360.0 / TAU } -degrees_double4 :: proc "c" (radians: double4) -> double4 { return radians * 360.0 / TAU } +@(require_results) degrees_float :: proc "c" (radians: float) -> float { return radians * 360.0 / TAU } +@(require_results) degrees_double :: proc "c" (radians: double) -> double { return radians * 360.0 / TAU } +@(require_results) degrees_float2 :: proc "c" (radians: float2) -> float2 { return radians * 360.0 / TAU } +@(require_results) degrees_float3 :: proc "c" (radians: float3) -> float3 { return radians * 360.0 / TAU } +@(require_results) degrees_float4 :: proc "c" (radians: float4) -> float4 { return radians * 360.0 / TAU } +@(require_results) degrees_double2 :: proc "c" (radians: double2) -> double2 { return radians * 360.0 / TAU } +@(require_results) degrees_double3 :: proc "c" (radians: double3) -> double3 { return radians * 360.0 / TAU } +@(require_results) degrees_double4 :: proc "c" (radians: double4) -> double4 { return radians * 360.0 / TAU } min :: proc{ min_int, @@ -744,22 +744,22 @@ min :: proc{ min_uint3, min_uint4, } -min_int :: proc "c" (x, y: int) -> int { return builtin.min(x, y) } -min_uint :: proc "c" (x, y: uint) -> uint { return builtin.min(x, y) } -min_float :: proc "c" (x, y: float) -> float { return builtin.min(x, y) } -min_double :: proc "c" (x, y: double) -> double { return builtin.min(x, y) } -min_float2 :: proc "c" (x, y: float2) -> float2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_float3 :: proc "c" (x, y: float3) -> float3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_float4 :: proc "c" (x, y: float4) -> float4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_double2 :: proc "c" (x, y: double2) -> double2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_double3 :: proc "c" (x, y: double3) -> double3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_double4 :: proc "c" (x, y: double4) -> double4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_int2 :: proc "c" (x, y: int2) -> int2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_int3 :: proc "c" (x, y: int3) -> int3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_int4 :: proc "c" (x, y: int4) -> int4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } -min_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {min(x.x, y.x), min(x.y, y.y)} } -min_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } -min_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_int :: proc "c" (x, y: int) -> int { return builtin.min(x, y) } +@(require_results) min_uint :: proc "c" (x, y: uint) -> uint { return builtin.min(x, y) } +@(require_results) min_float :: proc "c" (x, y: float) -> float { return builtin.min(x, y) } +@(require_results) min_double :: proc "c" (x, y: double) -> double { return builtin.min(x, y) } +@(require_results) min_float2 :: proc "c" (x, y: float2) -> float2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_float3 :: proc "c" (x, y: float3) -> float3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_float4 :: proc "c" (x, y: float4) -> float4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_double2 :: proc "c" (x, y: double2) -> double2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_double3 :: proc "c" (x, y: double3) -> double3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_double4 :: proc "c" (x, y: double4) -> double4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_int2 :: proc "c" (x, y: int2) -> int2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_int3 :: proc "c" (x, y: int3) -> int3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_int4 :: proc "c" (x, y: int4) -> int4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } +@(require_results) min_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {min(x.x, y.x), min(x.y, y.y)} } +@(require_results) min_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)} } +@(require_results) min_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)} } max :: proc{ @@ -780,22 +780,22 @@ max :: proc{ max_uint3, max_uint4, } -max_int :: proc "c" (x, y: int) -> int { return builtin.max(x, y) } -max_uint :: proc "c" (x, y: uint) -> uint { return builtin.max(x, y) } -max_float :: proc "c" (x, y: float) -> float { return builtin.max(x, y) } -max_double :: proc "c" (x, y: double) -> double { return builtin.max(x, y) } -max_float2 :: proc "c" (x, y: float2) -> float2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_float3 :: proc "c" (x, y: float3) -> float3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_float4 :: proc "c" (x, y: float4) -> float4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_double2 :: proc "c" (x, y: double2) -> double2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_double3 :: proc "c" (x, y: double3) -> double3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_double4 :: proc "c" (x, y: double4) -> double4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_int2 :: proc "c" (x, y: int2) -> int2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_int3 :: proc "c" (x, y: int3) -> int3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_int4 :: proc "c" (x, y: int4) -> int4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } -max_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {max(x.x, y.x), max(x.y, y.y)} } -max_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } -max_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_int :: proc "c" (x, y: int) -> int { return builtin.max(x, y) } +@(require_results) max_uint :: proc "c" (x, y: uint) -> uint { return builtin.max(x, y) } +@(require_results) max_float :: proc "c" (x, y: float) -> float { return builtin.max(x, y) } +@(require_results) max_double :: proc "c" (x, y: double) -> double { return builtin.max(x, y) } +@(require_results) max_float2 :: proc "c" (x, y: float2) -> float2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_float3 :: proc "c" (x, y: float3) -> float3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_float4 :: proc "c" (x, y: float4) -> float4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_double2 :: proc "c" (x, y: double2) -> double2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_double3 :: proc "c" (x, y: double3) -> double3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_double4 :: proc "c" (x, y: double4) -> double4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_int2 :: proc "c" (x, y: int2) -> int2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_int3 :: proc "c" (x, y: int3) -> int3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_int4 :: proc "c" (x, y: int4) -> int4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } +@(require_results) max_uint2 :: proc "c" (x, y: uint2) -> uint2 { return {max(x.x, y.x), max(x.y, y.y)} } +@(require_results) max_uint3 :: proc "c" (x, y: uint3) -> uint3 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)} } +@(require_results) max_uint4 :: proc "c" (x, y: uint4) -> uint4 { return {max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)} } @@ -817,22 +817,22 @@ clamp :: proc{ clamp_uint3, clamp_uint4, } -clamp_int :: proc "c" (x, y, z: int) -> int { return builtin.clamp(x, y, z) } -clamp_uint :: proc "c" (x, y, z: uint) -> uint { return builtin.clamp(x, y, z) } -clamp_float :: proc "c" (x, y, z: float) -> float { return builtin.clamp(x, y, z) } -clamp_double :: proc "c" (x, y, z: double) -> double { return builtin.clamp(x, y, z) } -clamp_float2 :: proc "c" (x, y, z: float2) -> float2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_float3 :: proc "c" (x, y, z: float3) -> float3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_float4 :: proc "c" (x, y, z: float4) -> float4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_double2 :: proc "c" (x, y, z: double2) -> double2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_double3 :: proc "c" (x, y, z: double3) -> double3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_double4 :: proc "c" (x, y, z: double4) -> double4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_int2 :: proc "c" (x, y, z: int2) -> int2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_int3 :: proc "c" (x, y, z: int3) -> int3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_int4 :: proc "c" (x, y, z: int4) -> int4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } -clamp_uint2 :: proc "c" (x, y, z: uint2) -> uint2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } -clamp_uint3 :: proc "c" (x, y, z: uint3) -> uint3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } -clamp_uint4 :: proc "c" (x, y, z: uint4) -> uint4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_int :: proc "c" (x, y, z: int) -> int { return builtin.clamp(x, y, z) } +@(require_results) clamp_uint :: proc "c" (x, y, z: uint) -> uint { return builtin.clamp(x, y, z) } +@(require_results) clamp_float :: proc "c" (x, y, z: float) -> float { return builtin.clamp(x, y, z) } +@(require_results) clamp_double :: proc "c" (x, y, z: double) -> double { return builtin.clamp(x, y, z) } +@(require_results) clamp_float2 :: proc "c" (x, y, z: float2) -> float2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_float3 :: proc "c" (x, y, z: float3) -> float3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_float4 :: proc "c" (x, y, z: float4) -> float4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_double2 :: proc "c" (x, y, z: double2) -> double2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_double3 :: proc "c" (x, y, z: double3) -> double3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_double4 :: proc "c" (x, y, z: double4) -> double4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_int2 :: proc "c" (x, y, z: int2) -> int2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_int3 :: proc "c" (x, y, z: int3) -> int3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_int4 :: proc "c" (x, y, z: int4) -> int4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } +@(require_results) clamp_uint2 :: proc "c" (x, y, z: uint2) -> uint2 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y)} } +@(require_results) clamp_uint3 :: proc "c" (x, y, z: uint3) -> uint3 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z)} } +@(require_results) clamp_uint4 :: proc "c" (x, y, z: uint4) -> uint4 { return {clamp(x.x, y.x, z.x), clamp(x.y, y.y, z.y), clamp(x.z, y.z, z.z), clamp(x.w, y.w, z.w)} } saturate :: proc{ saturate_int, @@ -852,22 +852,22 @@ saturate :: proc{ saturate_uint3, saturate_uint4, } -saturate_int :: proc "c" (v: int) -> int { return builtin.clamp(v, 0, 1) } -saturate_uint :: proc "c" (v: uint) -> uint { return builtin.clamp(v, 0, 1) } -saturate_float :: proc "c" (v: float) -> float { return builtin.clamp(v, 0, 1) } -saturate_double :: proc "c" (v: double) -> double { return builtin.clamp(v, 0, 1) } -saturate_float2 :: proc "c" (v: float2) -> float2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_float3 :: proc "c" (v: float3) -> float3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_float4 :: proc "c" (v: float4) -> float4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_double2 :: proc "c" (v: double2) -> double2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_double3 :: proc "c" (v: double3) -> double3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_double4 :: proc "c" (v: double4) -> double4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_int2 :: proc "c" (v: int2) -> int2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_int3 :: proc "c" (v: int3) -> int3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_int4 :: proc "c" (v: int4) -> int4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } -saturate_uint2 :: proc "c" (v: uint2) -> uint2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } -saturate_uint3 :: proc "c" (v: uint3) -> uint3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } -saturate_uint4 :: proc "c" (v: uint4) -> uint4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_int :: proc "c" (v: int) -> int { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_uint :: proc "c" (v: uint) -> uint { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_float :: proc "c" (v: float) -> float { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_double :: proc "c" (v: double) -> double { return builtin.clamp(v, 0, 1) } +@(require_results) saturate_float2 :: proc "c" (v: float2) -> float2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_float3 :: proc "c" (v: float3) -> float3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_float4 :: proc "c" (v: float4) -> float4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_double2 :: proc "c" (v: double2) -> double2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_double3 :: proc "c" (v: double3) -> double3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_double4 :: proc "c" (v: double4) -> double4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_int2 :: proc "c" (v: int2) -> int2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_int3 :: proc "c" (v: int3) -> int3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_int4 :: proc "c" (v: int4) -> int4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } +@(require_results) saturate_uint2 :: proc "c" (v: uint2) -> uint2 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1)} } +@(require_results) saturate_uint3 :: proc "c" (v: uint3) -> uint3 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1)} } +@(require_results) saturate_uint4 :: proc "c" (v: uint4) -> uint4 { return {builtin.clamp(v.x, 0, 1), builtin.clamp(v.y, 0, 1), builtin.clamp(v.z, 0, 1), builtin.clamp(v.w, 0, 1)} } lerp :: proc{ @@ -880,14 +880,14 @@ lerp :: proc{ lerp_double3, lerp_double4, } -lerp_float :: proc "c" (x, y, t: float) -> float { return x*(1-t) + y*t } -lerp_double :: proc "c" (x, y, t: double) -> double { return x*(1-t) + y*t } -lerp_float2 :: proc "c" (x, y, t: float2) -> float2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_float3 :: proc "c" (x, y, t: float3) -> float3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_float4 :: proc "c" (x, y, t: float4) -> float4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } -lerp_double2 :: proc "c" (x, y, t: double2) -> double2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } -lerp_double3 :: proc "c" (x, y, t: double3) -> double3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } -lerp_double4 :: proc "c" (x, y, t: double4) -> double4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_float :: proc "c" (x, y, t: float) -> float { return x*(1-t) + y*t } +@(require_results) lerp_double :: proc "c" (x, y, t: double) -> double { return x*(1-t) + y*t } +@(require_results) lerp_float2 :: proc "c" (x, y, t: float2) -> float2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_float3 :: proc "c" (x, y, t: float3) -> float3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } +@(require_results) lerp_float4 :: proc "c" (x, y, t: float4) -> float4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } +@(require_results) lerp_double2 :: proc "c" (x, y, t: double2) -> double2 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y)} } +@(require_results) lerp_double3 :: proc "c" (x, y, t: double3) -> double3 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, t.y), lerp(x.z, y.z, t.z)} } +@(require_results) lerp_double4 :: proc "c" (x, y, t: double4) -> double4 { return {lerp(x.x, y.x, t.x), lerp(x.y, y.y, y.y), lerp(x.z, y.z, t.z), lerp(x.w, y.w, t.w)} } step :: proc{ @@ -900,14 +900,14 @@ step :: proc{ step_double3, step_double4, } -step_float :: proc "c" (edge, x: float) -> float { return 0 if x < edge else 1 } -step_double :: proc "c" (edge, x: double) -> double { return 0 if x < edge else 1 } -step_float2 :: proc "c" (edge, x: float2) -> float2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_float3 :: proc "c" (edge, x: float3) -> float3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_float4 :: proc "c" (edge, x: float4) -> float4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } -step_double2 :: proc "c" (edge, x: double2) -> double2 { return {step(edge.x, x.x), step(edge.y, x.y)} } -step_double3 :: proc "c" (edge, x: double3) -> double3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } -step_double4 :: proc "c" (edge, x: double4) -> double4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_float :: proc "c" (edge, x: float) -> float { return 0 if x < edge else 1 } +@(require_results) step_double :: proc "c" (edge, x: double) -> double { return 0 if x < edge else 1 } +@(require_results) step_float2 :: proc "c" (edge, x: float2) -> float2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_float3 :: proc "c" (edge, x: float3) -> float3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_float4 :: proc "c" (edge, x: float4) -> float4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } +@(require_results) step_double2 :: proc "c" (edge, x: double2) -> double2 { return {step(edge.x, x.x), step(edge.y, x.y)} } +@(require_results) step_double3 :: proc "c" (edge, x: double3) -> double3 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z)} } +@(require_results) step_double4 :: proc "c" (edge, x: double4) -> double4 { return {step(edge.x, x.x), step(edge.y, x.y), step(edge.z, x.z), step(edge.w, x.w)} } smoothstep :: proc{ smoothstep_float, @@ -919,20 +919,20 @@ smoothstep :: proc{ smoothstep_double3, smoothstep_double4, } -smoothstep_float :: proc "c" (edge0, edge1, x: float) -> float { +@(require_results) smoothstep_float :: proc "c" (edge0, edge1, x: float) -> float { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_double :: proc "c" (edge0, edge1, x: double) -> double { +@(require_results) smoothstep_double :: proc "c" (edge0, edge1, x: double) -> double { y := clamp(((x-edge0) / (edge1 - edge0)), 0, 1) return y * y * (3 - 2*y) } -smoothstep_float2 :: proc "c" (edge0, edge1, x: float2) -> float2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_float3 :: proc "c" (edge0, edge1, x: float3) -> float3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_float4 :: proc "c" (edge0, edge1, x: float4) -> float4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } -smoothstep_double2 :: proc "c" (edge0, edge1, x: double2) -> double2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } -smoothstep_double3 :: proc "c" (edge0, edge1, x: double3) -> double3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } -smoothstep_double4 :: proc "c" (edge0, edge1, x: double4) -> double4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } +@(require_results) smoothstep_float2 :: proc "c" (edge0, edge1, x: float2) -> float2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_float3 :: proc "c" (edge0, edge1, x: float3) -> float3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } +@(require_results) smoothstep_float4 :: proc "c" (edge0, edge1, x: float4) -> float4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } +@(require_results) smoothstep_double2 :: proc "c" (edge0, edge1, x: double2) -> double2 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y)} } +@(require_results) smoothstep_double3 :: proc "c" (edge0, edge1, x: double3) -> double3 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z)} } +@(require_results) smoothstep_double4 :: proc "c" (edge0, edge1, x: double4) -> double4 { return {smoothstep(edge0.x, edge1.x, x.x), smoothstep(edge0.y, edge1.y, x.y), smoothstep(edge0.z, edge1.z, x.z), smoothstep(edge0.w, edge1.w, x.w)} } abs :: proc{ @@ -953,22 +953,22 @@ abs :: proc{ abs_uint3, abs_uint4, } -abs_int :: proc "c" (x: int) -> int { return builtin.abs(x) } -abs_uint :: proc "c" (x: uint) -> uint { return x } -abs_float :: proc "c" (x: float) -> float { return builtin.abs(x) } -abs_double :: proc "c" (x: double) -> double { return builtin.abs(x) } -abs_float2 :: proc "c" (x: float2) -> float2 { return {abs(x.x), abs(x.y)} } -abs_float3 :: proc "c" (x: float3) -> float3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_float4 :: proc "c" (x: float4) -> float4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_double2 :: proc "c" (x: double2) -> double2 { return {abs(x.x), abs(x.y)} } -abs_double3 :: proc "c" (x: double3) -> double3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_double4 :: proc "c" (x: double4) -> double4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_int2 :: proc "c" (x: int2) -> int2 { return {abs(x.x), abs(x.y)} } -abs_int3 :: proc "c" (x: int3) -> int3 { return {abs(x.x), abs(x.y), abs(x.z)} } -abs_int4 :: proc "c" (x: int4) -> int4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } -abs_uint2 :: proc "c" (x: uint2) -> uint2 { return x } -abs_uint3 :: proc "c" (x: uint3) -> uint3 { return x } -abs_uint4 :: proc "c" (x: uint4) -> uint4 { return x } +@(require_results) abs_int :: proc "c" (x: int) -> int { return builtin.abs(x) } +@(require_results) abs_uint :: proc "c" (x: uint) -> uint { return x } +@(require_results) abs_float :: proc "c" (x: float) -> float { return builtin.abs(x) } +@(require_results) abs_double :: proc "c" (x: double) -> double { return builtin.abs(x) } +@(require_results) abs_float2 :: proc "c" (x: float2) -> float2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_float3 :: proc "c" (x: float3) -> float3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_float4 :: proc "c" (x: float4) -> float4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_double2 :: proc "c" (x: double2) -> double2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_double3 :: proc "c" (x: double3) -> double3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_double4 :: proc "c" (x: double4) -> double4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_int2 :: proc "c" (x: int2) -> int2 { return {abs(x.x), abs(x.y)} } +@(require_results) abs_int3 :: proc "c" (x: int3) -> int3 { return {abs(x.x), abs(x.y), abs(x.z)} } +@(require_results) abs_int4 :: proc "c" (x: int4) -> int4 { return {abs(x.x), abs(x.y), abs(x.z), abs(x.w)} } +@(require_results) abs_uint2 :: proc "c" (x: uint2) -> uint2 { return x } +@(require_results) abs_uint3 :: proc "c" (x: uint3) -> uint3 { return x } +@(require_results) abs_uint4 :: proc "c" (x: uint4) -> uint4 { return x } dot :: proc{ dot_int, @@ -988,22 +988,22 @@ dot :: proc{ dot_uint3, dot_uint4, } -dot_int :: proc "c" (a, b: int) -> int { return a*b } -dot_uint :: proc "c" (a, b: uint) -> uint { return a*b } -dot_float :: proc "c" (a, b: float) -> float { return a*b } -dot_double :: proc "c" (a, b: double) -> double { return a*b } -dot_float2 :: proc "c" (a, b: float2) -> float { return a.x*b.x + a.y*b.y } -dot_float3 :: proc "c" (a, b: float3) -> float { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_float4 :: proc "c" (a, b: float4) -> float { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_double2 :: proc "c" (a, b: double2) -> double { return a.x*b.x + a.y*b.y } -dot_double3 :: proc "c" (a, b: double3) -> double { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_double4 :: proc "c" (a, b: double4) -> double { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_int2 :: proc "c" (a, b: int2) -> int { return a.x*b.x + a.y*b.y } -dot_int3 :: proc "c" (a, b: int3) -> int { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_int4 :: proc "c" (a, b: int4) -> int { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } -dot_uint2 :: proc "c" (a, b: uint2) -> uint { return a.x*b.x + a.y*b.y } -dot_uint3 :: proc "c" (a, b: uint3) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z } -dot_uint4 :: proc "c" (a, b: uint4) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_int :: proc "c" (a, b: int) -> int { return a*b } +@(require_results) dot_uint :: proc "c" (a, b: uint) -> uint { return a*b } +@(require_results) dot_float :: proc "c" (a, b: float) -> float { return a*b } +@(require_results) dot_double :: proc "c" (a, b: double) -> double { return a*b } +@(require_results) dot_float2 :: proc "c" (a, b: float2) -> float { return a.x*b.x + a.y*b.y } +@(require_results) dot_float3 :: proc "c" (a, b: float3) -> float { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_float4 :: proc "c" (a, b: float4) -> float { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_double2 :: proc "c" (a, b: double2) -> double { return a.x*b.x + a.y*b.y } +@(require_results) dot_double3 :: proc "c" (a, b: double3) -> double { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_double4 :: proc "c" (a, b: double4) -> double { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_int2 :: proc "c" (a, b: int2) -> int { return a.x*b.x + a.y*b.y } +@(require_results) dot_int3 :: proc "c" (a, b: int3) -> int { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_int4 :: proc "c" (a, b: int4) -> int { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } +@(require_results) dot_uint2 :: proc "c" (a, b: uint2) -> uint { return a.x*b.x + a.y*b.y } +@(require_results) dot_uint3 :: proc "c" (a, b: uint3) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) dot_uint4 :: proc "c" (a, b: uint4) -> uint { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w } length :: proc{ length_float, @@ -1015,14 +1015,14 @@ length :: proc{ length_double3, length_double4, } -length_float :: proc "c" (x: float) -> float { return builtin.abs(x) } -length_double :: proc "c" (x: double) -> double { return builtin.abs(x) } -length_float2 :: proc "c" (x: float2) -> float { return sqrt(x.x*x.x + x.y*x.y) } -length_float3 :: proc "c" (x: float3) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_float4 :: proc "c" (x: float4) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } -length_double2 :: proc "c" (x: double2) -> double { return sqrt(x.x*x.x + x.y*x.y) } -length_double3 :: proc "c" (x: double3) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } -length_double4 :: proc "c" (x: double4) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_float :: proc "c" (x: float) -> float { return builtin.abs(x) } +@(require_results) length_double :: proc "c" (x: double) -> double { return builtin.abs(x) } +@(require_results) length_float2 :: proc "c" (x: float2) -> float { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_float3 :: proc "c" (x: float3) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_float4 :: proc "c" (x: float4) -> float { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } +@(require_results) length_double2 :: proc "c" (x: double2) -> double { return sqrt(x.x*x.x + x.y*x.y) } +@(require_results) length_double3 :: proc "c" (x: double3) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z) } +@(require_results) length_double4 :: proc "c" (x: double4) -> double { return sqrt(x.x*x.x + x.y*x.y + x.z*x.z + x.w*x.w) } distance :: proc{ @@ -1035,14 +1035,14 @@ distance :: proc{ distance_double3, distance_double4, } -distance_float :: proc "c" (x, y: float) -> float { return length(y-x) } -distance_double :: proc "c" (x, y: double) -> double { return length(y-x) } -distance_float2 :: proc "c" (x, y: float2) -> float { return length(y-x) } -distance_float3 :: proc "c" (x, y: float3) -> float { return length(y-x) } -distance_float4 :: proc "c" (x, y: float4) -> float { return length(y-x) } -distance_double2 :: proc "c" (x, y: double2) -> double { return length(y-x) } -distance_double3 :: proc "c" (x, y: double3) -> double { return length(y-x) } -distance_double4 :: proc "c" (x, y: double4) -> double { return length(y-x) } +@(require_results) distance_float :: proc "c" (x, y: float) -> float { return length(y-x) } +@(require_results) distance_double :: proc "c" (x, y: double) -> double { return length(y-x) } +@(require_results) distance_float2 :: proc "c" (x, y: float2) -> float { return length(y-x) } +@(require_results) distance_float3 :: proc "c" (x, y: float3) -> float { return length(y-x) } +@(require_results) distance_float4 :: proc "c" (x, y: float4) -> float { return length(y-x) } +@(require_results) distance_double2 :: proc "c" (x, y: double2) -> double { return length(y-x) } +@(require_results) distance_double3 :: proc "c" (x, y: double3) -> double { return length(y-x) } +@(require_results) distance_double4 :: proc "c" (x, y: double4) -> double { return length(y-x) } cross :: proc{ @@ -1051,19 +1051,19 @@ cross :: proc{ cross_int3, } -cross_float3 :: proc "c" (a, b: float3) -> (c: float3) { +@(require_results) cross_float3 :: proc "c" (a, b: float3) -> (c: float3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y return } -cross_double3 :: proc "c" (a, b: double3) -> (c: double3) { +@(require_results) cross_double3 :: proc "c" (a, b: double3) -> (c: double3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y return } -cross_int3 :: proc "c" (a, b: int3) -> (c: int3) { +@(require_results) cross_int3 :: proc "c" (a, b: int3) -> (c: int3) { c.x = a.y*b.z - b.y*a.z c.y = a.z*b.x - b.z*a.x c.z = a.x*b.y - b.x*a.y @@ -1080,14 +1080,14 @@ normalize :: proc{ normalize_double3, normalize_double4, } -normalize_float :: proc "c" (x: float) -> float { return 1.0 } -normalize_double :: proc "c" (x: double) -> double { return 1.0 } -normalize_float2 :: proc "c" (x: float2) -> float2 { return x / length(x) } -normalize_float3 :: proc "c" (x: float3) -> float3 { return x / length(x) } -normalize_float4 :: proc "c" (x: float4) -> float4 { return x / length(x) } -normalize_double2 :: proc "c" (x: double2) -> double2 { return x / length(x) } -normalize_double3 :: proc "c" (x: double3) -> double3 { return x / length(x) } -normalize_double4 :: proc "c" (x: double4) -> double4 { return x / length(x) } +@(require_results) normalize_float :: proc "c" (x: float) -> float { return 1.0 } +@(require_results) normalize_double :: proc "c" (x: double) -> double { return 1.0 } +@(require_results) normalize_float2 :: proc "c" (x: float2) -> float2 { return x / length(x) } +@(require_results) normalize_float3 :: proc "c" (x: float3) -> float3 { return x / length(x) } +@(require_results) normalize_float4 :: proc "c" (x: float4) -> float4 { return x / length(x) } +@(require_results) normalize_double2 :: proc "c" (x: double2) -> double2 { return x / length(x) } +@(require_results) normalize_double3 :: proc "c" (x: double3) -> double3 { return x / length(x) } +@(require_results) normalize_double4 :: proc "c" (x: double4) -> double4 { return x / length(x) } faceforward :: proc{ @@ -1100,14 +1100,14 @@ faceforward :: proc{ faceforward_double3, faceforward_double4, } -faceforward_float :: proc "c" (N, I, Nref: float) -> float { return N if dot(I, Nref) < 0 else -N } -faceforward_double :: proc "c" (N, I, Nref: double) -> double { return N if dot(I, Nref) < 0 else -N } -faceforward_float2 :: proc "c" (N, I, Nref: float2) -> float2 { return N if dot(I, Nref) < 0 else -N } -faceforward_float3 :: proc "c" (N, I, Nref: float3) -> float3 { return N if dot(I, Nref) < 0 else -N } -faceforward_float4 :: proc "c" (N, I, Nref: float4) -> float4 { return N if dot(I, Nref) < 0 else -N } -faceforward_double2 :: proc "c" (N, I, Nref: double2) -> double2 { return N if dot(I, Nref) < 0 else -N } -faceforward_double3 :: proc "c" (N, I, Nref: double3) -> double3 { return N if dot(I, Nref) < 0 else -N } -faceforward_double4 :: proc "c" (N, I, Nref: double4) -> double4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_float :: proc "c" (N, I, Nref: float) -> float { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double :: proc "c" (N, I, Nref: double) -> double { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_float2 :: proc "c" (N, I, Nref: float2) -> float2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_float3 :: proc "c" (N, I, Nref: float3) -> float3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_float4 :: proc "c" (N, I, Nref: float4) -> float4 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double2 :: proc "c" (N, I, Nref: double2) -> double2 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double3 :: proc "c" (N, I, Nref: double3) -> double3 { return N if dot(I, Nref) < 0 else -N } +@(require_results) faceforward_double4 :: proc "c" (N, I, Nref: double4) -> double4 { return N if dot(I, Nref) < 0 else -N } reflect :: proc{ @@ -1120,14 +1120,14 @@ reflect :: proc{ reflect_double3, reflect_double4, } -reflect_float :: proc "c" (I, N: float) -> float { return I - 2*N*dot(N, I) } -reflect_double :: proc "c" (I, N: double) -> double { return I - 2*N*dot(N, I) } -reflect_float2 :: proc "c" (I, N: float2) -> float2 { return I - 2*N*dot(N, I) } -reflect_float3 :: proc "c" (I, N: float3) -> float3 { return I - 2*N*dot(N, I) } -reflect_float4 :: proc "c" (I, N: float4) -> float4 { return I - 2*N*dot(N, I) } -reflect_double2 :: proc "c" (I, N: double2) -> double2 { return I - 2*N*dot(N, I) } -reflect_double3 :: proc "c" (I, N: double3) -> double3 { return I - 2*N*dot(N, I) } -reflect_double4 :: proc "c" (I, N: double4) -> double4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_float :: proc "c" (I, N: float) -> float { return I - 2*N*dot(N, I) } +@(require_results) reflect_double :: proc "c" (I, N: double) -> double { return I - 2*N*dot(N, I) } +@(require_results) reflect_float2 :: proc "c" (I, N: float2) -> float2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_float3 :: proc "c" (I, N: float3) -> float3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_float4 :: proc "c" (I, N: float4) -> float4 { return I - 2*N*dot(N, I) } +@(require_results) reflect_double2 :: proc "c" (I, N: double2) -> double2 { return I - 2*N*dot(N, I) } +@(require_results) reflect_double3 :: proc "c" (I, N: double3) -> double3 { return I - 2*N*dot(N, I) } +@(require_results) reflect_double4 :: proc "c" (I, N: double4) -> double4 { return I - 2*N*dot(N, I) } @@ -1142,49 +1142,57 @@ refract :: proc{ refract_double3, refract_double4, } -refract_float :: proc "c" (i, n, eta: float) -> float { +@(require_results) +refract_float :: proc "c" (i, n, eta: float) -> float { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float(int(cost2 > 0)) } -refract_double :: proc "c" (i, n, eta: double) -> double { +@(require_results) +refract_double :: proc "c" (i, n, eta: double) -> double { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double(int(cost2 > 0)) } -refract_float2 :: proc "c" (i, n, eta: float2) -> float2 { +@(require_results) +refract_float2 :: proc "c" (i, n, eta: float2) -> float2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float2{float(int(cost2.x > 0)), float(int(cost2.y > 0))} } -refract_float3 :: proc "c" (i, n, eta: float3) -> float3 { +@(require_results) +refract_float3 :: proc "c" (i, n, eta: float3) -> float3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float3{float(int(cost2.x > 0)), float(int(cost2.y > 0)), float(int(cost2.z > 0))} } -refract_float4 :: proc "c" (i, n, eta: float4) -> float4 { +@(require_results) +refract_float4 :: proc "c" (i, n, eta: float4) -> float4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * float4{float(int(cost2.x > 0)), float(int(cost2.y > 0)), float(int(cost2.z > 0)), float(int(cost2.w > 0))} } -refract_double2 :: proc "c" (i, n, eta: double2) -> double2 { +@(require_results) +refract_double2 :: proc "c" (i, n, eta: double2) -> double2 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double2{double(int(cost2.x > 0)), double(int(cost2.y > 0))} } -refract_double3 :: proc "c" (i, n, eta: double3) -> double3 { +@(require_results) +refract_double3 :: proc "c" (i, n, eta: double3) -> double3 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) return t * double3{double(int(cost2.x > 0)), double(int(cost2.y > 0)), double(int(cost2.z > 0))} } -refract_double4 :: proc "c" (i, n, eta: double4) -> double4 { +@(require_results) +refract_double4 :: proc "c" (i, n, eta: double4) -> double4 { cosi := dot(-i, n) cost2 := 1 - eta*eta*(1 - cosi*cosi) t := eta*i + ((eta*cosi - sqrt(abs(cost2))) * n) @@ -1196,18 +1204,18 @@ scalarTripleProduct :: proc{ scalarTripleProduct_double3, scalarTripleProduct_int3, } -scalarTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float { return dot(a, cross(b, c)) } -scalarTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double { return dot(a, cross(b, c)) } -scalarTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double { return dot(a, cross(b, c)) } +@(require_results) scalarTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int { return dot(a, cross(b, c)) } vectorTripleProduct :: proc { vectorTripleProduct_float3, vectorTripleProduct_double3, vectorTripleProduct_int3, } -vectorTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float3 { return cross(a, cross(b, c)) } -vectorTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double3 { return cross(a, cross(b, c)) } -vectorTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_float3 :: proc "c" (a, b, c: float3) -> float3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_double3 :: proc "c" (a, b, c: double3) -> double3 { return cross(a, cross(b, c)) } +@(require_results) vectorTripleProduct_int3 :: proc "c" (a, b, c: int3) -> int3 { return cross(a, cross(b, c)) } // Vector Relational Procedures @@ -1230,22 +1238,22 @@ lessThan :: proc{ lessThan_int4, lessThan_uint4, } -lessThan_float :: proc "c" (a, b: float) -> bool { return a < b } -lessThan_double :: proc "c" (a, b: double) -> bool { return a < b } -lessThan_int :: proc "c" (a, b: int) -> bool { return a < b } -lessThan_uint :: proc "c" (a, b: uint) -> bool { return a < b } -lessThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x < b.x, a.y < b.y} } -lessThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } -lessThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } -lessThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_float :: proc "c" (a, b: float) -> bool { return a < b } +@(require_results) lessThan_double :: proc "c" (a, b: double) -> bool { return a < b } +@(require_results) lessThan_int :: proc "c" (a, b: int) -> bool { return a < b } +@(require_results) lessThan_uint :: proc "c" (a, b: uint) -> bool { return a < b } +@(require_results) lessThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x < b.x, a.y < b.y} } +@(require_results) lessThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x < b.x, a.y < b.y, a.z < b.z} } +@(require_results) lessThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } +@(require_results) lessThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w} } lessThanEqual :: proc{ @@ -1266,22 +1274,22 @@ lessThanEqual :: proc{ lessThanEqual_int4, lessThanEqual_uint4, } -lessThanEqual_float :: proc "c" (a, b: float) -> bool { return a <= b } -lessThanEqual_double :: proc "c" (a, b: double) -> bool { return a <= b } -lessThanEqual_int :: proc "c" (a, b: int) -> bool { return a <= b } -lessThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a <= b } -lessThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } -lessThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } -lessThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } -lessThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_float :: proc "c" (a, b: float) -> bool { return a <= b } +@(require_results) lessThanEqual_double :: proc "c" (a, b: double) -> bool { return a <= b } +@(require_results) lessThanEqual_int :: proc "c" (a, b: int) -> bool { return a <= b } +@(require_results) lessThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a <= b } +@(require_results) lessThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x <= b.x, a.y <= b.y} } +@(require_results) lessThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z} } +@(require_results) lessThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } +@(require_results) lessThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w} } greaterThan :: proc{ @@ -1302,22 +1310,22 @@ greaterThan :: proc{ greaterThan_int4, greaterThan_uint4, } -greaterThan_float :: proc "c" (a, b: float) -> bool { return a > b } -greaterThan_double :: proc "c" (a, b: double) -> bool { return a > b } -greaterThan_int :: proc "c" (a, b: int) -> bool { return a > b } -greaterThan_uint :: proc "c" (a, b: uint) -> bool { return a > b } -greaterThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x > b.x, a.y > b.y} } -greaterThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } -greaterThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } -greaterThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_float :: proc "c" (a, b: float) -> bool { return a > b } +@(require_results) greaterThan_double :: proc "c" (a, b: double) -> bool { return a > b } +@(require_results) greaterThan_int :: proc "c" (a, b: int) -> bool { return a > b } +@(require_results) greaterThan_uint :: proc "c" (a, b: uint) -> bool { return a > b } +@(require_results) greaterThan_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x > b.x, a.y > b.y} } +@(require_results) greaterThan_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x > b.x, a.y > b.y, a.z > b.z} } +@(require_results) greaterThan_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } +@(require_results) greaterThan_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x > b.x, a.y > b.y, a.z > b.z, a.w > b.w} } greaterThanEqual :: proc{ @@ -1338,22 +1346,22 @@ greaterThanEqual :: proc{ greaterThanEqual_int4, greaterThanEqual_uint4, } -greaterThanEqual_float :: proc "c" (a, b: float) -> bool { return a >= b } -greaterThanEqual_double :: proc "c" (a, b: double) -> bool { return a >= b } -greaterThanEqual_int :: proc "c" (a, b: int) -> bool { return a >= b } -greaterThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a >= b } -greaterThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } -greaterThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } -greaterThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } -greaterThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_float :: proc "c" (a, b: float) -> bool { return a >= b } +@(require_results) greaterThanEqual_double :: proc "c" (a, b: double) -> bool { return a >= b } +@(require_results) greaterThanEqual_int :: proc "c" (a, b: int) -> bool { return a >= b } +@(require_results) greaterThanEqual_uint :: proc "c" (a, b: uint) -> bool { return a >= b } +@(require_results) greaterThanEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x >= b.x, a.y >= b.y} } +@(require_results) greaterThanEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z} } +@(require_results) greaterThanEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } +@(require_results) greaterThanEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w} } equal :: proc{ @@ -1374,22 +1382,22 @@ equal :: proc{ equal_int4, equal_uint4, } -equal_float :: proc "c" (a, b: float) -> bool { return a == b } -equal_double :: proc "c" (a, b: double) -> bool { return a == b } -equal_int :: proc "c" (a, b: int) -> bool { return a == b } -equal_uint :: proc "c" (a, b: uint) -> bool { return a == b } -equal_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x == b.x, a.y == b.y} } -equal_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } -equal_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } -equal_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_float :: proc "c" (a, b: float) -> bool { return a == b } +@(require_results) equal_double :: proc "c" (a, b: double) -> bool { return a == b } +@(require_results) equal_int :: proc "c" (a, b: int) -> bool { return a == b } +@(require_results) equal_uint :: proc "c" (a, b: uint) -> bool { return a == b } +@(require_results) equal_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x == b.x, a.y == b.y} } +@(require_results) equal_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x == b.x, a.y == b.y, a.z == b.z} } +@(require_results) equal_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } +@(require_results) equal_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x == b.x, a.y == b.y, a.z == b.z, a.w == b.w} } notEqual :: proc{ notEqual_float, @@ -1409,22 +1417,22 @@ notEqual :: proc{ notEqual_int4, notEqual_uint4, } -notEqual_float :: proc "c" (a, b: float) -> bool { return a != b } -notEqual_double :: proc "c" (a, b: double) -> bool { return a != b } -notEqual_int :: proc "c" (a, b: int) -> bool { return a != b } -notEqual_uint :: proc "c" (a, b: uint) -> bool { return a != b } -notEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x != b.x, a.y != b.y} } -notEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } -notEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } -notEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_float :: proc "c" (a, b: float) -> bool { return a != b } +@(require_results) notEqual_double :: proc "c" (a, b: double) -> bool { return a != b } +@(require_results) notEqual_int :: proc "c" (a, b: int) -> bool { return a != b } +@(require_results) notEqual_uint :: proc "c" (a, b: uint) -> bool { return a != b } +@(require_results) notEqual_float2 :: proc "c" (a, b: float2) -> bool2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_double2 :: proc "c" (a, b: double2) -> bool2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_int2 :: proc "c" (a, b: int2) -> bool2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_uint2 :: proc "c" (a, b: uint2) -> bool2 { return {a.x != b.x, a.y != b.y} } +@(require_results) notEqual_float3 :: proc "c" (a, b: float3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_double3 :: proc "c" (a, b: double3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_int3 :: proc "c" (a, b: int3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_uint3 :: proc "c" (a, b: uint3) -> bool3 { return {a.x != b.x, a.y != b.y, a.z != b.z} } +@(require_results) notEqual_float4 :: proc "c" (a, b: float4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_double4 :: proc "c" (a, b: double4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_int4 :: proc "c" (a, b: int4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } +@(require_results) notEqual_uint4 :: proc "c" (a, b: uint4) -> bool4 { return {a.x != b.x, a.y != b.y, a.z != b.z, a.w != b.w} } any :: proc{ @@ -1433,10 +1441,10 @@ any :: proc{ any_bool3, any_bool4, } -any_bool :: proc "c" (v: bool) -> bool { return v } -any_bool2 :: proc "c" (v: bool2) -> bool { return v.x || v.y } -any_bool3 :: proc "c" (v: bool3) -> bool { return v.x || v.y || v.z } -any_bool4 :: proc "c" (v: bool4) -> bool { return v.x || v.y || v.z || v.w } +@(require_results) any_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) any_bool2 :: proc "c" (v: bool2) -> bool { return v.x || v.y } +@(require_results) any_bool3 :: proc "c" (v: bool3) -> bool { return v.x || v.y || v.z } +@(require_results) any_bool4 :: proc "c" (v: bool4) -> bool { return v.x || v.y || v.z || v.w } all :: proc{ all_bool, @@ -1444,10 +1452,10 @@ all :: proc{ all_bool3, all_bool4, } -all_bool :: proc "c" (v: bool) -> bool { return v } -all_bool2 :: proc "c" (v: bool2) -> bool { return v.x && v.y } -all_bool3 :: proc "c" (v: bool3) -> bool { return v.x && v.y && v.z } -all_bool4 :: proc "c" (v: bool4) -> bool { return v.x && v.y && v.z && v.w } +@(require_results) all_bool :: proc "c" (v: bool) -> bool { return v } +@(require_results) all_bool2 :: proc "c" (v: bool2) -> bool { return v.x && v.y } +@(require_results) all_bool3 :: proc "c" (v: bool3) -> bool { return v.x && v.y && v.z } +@(require_results) all_bool4 :: proc "c" (v: bool4) -> bool { return v.x && v.y && v.z && v.w } not :: proc{ not_bool, @@ -1455,22 +1463,22 @@ not :: proc{ not_bool3, not_bool4, } -not_bool :: proc "c" (v: bool) -> bool { return !v } -not_bool2 :: proc "c" (v: bool2) -> bool2 { return {!v.x, !v.y} } -not_bool3 :: proc "c" (v: bool3) -> bool3 { return {!v.x, !v.y, !v.z} } -not_bool4 :: proc "c" (v: bool4) -> bool4 { return {!v.x, !v.y, !v.z, !v.w} } +@(require_results) not_bool :: proc "c" (v: bool) -> bool { return !v } +@(require_results) not_bool2 :: proc "c" (v: bool2) -> bool2 { return {!v.x, !v.y} } +@(require_results) not_bool3 :: proc "c" (v: bool3) -> bool3 { return {!v.x, !v.y, !v.z} } +@(require_results) not_bool4 :: proc "c" (v: bool4) -> bool4 { return {!v.x, !v.y, !v.z, !v.w} } -inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return builtin.inverse(m) } -inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return builtin.inverse(m) } -inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return builtin.inverse(m) } -inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return builtin.inverse(m) } -inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return builtin.inverse(m) } -inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return builtin.inverse(m) } -inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return builtin.inverse(m) } -inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return builtin.inverse(m) } +@(require_results) inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return builtin.inverse(m) } +@(require_results) inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return builtin.inverse(m) } +@(require_results) inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return builtin.inverse(m) } +@(require_results) inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return builtin.inverse(m) } +@(require_results) inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return builtin.inverse(m) } +@(require_results) inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return builtin.inverse(m) } +@(require_results) inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return builtin.inverse(m) } +@(require_results) inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return builtin.inverse(m) } inverse :: proc{ inverse_float1x1, @@ -1544,57 +1552,57 @@ asfloat :: proc{ asfloat_double3, asfloat_double4, } -asfloat_float :: proc "c" (v: float) -> float { return float(v) } -asfloat_double :: proc "c" (v: double) -> float { return float(v) } -asfloat_int :: proc "c" (v: int) -> float { return float(v) } -asfloat_uint :: proc "c" (v: uint) -> float { return float(v) } -asfloat_float1x1 :: proc "c" (v: float1x1) -> float1x1 { return float1x1(v) } -asfloat_float2x2 :: proc "c" (v: float2x2) -> float2x2 { return float2x2(v) } -asfloat_float3x3 :: proc "c" (v: float3x3) -> float3x3 { return float3x3(v) } -asfloat_float4x4 :: proc "c" (v: float4x4) -> float4x4 { return float4x4(v) } -asfloat_float1x2 :: proc "c" (v: float1x2) -> float1x2 { return float1x2(v) } -asfloat_float1x3 :: proc "c" (v: float1x3) -> float1x3 { return float1x3(v) } -asfloat_float1x4 :: proc "c" (v: float1x4) -> float1x4 { return float1x4(v) } -asfloat_float2x1 :: proc "c" (v: float2x1) -> float2x1 { return float2x1(v) } -asfloat_float2x3 :: proc "c" (v: float2x3) -> float2x3 { return float2x3(v) } -asfloat_float2x4 :: proc "c" (v: float2x4) -> float2x4 { return float2x4(v) } -asfloat_float3x1 :: proc "c" (v: float3x1) -> float3x1 { return float3x1(v) } -asfloat_float3x2 :: proc "c" (v: float3x2) -> float3x2 { return float3x2(v) } -asfloat_float3x4 :: proc "c" (v: float3x4) -> float3x4 { return float3x4(v) } -asfloat_float4x1 :: proc "c" (v: float4x1) -> float4x1 { return float4x1(v) } -asfloat_float4x2 :: proc "c" (v: float4x2) -> float4x2 { return float4x2(v) } -asfloat_float4x3 :: proc "c" (v: float4x3) -> float4x3 { return float4x3(v) } -asfloat_float2 :: proc "c" (v: float2) -> float2 { return float2(v) } -asfloat_float3 :: proc "c" (v: float3) -> float3 { return float3(v) } -asfloat_float4 :: proc "c" (v: float4) -> float4 { return float4(v) } -asfloat_int2 :: proc "c" (v: int2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_int3 :: proc "c" (v: int3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_int4 :: proc "c" (v: int4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } -asfloat_uint2 :: proc "c" (v: uint2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_uint3 :: proc "c" (v: uint3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_uint4 :: proc "c" (v: uint4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } -asfloat_bool2 :: proc "c" (v: bool2) -> float2 { return float2{float(int(v.x)), float(int(v.y))} } -asfloat_bool3 :: proc "c" (v: bool3) -> float3 { return float3{float(int(v.x)), float(int(v.y)), float(int(v.z))} } -asfloat_bool4 :: proc "c" (v: bool4) -> float4 { return float4{float(int(v.x)), float(int(v.y)), float(int(v.z)), float(int(v.w))} } -asfloat_double1x1 :: proc "c" (v: double1x1) -> float1x1 { return float1x1(v) } -asfloat_double2x2 :: proc "c" (v: double2x2) -> float2x2 { return float2x2(v) } -asfloat_double3x3 :: proc "c" (v: double3x3) -> float3x3 { return float3x3(v) } -asfloat_double4x4 :: proc "c" (v: double4x4) -> float4x4 { return float4x4(v) } -asfloat_double1x2 :: proc "c" (v: double1x2) -> float1x2 { return float1x2(v) } -asfloat_double1x3 :: proc "c" (v: double1x3) -> float1x3 { return float1x3(v) } -asfloat_double1x4 :: proc "c" (v: double1x4) -> float1x4 { return float1x4(v) } -asfloat_double2x1 :: proc "c" (v: double2x1) -> float2x1 { return float2x1(v) } -asfloat_double2x3 :: proc "c" (v: double2x3) -> float2x3 { return float2x3(v) } -asfloat_double2x4 :: proc "c" (v: double2x4) -> float2x4 { return float2x4(v) } -asfloat_double3x1 :: proc "c" (v: double3x1) -> float3x1 { return float3x1(v) } -asfloat_double3x2 :: proc "c" (v: double3x2) -> float3x2 { return float3x2(v) } -asfloat_double3x4 :: proc "c" (v: double3x4) -> float3x4 { return float3x4(v) } -asfloat_double4x1 :: proc "c" (v: double4x1) -> float4x1 { return float4x1(v) } -asfloat_double4x2 :: proc "c" (v: double4x2) -> float4x2 { return float4x2(v) } -asfloat_double4x3 :: proc "c" (v: double4x3) -> float4x3 { return float4x3(v) } -asfloat_double2 :: proc "c" (v: double2) -> float2 { return float2{float(v.x), float(v.y)} } -asfloat_double3 :: proc "c" (v: double3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } -asfloat_double4 :: proc "c" (v: double4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(require_results) asfloat_float :: proc "c" (v: float) -> float { return float(v) } +@(require_results) asfloat_double :: proc "c" (v: double) -> float { return float(v) } +@(require_results) asfloat_int :: proc "c" (v: int) -> float { return float(v) } +@(require_results) asfloat_uint :: proc "c" (v: uint) -> float { return float(v) } +@(require_results) asfloat_float1x1 :: proc "c" (v: float1x1) -> float1x1 { return float1x1(v) } +@(require_results) asfloat_float2x2 :: proc "c" (v: float2x2) -> float2x2 { return float2x2(v) } +@(require_results) asfloat_float3x3 :: proc "c" (v: float3x3) -> float3x3 { return float3x3(v) } +@(require_results) asfloat_float4x4 :: proc "c" (v: float4x4) -> float4x4 { return float4x4(v) } +@(require_results) asfloat_float1x2 :: proc "c" (v: float1x2) -> float1x2 { return float1x2(v) } +@(require_results) asfloat_float1x3 :: proc "c" (v: float1x3) -> float1x3 { return float1x3(v) } +@(require_results) asfloat_float1x4 :: proc "c" (v: float1x4) -> float1x4 { return float1x4(v) } +@(require_results) asfloat_float2x1 :: proc "c" (v: float2x1) -> float2x1 { return float2x1(v) } +@(require_results) asfloat_float2x3 :: proc "c" (v: float2x3) -> float2x3 { return float2x3(v) } +@(require_results) asfloat_float2x4 :: proc "c" (v: float2x4) -> float2x4 { return float2x4(v) } +@(require_results) asfloat_float3x1 :: proc "c" (v: float3x1) -> float3x1 { return float3x1(v) } +@(require_results) asfloat_float3x2 :: proc "c" (v: float3x2) -> float3x2 { return float3x2(v) } +@(require_results) asfloat_float3x4 :: proc "c" (v: float3x4) -> float3x4 { return float3x4(v) } +@(require_results) asfloat_float4x1 :: proc "c" (v: float4x1) -> float4x1 { return float4x1(v) } +@(require_results) asfloat_float4x2 :: proc "c" (v: float4x2) -> float4x2 { return float4x2(v) } +@(require_results) asfloat_float4x3 :: proc "c" (v: float4x3) -> float4x3 { return float4x3(v) } +@(require_results) asfloat_float2 :: proc "c" (v: float2) -> float2 { return float2(v) } +@(require_results) asfloat_float3 :: proc "c" (v: float3) -> float3 { return float3(v) } +@(require_results) asfloat_float4 :: proc "c" (v: float4) -> float4 { return float4(v) } +@(require_results) asfloat_int2 :: proc "c" (v: int2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_int3 :: proc "c" (v: int3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_int4 :: proc "c" (v: int4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(require_results) asfloat_uint2 :: proc "c" (v: uint2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_uint3 :: proc "c" (v: uint3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_uint4 :: proc "c" (v: uint4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } +@(require_results) asfloat_bool2 :: proc "c" (v: bool2) -> float2 { return float2{float(int(v.x)), float(int(v.y))} } +@(require_results) asfloat_bool3 :: proc "c" (v: bool3) -> float3 { return float3{float(int(v.x)), float(int(v.y)), float(int(v.z))} } +@(require_results) asfloat_bool4 :: proc "c" (v: bool4) -> float4 { return float4{float(int(v.x)), float(int(v.y)), float(int(v.z)), float(int(v.w))} } +@(require_results) asfloat_double1x1 :: proc "c" (v: double1x1) -> float1x1 { return float1x1(v) } +@(require_results) asfloat_double2x2 :: proc "c" (v: double2x2) -> float2x2 { return float2x2(v) } +@(require_results) asfloat_double3x3 :: proc "c" (v: double3x3) -> float3x3 { return float3x3(v) } +@(require_results) asfloat_double4x4 :: proc "c" (v: double4x4) -> float4x4 { return float4x4(v) } +@(require_results) asfloat_double1x2 :: proc "c" (v: double1x2) -> float1x2 { return float1x2(v) } +@(require_results) asfloat_double1x3 :: proc "c" (v: double1x3) -> float1x3 { return float1x3(v) } +@(require_results) asfloat_double1x4 :: proc "c" (v: double1x4) -> float1x4 { return float1x4(v) } +@(require_results) asfloat_double2x1 :: proc "c" (v: double2x1) -> float2x1 { return float2x1(v) } +@(require_results) asfloat_double2x3 :: proc "c" (v: double2x3) -> float2x3 { return float2x3(v) } +@(require_results) asfloat_double2x4 :: proc "c" (v: double2x4) -> float2x4 { return float2x4(v) } +@(require_results) asfloat_double3x1 :: proc "c" (v: double3x1) -> float3x1 { return float3x1(v) } +@(require_results) asfloat_double3x2 :: proc "c" (v: double3x2) -> float3x2 { return float3x2(v) } +@(require_results) asfloat_double3x4 :: proc "c" (v: double3x4) -> float3x4 { return float3x4(v) } +@(require_results) asfloat_double4x1 :: proc "c" (v: double4x1) -> float4x1 { return float4x1(v) } +@(require_results) asfloat_double4x2 :: proc "c" (v: double4x2) -> float4x2 { return float4x2(v) } +@(require_results) asfloat_double4x3 :: proc "c" (v: double4x3) -> float4x3 { return float4x3(v) } +@(require_results) asfloat_double2 :: proc "c" (v: double2) -> float2 { return float2{float(v.x), float(v.y)} } +@(require_results) asfloat_double3 :: proc "c" (v: double3) -> float3 { return float3{float(v.x), float(v.y), float(v.z)} } +@(require_results) asfloat_double4 :: proc "c" (v: double4) -> float4 { return float4{float(v.x), float(v.y), float(v.z), float(v.w)} } asdouble :: proc{ asdouble_float, @@ -1649,57 +1657,57 @@ asdouble :: proc{ asdouble_double3, asdouble_double4, } -asdouble_float :: proc "c" (v: float) -> double { return double(v) } -asdouble_double :: proc "c" (v: double) -> double { return double(v) } -asdouble_int :: proc "c" (v: int) -> double { return double(v) } -asdouble_uint :: proc "c" (v: uint) -> double { return double(v) } -asdouble_float1x1 :: proc "c" (v: float1x1) -> double1x1 { return double1x1(v) } -asdouble_float2x2 :: proc "c" (v: float2x2) -> double2x2 { return double2x2(v) } -asdouble_float3x3 :: proc "c" (v: float3x3) -> double3x3 { return double3x3(v) } -asdouble_float4x4 :: proc "c" (v: float4x4) -> double4x4 { return double4x4(v) } -asdouble_float1x2 :: proc "c" (v: float1x2) -> double1x2 { return double1x2(v) } -asdouble_float1x3 :: proc "c" (v: float1x3) -> double1x3 { return double1x3(v) } -asdouble_float1x4 :: proc "c" (v: float1x4) -> double1x4 { return double1x4(v) } -asdouble_float2x1 :: proc "c" (v: float2x1) -> double2x1 { return double2x1(v) } -asdouble_float2x3 :: proc "c" (v: float2x3) -> double2x3 { return double2x3(v) } -asdouble_float2x4 :: proc "c" (v: float2x4) -> double2x4 { return double2x4(v) } -asdouble_float3x1 :: proc "c" (v: float3x1) -> double3x1 { return double3x1(v) } -asdouble_float3x2 :: proc "c" (v: float3x2) -> double3x2 { return double3x2(v) } -asdouble_float3x4 :: proc "c" (v: float3x4) -> double3x4 { return double3x4(v) } -asdouble_float4x1 :: proc "c" (v: float4x1) -> double4x1 { return double4x1(v) } -asdouble_float4x2 :: proc "c" (v: float4x2) -> double4x2 { return double4x2(v) } -asdouble_float4x3 :: proc "c" (v: float4x3) -> double4x3 { return double4x3(v) } -asdouble_float2 :: proc "c" (v: float2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_float3 :: proc "c" (v: float3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_float4 :: proc "c" (v: float4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_int2 :: proc "c" (v: int2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_int3 :: proc "c" (v: int3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_int4 :: proc "c" (v: int4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_uint2 :: proc "c" (v: uint2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_uint3 :: proc "c" (v: uint3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_uint4 :: proc "c" (v: uint4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } -asdouble_bool2 :: proc "c" (v: bool2) -> double2 { return double2{double(int(v.x)), double(int(v.y))} } -asdouble_bool3 :: proc "c" (v: bool3) -> double3 { return double3{double(int(v.x)), double(int(v.y)), double(int(v.z))} } -asdouble_bool4 :: proc "c" (v: bool4) -> double4 { return double4{double(int(v.x)), double(int(v.y)), double(int(v.z)), double(int(v.w))} } -asdouble_double1x1 :: proc "c" (v: double1x1) -> double1x1 { return double1x1(v) } -asdouble_double2x2 :: proc "c" (v: double2x2) -> double2x2 { return double2x2(v) } -asdouble_double3x3 :: proc "c" (v: double3x3) -> double3x3 { return double3x3(v) } -asdouble_double4x4 :: proc "c" (v: double4x4) -> double4x4 { return double4x4(v) } -asdouble_double1x2 :: proc "c" (v: double1x2) -> double1x2 { return double1x2(v) } -asdouble_double1x3 :: proc "c" (v: double1x3) -> double1x3 { return double1x3(v) } -asdouble_double1x4 :: proc "c" (v: double1x4) -> double1x4 { return double1x4(v) } -asdouble_double2x1 :: proc "c" (v: double2x1) -> double2x1 { return double2x1(v) } -asdouble_double2x3 :: proc "c" (v: double2x3) -> double2x3 { return double2x3(v) } -asdouble_double2x4 :: proc "c" (v: double2x4) -> double2x4 { return double2x4(v) } -asdouble_double3x1 :: proc "c" (v: double3x1) -> double3x1 { return double3x1(v) } -asdouble_double3x2 :: proc "c" (v: double3x2) -> double3x2 { return double3x2(v) } -asdouble_double3x4 :: proc "c" (v: double3x4) -> double3x4 { return double3x4(v) } -asdouble_double4x1 :: proc "c" (v: double4x1) -> double4x1 { return double4x1(v) } -asdouble_double4x2 :: proc "c" (v: double4x2) -> double4x2 { return double4x2(v) } -asdouble_double4x3 :: proc "c" (v: double4x3) -> double4x3 { return double4x3(v) } -asdouble_double2 :: proc "c" (v: double2) -> double2 { return double2{double(v.x), double(v.y)} } -asdouble_double3 :: proc "c" (v: double3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } -asdouble_double4 :: proc "c" (v: double4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_float :: proc "c" (v: float) -> double { return double(v) } +@(require_results) asdouble_double :: proc "c" (v: double) -> double { return double(v) } +@(require_results) asdouble_int :: proc "c" (v: int) -> double { return double(v) } +@(require_results) asdouble_uint :: proc "c" (v: uint) -> double { return double(v) } +@(require_results) asdouble_float1x1 :: proc "c" (v: float1x1) -> double1x1 { return double1x1(v) } +@(require_results) asdouble_float2x2 :: proc "c" (v: float2x2) -> double2x2 { return double2x2(v) } +@(require_results) asdouble_float3x3 :: proc "c" (v: float3x3) -> double3x3 { return double3x3(v) } +@(require_results) asdouble_float4x4 :: proc "c" (v: float4x4) -> double4x4 { return double4x4(v) } +@(require_results) asdouble_float1x2 :: proc "c" (v: float1x2) -> double1x2 { return double1x2(v) } +@(require_results) asdouble_float1x3 :: proc "c" (v: float1x3) -> double1x3 { return double1x3(v) } +@(require_results) asdouble_float1x4 :: proc "c" (v: float1x4) -> double1x4 { return double1x4(v) } +@(require_results) asdouble_float2x1 :: proc "c" (v: float2x1) -> double2x1 { return double2x1(v) } +@(require_results) asdouble_float2x3 :: proc "c" (v: float2x3) -> double2x3 { return double2x3(v) } +@(require_results) asdouble_float2x4 :: proc "c" (v: float2x4) -> double2x4 { return double2x4(v) } +@(require_results) asdouble_float3x1 :: proc "c" (v: float3x1) -> double3x1 { return double3x1(v) } +@(require_results) asdouble_float3x2 :: proc "c" (v: float3x2) -> double3x2 { return double3x2(v) } +@(require_results) asdouble_float3x4 :: proc "c" (v: float3x4) -> double3x4 { return double3x4(v) } +@(require_results) asdouble_float4x1 :: proc "c" (v: float4x1) -> double4x1 { return double4x1(v) } +@(require_results) asdouble_float4x2 :: proc "c" (v: float4x2) -> double4x2 { return double4x2(v) } +@(require_results) asdouble_float4x3 :: proc "c" (v: float4x3) -> double4x3 { return double4x3(v) } +@(require_results) asdouble_float2 :: proc "c" (v: float2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_float3 :: proc "c" (v: float3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_float4 :: proc "c" (v: float4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_int2 :: proc "c" (v: int2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_int3 :: proc "c" (v: int3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_int4 :: proc "c" (v: int4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_uint2 :: proc "c" (v: uint2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_uint3 :: proc "c" (v: uint3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_uint4 :: proc "c" (v: uint4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } +@(require_results) asdouble_bool2 :: proc "c" (v: bool2) -> double2 { return double2{double(int(v.x)), double(int(v.y))} } +@(require_results) asdouble_bool3 :: proc "c" (v: bool3) -> double3 { return double3{double(int(v.x)), double(int(v.y)), double(int(v.z))} } +@(require_results) asdouble_bool4 :: proc "c" (v: bool4) -> double4 { return double4{double(int(v.x)), double(int(v.y)), double(int(v.z)), double(int(v.w))} } +@(require_results) asdouble_double1x1 :: proc "c" (v: double1x1) -> double1x1 { return double1x1(v) } +@(require_results) asdouble_double2x2 :: proc "c" (v: double2x2) -> double2x2 { return double2x2(v) } +@(require_results) asdouble_double3x3 :: proc "c" (v: double3x3) -> double3x3 { return double3x3(v) } +@(require_results) asdouble_double4x4 :: proc "c" (v: double4x4) -> double4x4 { return double4x4(v) } +@(require_results) asdouble_double1x2 :: proc "c" (v: double1x2) -> double1x2 { return double1x2(v) } +@(require_results) asdouble_double1x3 :: proc "c" (v: double1x3) -> double1x3 { return double1x3(v) } +@(require_results) asdouble_double1x4 :: proc "c" (v: double1x4) -> double1x4 { return double1x4(v) } +@(require_results) asdouble_double2x1 :: proc "c" (v: double2x1) -> double2x1 { return double2x1(v) } +@(require_results) asdouble_double2x3 :: proc "c" (v: double2x3) -> double2x3 { return double2x3(v) } +@(require_results) asdouble_double2x4 :: proc "c" (v: double2x4) -> double2x4 { return double2x4(v) } +@(require_results) asdouble_double3x1 :: proc "c" (v: double3x1) -> double3x1 { return double3x1(v) } +@(require_results) asdouble_double3x2 :: proc "c" (v: double3x2) -> double3x2 { return double3x2(v) } +@(require_results) asdouble_double3x4 :: proc "c" (v: double3x4) -> double3x4 { return double3x4(v) } +@(require_results) asdouble_double4x1 :: proc "c" (v: double4x1) -> double4x1 { return double4x1(v) } +@(require_results) asdouble_double4x2 :: proc "c" (v: double4x2) -> double4x2 { return double4x2(v) } +@(require_results) asdouble_double4x3 :: proc "c" (v: double4x3) -> double4x3 { return double4x3(v) } +@(require_results) asdouble_double2 :: proc "c" (v: double2) -> double2 { return double2{double(v.x), double(v.y)} } +@(require_results) asdouble_double3 :: proc "c" (v: double3) -> double3 { return double3{double(v.x), double(v.y), double(v.z)} } +@(require_results) asdouble_double4 :: proc "c" (v: double4) -> double4 { return double4{double(v.x), double(v.y), double(v.z), double(v.w)} } asint :: proc{ asint_float, @@ -1754,57 +1762,57 @@ asint :: proc{ asint_double3, asint_double4, } -asint_float :: proc "c" (v: float) -> int { return int(v) } -asint_double :: proc "c" (v: double) -> int { return int(v) } -asint_int :: proc "c" (v: int) -> int { return int(v) } -asint_uint :: proc "c" (v: uint) -> int { return int(v) } -asint_float1x1 :: proc "c" (v: float1x1) -> int1x1 { return int1x1(v) } -asint_float2x2 :: proc "c" (v: float2x2) -> int2x2 { return int2x2(v) } -asint_float3x3 :: proc "c" (v: float3x3) -> int3x3 { return int3x3(v) } -asint_float4x4 :: proc "c" (v: float4x4) -> int4x4 { return int4x4(v) } -asint_float1x2 :: proc "c" (v: float1x2) -> int1x2 { return int1x2(v) } -asint_float1x3 :: proc "c" (v: float1x3) -> int1x3 { return int1x3(v) } -asint_float1x4 :: proc "c" (v: float1x4) -> int1x4 { return int1x4(v) } -asint_float2x1 :: proc "c" (v: float2x1) -> int2x1 { return int2x1(v) } -asint_float2x3 :: proc "c" (v: float2x3) -> int2x3 { return int2x3(v) } -asint_float2x4 :: proc "c" (v: float2x4) -> int2x4 { return int2x4(v) } -asint_float3x1 :: proc "c" (v: float3x1) -> int3x1 { return int3x1(v) } -asint_float3x2 :: proc "c" (v: float3x2) -> int3x2 { return int3x2(v) } -asint_float3x4 :: proc "c" (v: float3x4) -> int3x4 { return int3x4(v) } -asint_float4x1 :: proc "c" (v: float4x1) -> int4x1 { return int4x1(v) } -asint_float4x2 :: proc "c" (v: float4x2) -> int4x2 { return int4x2(v) } -asint_float4x3 :: proc "c" (v: float4x3) -> int4x3 { return int4x3(v) } -asint_float2 :: proc "c" (v: float2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_float3 :: proc "c" (v: float3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_float4 :: proc "c" (v: float4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_int2 :: proc "c" (v: int2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_int3 :: proc "c" (v: int3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_int4 :: proc "c" (v: int4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_uint2 :: proc "c" (v: uint2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_uint3 :: proc "c" (v: uint3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_uint4 :: proc "c" (v: uint4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } -asint_bool2 :: proc "c" (v: bool2) -> int2 { return int2{int(int(v.x)), int(int(v.y))} } -asint_bool3 :: proc "c" (v: bool3) -> int3 { return int3{int(int(v.x)), int(int(v.y)), int(int(v.z))} } -asint_bool4 :: proc "c" (v: bool4) -> int4 { return int4{int(int(v.x)), int(int(v.y)), int(int(v.z)), int(int(v.w))} } -asint_double1x1 :: proc "c" (v: double1x1) -> int1x1 { return int1x1(v) } -asint_double2x2 :: proc "c" (v: double2x2) -> int2x2 { return int2x2(v) } -asint_double3x3 :: proc "c" (v: double3x3) -> int3x3 { return int3x3(v) } -asint_double4x4 :: proc "c" (v: double4x4) -> int4x4 { return int4x4(v) } -asint_double1x2 :: proc "c" (v: double1x2) -> int1x2 { return int1x2(v) } -asint_double1x3 :: proc "c" (v: double1x3) -> int1x3 { return int1x3(v) } -asint_double1x4 :: proc "c" (v: double1x4) -> int1x4 { return int1x4(v) } -asint_double2x1 :: proc "c" (v: double2x1) -> int2x1 { return int2x1(v) } -asint_double2x3 :: proc "c" (v: double2x3) -> int2x3 { return int2x3(v) } -asint_double2x4 :: proc "c" (v: double2x4) -> int2x4 { return int2x4(v) } -asint_double3x1 :: proc "c" (v: double3x1) -> int3x1 { return int3x1(v) } -asint_double3x2 :: proc "c" (v: double3x2) -> int3x2 { return int3x2(v) } -asint_double3x4 :: proc "c" (v: double3x4) -> int3x4 { return int3x4(v) } -asint_double4x1 :: proc "c" (v: double4x1) -> int4x1 { return int4x1(v) } -asint_double4x2 :: proc "c" (v: double4x2) -> int4x2 { return int4x2(v) } -asint_double4x3 :: proc "c" (v: double4x3) -> int4x3 { return int4x3(v) } -asint_double2 :: proc "c" (v: double2) -> int2 { return int2{int(v.x), int(v.y)} } -asint_double3 :: proc "c" (v: double3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } -asint_double4 :: proc "c" (v: double4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_float :: proc "c" (v: float) -> int { return int(v) } +@(require_results) asint_double :: proc "c" (v: double) -> int { return int(v) } +@(require_results) asint_int :: proc "c" (v: int) -> int { return int(v) } +@(require_results) asint_uint :: proc "c" (v: uint) -> int { return int(v) } +@(require_results) asint_float1x1 :: proc "c" (v: float1x1) -> int1x1 { return int1x1(v) } +@(require_results) asint_float2x2 :: proc "c" (v: float2x2) -> int2x2 { return int2x2(v) } +@(require_results) asint_float3x3 :: proc "c" (v: float3x3) -> int3x3 { return int3x3(v) } +@(require_results) asint_float4x4 :: proc "c" (v: float4x4) -> int4x4 { return int4x4(v) } +@(require_results) asint_float1x2 :: proc "c" (v: float1x2) -> int1x2 { return int1x2(v) } +@(require_results) asint_float1x3 :: proc "c" (v: float1x3) -> int1x3 { return int1x3(v) } +@(require_results) asint_float1x4 :: proc "c" (v: float1x4) -> int1x4 { return int1x4(v) } +@(require_results) asint_float2x1 :: proc "c" (v: float2x1) -> int2x1 { return int2x1(v) } +@(require_results) asint_float2x3 :: proc "c" (v: float2x3) -> int2x3 { return int2x3(v) } +@(require_results) asint_float2x4 :: proc "c" (v: float2x4) -> int2x4 { return int2x4(v) } +@(require_results) asint_float3x1 :: proc "c" (v: float3x1) -> int3x1 { return int3x1(v) } +@(require_results) asint_float3x2 :: proc "c" (v: float3x2) -> int3x2 { return int3x2(v) } +@(require_results) asint_float3x4 :: proc "c" (v: float3x4) -> int3x4 { return int3x4(v) } +@(require_results) asint_float4x1 :: proc "c" (v: float4x1) -> int4x1 { return int4x1(v) } +@(require_results) asint_float4x2 :: proc "c" (v: float4x2) -> int4x2 { return int4x2(v) } +@(require_results) asint_float4x3 :: proc "c" (v: float4x3) -> int4x3 { return int4x3(v) } +@(require_results) asint_float2 :: proc "c" (v: float2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_float3 :: proc "c" (v: float3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_float4 :: proc "c" (v: float4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_int2 :: proc "c" (v: int2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_int3 :: proc "c" (v: int3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_int4 :: proc "c" (v: int4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_uint2 :: proc "c" (v: uint2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_uint3 :: proc "c" (v: uint3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_uint4 :: proc "c" (v: uint4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } +@(require_results) asint_bool2 :: proc "c" (v: bool2) -> int2 { return int2{int(int(v.x)), int(int(v.y))} } +@(require_results) asint_bool3 :: proc "c" (v: bool3) -> int3 { return int3{int(int(v.x)), int(int(v.y)), int(int(v.z))} } +@(require_results) asint_bool4 :: proc "c" (v: bool4) -> int4 { return int4{int(int(v.x)), int(int(v.y)), int(int(v.z)), int(int(v.w))} } +@(require_results) asint_double1x1 :: proc "c" (v: double1x1) -> int1x1 { return int1x1(v) } +@(require_results) asint_double2x2 :: proc "c" (v: double2x2) -> int2x2 { return int2x2(v) } +@(require_results) asint_double3x3 :: proc "c" (v: double3x3) -> int3x3 { return int3x3(v) } +@(require_results) asint_double4x4 :: proc "c" (v: double4x4) -> int4x4 { return int4x4(v) } +@(require_results) asint_double1x2 :: proc "c" (v: double1x2) -> int1x2 { return int1x2(v) } +@(require_results) asint_double1x3 :: proc "c" (v: double1x3) -> int1x3 { return int1x3(v) } +@(require_results) asint_double1x4 :: proc "c" (v: double1x4) -> int1x4 { return int1x4(v) } +@(require_results) asint_double2x1 :: proc "c" (v: double2x1) -> int2x1 { return int2x1(v) } +@(require_results) asint_double2x3 :: proc "c" (v: double2x3) -> int2x3 { return int2x3(v) } +@(require_results) asint_double2x4 :: proc "c" (v: double2x4) -> int2x4 { return int2x4(v) } +@(require_results) asint_double3x1 :: proc "c" (v: double3x1) -> int3x1 { return int3x1(v) } +@(require_results) asint_double3x2 :: proc "c" (v: double3x2) -> int3x2 { return int3x2(v) } +@(require_results) asint_double3x4 :: proc "c" (v: double3x4) -> int3x4 { return int3x4(v) } +@(require_results) asint_double4x1 :: proc "c" (v: double4x1) -> int4x1 { return int4x1(v) } +@(require_results) asint_double4x2 :: proc "c" (v: double4x2) -> int4x2 { return int4x2(v) } +@(require_results) asint_double4x3 :: proc "c" (v: double4x3) -> int4x3 { return int4x3(v) } +@(require_results) asint_double2 :: proc "c" (v: double2) -> int2 { return int2{int(v.x), int(v.y)} } +@(require_results) asint_double3 :: proc "c" (v: double3) -> int3 { return int3{int(v.x), int(v.y), int(v.z)} } +@(require_results) asint_double4 :: proc "c" (v: double4) -> int4 { return int4{int(v.x), int(v.y), int(v.z), int(v.w)} } asuint :: proc{ @@ -1828,25 +1836,25 @@ asuint :: proc{ asuint_double3, asuint_double4, } -asuint_float :: proc "c" (v: float) -> uint { return uint(v) } -asuint_double :: proc "c" (v: double) -> uint { return uint(v) } -asuint_int :: proc "c" (v: int) -> uint { return uint(v) } -asuint_uint :: proc "c" (v: uint) -> uint { return uint(v) } -asuint_float2 :: proc "c" (v: float2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_float3 :: proc "c" (v: float3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_float4 :: proc "c" (v: float4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_int2 :: proc "c" (v: int2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_int3 :: proc "c" (v: int3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_int4 :: proc "c" (v: int4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_uint2 :: proc "c" (v: uint2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_uint3 :: proc "c" (v: uint3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_uint4 :: proc "c" (v: uint4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } -asuint_bool2 :: proc "c" (v: bool2) -> uint2 { return uint2{uint(uint(v.x)), uint(uint(v.y))} } -asuint_bool3 :: proc "c" (v: bool3) -> uint3 { return uint3{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z))} } -asuint_bool4 :: proc "c" (v: bool4) -> uint4 { return uint4{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z)), uint(uint(v.w))} } -asuint_double2 :: proc "c" (v: double2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } -asuint_double3 :: proc "c" (v: double3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } -asuint_double4 :: proc "c" (v: double4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_float :: proc "c" (v: float) -> uint { return uint(v) } +@(require_results) asuint_double :: proc "c" (v: double) -> uint { return uint(v) } +@(require_results) asuint_int :: proc "c" (v: int) -> uint { return uint(v) } +@(require_results) asuint_uint :: proc "c" (v: uint) -> uint { return uint(v) } +@(require_results) asuint_float2 :: proc "c" (v: float2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_float3 :: proc "c" (v: float3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_float4 :: proc "c" (v: float4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_int2 :: proc "c" (v: int2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_int3 :: proc "c" (v: int3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_int4 :: proc "c" (v: int4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_uint2 :: proc "c" (v: uint2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_uint3 :: proc "c" (v: uint3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_uint4 :: proc "c" (v: uint4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } +@(require_results) asuint_bool2 :: proc "c" (v: bool2) -> uint2 { return uint2{uint(uint(v.x)), uint(uint(v.y))} } +@(require_results) asuint_bool3 :: proc "c" (v: bool3) -> uint3 { return uint3{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z))} } +@(require_results) asuint_bool4 :: proc "c" (v: bool4) -> uint4 { return uint4{uint(uint(v.x)), uint(uint(v.y)), uint(uint(v.z)), uint(uint(v.w))} } +@(require_results) asuint_double2 :: proc "c" (v: double2) -> uint2 { return uint2{uint(v.x), uint(v.y)} } +@(require_results) asuint_double3 :: proc "c" (v: double3) -> uint3 { return uint3{uint(v.x), uint(v.y), uint(v.z)} } +@(require_results) asuint_double4 :: proc "c" (v: double4) -> uint4 { return uint4{uint(v.x), uint(v.y), uint(v.z), uint(v.w)} } // TODO(bill): All of the `mul` procedures diff --git a/core/math/linalg/hlsl/linalg_hlsl_math.odin b/core/math/linalg/hlsl/linalg_hlsl_math.odin index 91c542b59..5b8004342 100644 --- a/core/math/linalg/hlsl/linalg_hlsl_math.odin +++ b/core/math/linalg/hlsl/linalg_hlsl_math.odin @@ -2,34 +2,35 @@ package math_linalg_hlsl import "core:math" -cos_float :: proc "c" (x: float) -> float { return math.cos(x) } -sin_float :: proc "c" (x: float) -> float { return math.sin(x) } -tan_float :: proc "c" (x: float) -> float { return math.tan(x) } -acos_float :: proc "c" (x: float) -> float { return math.acos(x) } -asin_float :: proc "c" (x: float) -> float { return math.asin(x) } -atan_float :: proc "c" (x: float) -> float { return math.atan(x) } -atan2_float :: proc "c" (y, x: float) -> float { return math.atan2(y, x) } -cosh_float :: proc "c" (x: float) -> float { return math.cosh(x) } -sinh_float :: proc "c" (x: float) -> float { return math.sinh(x) } -tanh_float :: proc "c" (x: float) -> float { return math.tanh(x) } -acosh_float :: proc "c" (x: float) -> float { return math.acosh(x) } -asinh_float :: proc "c" (x: float) -> float { return math.asinh(x) } -atanh_float :: proc "c" (x: float) -> float { return math.atanh(x) } -sqrt_float :: proc "c" (x: float) -> float { return math.sqrt(x) } -rsqrt_float :: proc "c" (x: float) -> float { return 1.0/math.sqrt(x) } -rcp_float :: proc "c" (x: float) -> float { return 1.0/x } -pow_float :: proc "c" (x, y: float) -> float { return math.pow(x, y) } -exp_float :: proc "c" (x: float) -> float { return math.exp(x) } -log_float :: proc "c" (x: float) -> float { return math.ln(x) } -log2_float :: proc "c" (x: float) -> float { return math.log(x, 2) } -log10_float :: proc "c" (x: float) -> float { return math.log(x, 10) } -exp2_float :: proc "c" (x: float) -> float { return math.pow(float(2), x) } -sign_float :: proc "c" (x: float) -> float { return math.sign(x) } -floor_float :: proc "c" (x: float) -> float { return math.floor(x) } -round_float :: proc "c" (x: float) -> float { return math.round(x) } -ceil_float :: proc "c" (x: float) -> float { return math.ceil(x) } -isnan_float :: proc "c" (x: float) -> bool { return math.classify(x) == .NaN} -fmod_float :: proc "c" (x, y: float) -> float { return math.mod(x, y) } +@(require_results) cos_float :: proc "c" (x: float) -> float { return math.cos(x) } +@(require_results) sin_float :: proc "c" (x: float) -> float { return math.sin(x) } +@(require_results) tan_float :: proc "c" (x: float) -> float { return math.tan(x) } +@(require_results) acos_float :: proc "c" (x: float) -> float { return math.acos(x) } +@(require_results) asin_float :: proc "c" (x: float) -> float { return math.asin(x) } +@(require_results) atan_float :: proc "c" (x: float) -> float { return math.atan(x) } +@(require_results) atan2_float :: proc "c" (y, x: float) -> float { return math.atan2(y, x) } +@(require_results) cosh_float :: proc "c" (x: float) -> float { return math.cosh(x) } +@(require_results) sinh_float :: proc "c" (x: float) -> float { return math.sinh(x) } +@(require_results) tanh_float :: proc "c" (x: float) -> float { return math.tanh(x) } +@(require_results) acosh_float :: proc "c" (x: float) -> float { return math.acosh(x) } +@(require_results) asinh_float :: proc "c" (x: float) -> float { return math.asinh(x) } +@(require_results) atanh_float :: proc "c" (x: float) -> float { return math.atanh(x) } +@(require_results) sqrt_float :: proc "c" (x: float) -> float { return math.sqrt(x) } +@(require_results) rsqrt_float :: proc "c" (x: float) -> float { return 1.0/math.sqrt(x) } +@(require_results) rcp_float :: proc "c" (x: float) -> float { return 1.0/x } +@(require_results) pow_float :: proc "c" (x, y: float) -> float { return math.pow(x, y) } +@(require_results) exp_float :: proc "c" (x: float) -> float { return math.exp(x) } +@(require_results) log_float :: proc "c" (x: float) -> float { return math.ln(x) } +@(require_results) log2_float :: proc "c" (x: float) -> float { return math.log(x, 2) } +@(require_results) log10_float :: proc "c" (x: float) -> float { return math.log(x, 10) } +@(require_results) exp2_float :: proc "c" (x: float) -> float { return math.pow(float(2), x) } +@(require_results) sign_float :: proc "c" (x: float) -> float { return math.sign(x) } +@(require_results) floor_float :: proc "c" (x: float) -> float { return math.floor(x) } +@(require_results) round_float :: proc "c" (x: float) -> float { return math.round(x) } +@(require_results) ceil_float :: proc "c" (x: float) -> float { return math.ceil(x) } +@(require_results) isnan_float :: proc "c" (x: float) -> bool { return math.classify(x) == .NaN} +@(require_results) fmod_float :: proc "c" (x, y: float) -> float { return math.mod(x, y) } +@(require_results) frac_float :: proc "c" (x: float) -> float { if x >= 0 { return x - math.trunc(x) @@ -38,34 +39,35 @@ frac_float :: proc "c" (x: float) -> float { } -cos_double :: proc "c" (x: double) -> double { return math.cos(x) } -sin_double :: proc "c" (x: double) -> double { return math.sin(x) } -tan_double :: proc "c" (x: double) -> double { return math.tan(x) } -acos_double :: proc "c" (x: double) -> double { return math.acos(x) } -asin_double :: proc "c" (x: double) -> double { return math.asin(x) } -atan_double :: proc "c" (x: double) -> double { return math.atan(x) } -atan2_double :: proc "c" (y, x: double) -> double { return math.atan2(y, x) } -cosh_double :: proc "c" (x: double) -> double { return math.cosh(x) } -sinh_double :: proc "c" (x: double) -> double { return math.sinh(x) } -tanh_double :: proc "c" (x: double) -> double { return math.tanh(x) } -acosh_double :: proc "c" (x: double) -> double { return math.acosh(x) } -asinh_double :: proc "c" (x: double) -> double { return math.asinh(x) } -atanh_double :: proc "c" (x: double) -> double { return math.atanh(x) } -sqrt_double :: proc "c" (x: double) -> double { return math.sqrt(x) } -rsqrt_double :: proc "c" (x: double) -> double { return 1.0/math.sqrt(x) } -rcp_double :: proc "c" (x: double) -> double { return 1.0/x } -pow_double :: proc "c" (x, y: double) -> double { return math.pow(x, y) } -exp_double :: proc "c" (x: double) -> double { return math.exp(x) } -log_double :: proc "c" (x: double) -> double { return math.ln(x) } -log2_double :: proc "c" (x: double) -> double { return math.log(x, 2) } -log10_double :: proc "c" (x: double) -> double { return math.log(x, 10) } -exp2_double :: proc "c" (x: double) -> double { return math.pow(double(2), x) } -sign_double :: proc "c" (x: double) -> double { return math.sign(x) } -floor_double :: proc "c" (x: double) -> double { return math.floor(x) } -round_double :: proc "c" (x: double) -> double { return math.round(x) } -ceil_double :: proc "c" (x: double) -> double { return math.ceil(x) } -isnan_double :: proc "c" (x: double) -> bool { return math.classify(x) == .NaN} -fmod_double :: proc "c" (x, y: double) -> double { return math.mod(x, y) } +@(require_results) cos_double :: proc "c" (x: double) -> double { return math.cos(x) } +@(require_results) sin_double :: proc "c" (x: double) -> double { return math.sin(x) } +@(require_results) tan_double :: proc "c" (x: double) -> double { return math.tan(x) } +@(require_results) acos_double :: proc "c" (x: double) -> double { return math.acos(x) } +@(require_results) asin_double :: proc "c" (x: double) -> double { return math.asin(x) } +@(require_results) atan_double :: proc "c" (x: double) -> double { return math.atan(x) } +@(require_results) atan2_double :: proc "c" (y, x: double) -> double { return math.atan2(y, x) } +@(require_results) cosh_double :: proc "c" (x: double) -> double { return math.cosh(x) } +@(require_results) sinh_double :: proc "c" (x: double) -> double { return math.sinh(x) } +@(require_results) tanh_double :: proc "c" (x: double) -> double { return math.tanh(x) } +@(require_results) acosh_double :: proc "c" (x: double) -> double { return math.acosh(x) } +@(require_results) asinh_double :: proc "c" (x: double) -> double { return math.asinh(x) } +@(require_results) atanh_double :: proc "c" (x: double) -> double { return math.atanh(x) } +@(require_results) sqrt_double :: proc "c" (x: double) -> double { return math.sqrt(x) } +@(require_results) rsqrt_double :: proc "c" (x: double) -> double { return 1.0/math.sqrt(x) } +@(require_results) rcp_double :: proc "c" (x: double) -> double { return 1.0/x } +@(require_results) pow_double :: proc "c" (x, y: double) -> double { return math.pow(x, y) } +@(require_results) exp_double :: proc "c" (x: double) -> double { return math.exp(x) } +@(require_results) log_double :: proc "c" (x: double) -> double { return math.ln(x) } +@(require_results) log2_double :: proc "c" (x: double) -> double { return math.log(x, 2) } +@(require_results) log10_double :: proc "c" (x: double) -> double { return math.log(x, 10) } +@(require_results) exp2_double :: proc "c" (x: double) -> double { return math.pow(double(2), x) } +@(require_results) sign_double :: proc "c" (x: double) -> double { return math.sign(x) } +@(require_results) floor_double :: proc "c" (x: double) -> double { return math.floor(x) } +@(require_results) round_double :: proc "c" (x: double) -> double { return math.round(x) } +@(require_results) ceil_double :: proc "c" (x: double) -> double { return math.ceil(x) } +@(require_results) isnan_double :: proc "c" (x: double) -> bool { return math.classify(x) == .NaN} +@(require_results) fmod_double :: proc "c" (x, y: double) -> double { return math.mod(x, y) } +@(require_results) frac_double :: proc "c" (x: double) -> double { if x >= 0 { return x - math.trunc(x) From a1172d31f4b5aca40c013cb8f39f9a7c9ff8cde8 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:11:53 +0100 Subject: [PATCH 050/108] Add `@(require_results)` to `core:math/fixed` --- core/math/fixed/fixed.odin | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/core/math/fixed/fixed.odin b/core/math/fixed/fixed.odin index 856e7f088..e080d63b6 100644 --- a/core/math/fixed/fixed.odin +++ b/core/math/fixed/fixed.odin @@ -50,39 +50,48 @@ to_f64 :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> f64 { } +@(require_results) add :: proc(x, y: $T/Fixed) -> T { return {x.i + y.i} } +@(require_results) sub :: proc(x, y: $T/Fixed) -> T { return {x.i - y.i} } +@(require_results) mul :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) { z.i = intrinsics.fixed_point_mul(x.i, y.i, Fraction_Width) return } +@(require_results) mul_sat :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) { z.i = intrinsics.fixed_point_mul_sat(x.i, y.i, Fraction_Width) return } +@(require_results) div :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) { z.i = intrinsics.fixed_point_div(x.i, y.i, Fraction_Width) return } +@(require_results) div_sat :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) { z.i = intrinsics.fixed_point_div_sat(x.i, y.i, Fraction_Width) return } +@(require_results) floor :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing { return x.i >> Fraction_Width } +@(require_results) ceil :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing { Integer :: 8*size_of(Backing) - Fraction_Width return (x.i + (1 << Integer-1)) >> Fraction_Width } +@(require_results) round :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing { Integer :: 8*size_of(Backing) - Fraction_Width return (x.i + (1 << (Integer - 1))) >> Fraction_Width @@ -90,6 +99,7 @@ round :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing { +@(require_results) append :: proc(dst: []byte, x: $T/Fixed($Backing, $Fraction_Width)) -> string { x := x buf: [48]byte @@ -123,6 +133,7 @@ append :: proc(dst: []byte, x: $T/Fixed($Backing, $Fraction_Width)) -> string { } +@(require_results) to_string :: proc(x: $T/Fixed($Backing, $Fraction_Width), allocator := context.allocator) -> string { buf: [48]byte s := append(buf[:], x) From 18c5a536856f9296610a3180a6356eeab61f5521 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:13:44 +0100 Subject: [PATCH 051/108] Add `@(require_results)` and `contextless` to procedures in `core:math/bits` --- core/math/bits/bits.odin | 231 ++++++++++++++++++++++++++------------- 1 file changed, 154 insertions(+), 77 deletions(-) diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin index 850e8038a..959b5536f 100644 --- a/core/math/bits/bits.odin +++ b/core/math/bits/bits.odin @@ -37,68 +37,96 @@ overflowing_sub :: intrinsics.overflow_sub overflowing_mul :: intrinsics.overflow_mul -log2 :: proc(x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) { +@(require_results) +log2 :: proc "contextless" (x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) { return (8*size_of(T)-1) - count_leading_zeros(x) } -rotate_left8 :: proc(x: u8, k: int) -> u8 { +@(require_results) +rotate_left8 :: proc "contextless" (x: u8, k: int) -> u8 { n :: 8 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left16 :: proc(x: u16, k: int) -> u16 { +@(require_results) +rotate_left16 :: proc "contextless" (x: u16, k: int) -> u16 { n :: 16 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left32 :: proc(x: u32, k: int) -> u32 { +@(require_results) +rotate_left32 :: proc "contextless" (x: u32, k: int) -> u32 { n :: 32 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left64 :: proc(x: u64, k: int) -> u64 { +@(require_results) +rotate_left64 :: proc "contextless" (x: u64, k: int) -> u64 { n :: 64 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left :: proc(x: uint, k: int) -> uint { +@(require_results) +rotate_left :: proc "contextless" (x: uint, k: int) -> uint { n :: 8*size_of(uint) s := uint(k) & (n-1) return x <>(n-s) } -from_be_u8 :: proc(i: u8) -> u8 { return i } -from_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +from_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_le_u8 :: proc(i: u8) -> u8 { return i } -from_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +from_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_be_u8 :: proc(i: u8) -> u8 { return i } -to_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +to_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_le_u8 :: proc(i: u8) -> u8 { return i } -to_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +to_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -len_u8 :: proc(x: u8) -> int { +@(require_results) +len_u8 :: proc "contextless" (x: u8) -> int { return int(len_u8_table[x]) } -len_u16 :: proc(x: u16) -> (n: int) { +@(require_results) +len_u16 :: proc "contextless" (x: u16) -> (n: int) { x := x if x >= 1<<8 { x >>= 8 @@ -106,7 +134,8 @@ len_u16 :: proc(x: u16) -> (n: int) { } return n + int(len_u8_table[x]) } -len_u32 :: proc(x: u32) -> (n: int) { +@(require_results) +len_u32 :: proc "contextless" (x: u32) -> (n: int) { x := x if x >= 1<<16 { x >>= 16 @@ -118,7 +147,8 @@ len_u32 :: proc(x: u32) -> (n: int) { } return n + int(len_u8_table[x]) } -len_u64 :: proc(x: u64) -> (n: int) { +@(require_results) +len_u64 :: proc "contextless" (x: u64) -> (n: int) { x := x if x >= 1<<32 { x >>= 32 @@ -134,7 +164,8 @@ len_u64 :: proc(x: u64) -> (n: int) { } return n + int(len_u8_table[x]) } -len_uint :: proc(x: uint) -> (n: int) { +@(require_results) +len_uint :: proc "contextless" (x: uint) -> (n: int) { when size_of(uint) == size_of(u64) { return len_u64(u64(x)) } else { @@ -146,21 +177,24 @@ len_uint :: proc(x: uint) -> (n: int) { len :: proc{len_u8, len_u16, len_u32, len_u64, len_uint} -add_u32 :: proc(x, y, carry: u32) -> (sum, carry_out: u32) { +@(require_results) +add_u32 :: proc "contextless" (x, y, carry: u32) -> (sum, carry_out: u32) { tmp_carry, tmp_carry2: bool sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) carry_out = u32(tmp_carry | tmp_carry2) return } -add_u64 :: proc(x, y, carry: u64) -> (sum, carry_out: u64) { +@(require_results) +add_u64 :: proc "contextless" (x, y, carry: u64) -> (sum, carry_out: u64) { tmp_carry, tmp_carry2: bool sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) carry_out = u64(tmp_carry | tmp_carry2) return } -add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) { +@(require_results) +add_uint :: proc "contextless" (x, y, carry: uint) -> (sum, carry_out: uint) { when size_of(uint) == size_of(u64) { a, b := add_u64(u64(x), u64(y), u64(carry)) } else { @@ -172,21 +206,24 @@ add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) { add :: proc{add_u32, add_u64, add_uint} -sub_u32 :: proc(x, y, borrow: u32) -> (diff, borrow_out: u32) { +@(require_results) +sub_u32 :: proc "contextless" (x, y, borrow: u32) -> (diff, borrow_out: u32) { tmp_borrow, tmp_borrow2: bool diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) borrow_out = u32(tmp_borrow | tmp_borrow2) return } -sub_u64 :: proc(x, y, borrow: u64) -> (diff, borrow_out: u64) { +@(require_results) +sub_u64 :: proc "contextless" (x, y, borrow: u64) -> (diff, borrow_out: u64) { tmp_borrow, tmp_borrow2: bool diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) borrow_out = u64(tmp_borrow | tmp_borrow2) return } -sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) { +@(require_results) +sub_uint :: proc "contextless" (x, y, borrow: uint) -> (diff, borrow_out: uint) { when size_of(uint) == size_of(u64) { a, b := sub_u64(u64(x), u64(y), u64(borrow)) } else { @@ -198,18 +235,21 @@ sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) { sub :: proc{sub_u32, sub_u64, sub_uint} -mul_u32 :: proc(x, y: u32) -> (hi, lo: u32) { +@(require_results) +mul_u32 :: proc "contextless" (x, y: u32) -> (hi, lo: u32) { z := u64(x) * u64(y) hi, lo = u32(z>>32), u32(z) return } -mul_u64 :: proc(x, y: u64) -> (hi, lo: u64) { +@(require_results) +mul_u64 :: proc "contextless" (x, y: u64) -> (hi, lo: u64) { prod_wide := u128(x) * u128(y) hi, lo = u64(prod_wide>>64), u64(prod_wide) return } -mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { +@(require_results) +mul_uint :: proc "contextless" (x, y: uint) -> (hi, lo: uint) { when size_of(uint) == size_of(u32) { a, b := mul_u32(u32(x), u32(y)) } else { @@ -222,13 +262,15 @@ mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { mul :: proc{mul_u32, mul_u64, mul_uint} -div_u32 :: proc(hi, lo, y: u32) -> (quo, rem: u32) { +@(require_results) +div_u32 :: proc "odin" (hi, lo, y: u32) -> (quo, rem: u32) { assert(y != 0 && y <= hi) z := u64(hi)<<32 | u64(lo) quo, rem = u32(z/u64(y)), u32(z%u64(y)) return } -div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) { +@(require_results) +div_u64 :: proc "odin" (hi, lo, y: u64) -> (quo, rem: u64) { y := y two32 :: 1 << 32 mask32 :: two32 - 1 @@ -273,7 +315,8 @@ div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) { return q1*two32 + q0, (un21*two32 + un0 - q0*y) >> s } -div_uint :: proc(hi, lo, y: uint) -> (quo, rem: uint) { +@(require_results) +div_uint :: proc "odin" (hi, lo, y: uint) -> (quo, rem: uint) { when size_of(uint) == size_of(u32) { a, b := div_u32(u32(hi), u32(lo), u32(y)) } else { @@ -286,16 +329,26 @@ div :: proc{div_u32, div_u64, div_uint} -is_power_of_two_u8 :: proc(i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i8 :: proc(i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u16 :: proc(i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i16 :: proc(i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u32 :: proc(i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i32 :: proc(i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u64 :: proc(i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i64 :: proc(i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_int :: proc(i: int) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u8 :: proc "contextless" (i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i8 :: proc "contextless" (i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u16 :: proc "contextless" (i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i16 :: proc "contextless" (i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u32 :: proc "contextless" (i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i32 :: proc "contextless" (i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u64 :: proc "contextless" (i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i64 :: proc "contextless" (i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_uint :: proc "contextless" (i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_int :: proc "contextless" (i: int) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two :: proc{ is_power_of_two_u8, is_power_of_two_i8, @@ -320,44 +373,56 @@ len_u8_table := [256]u8{ } -bitfield_extract_u8 :: proc(value: u8, offset, bits: uint) -> u8 { return (value >> offset) & u8(1< u16 { return (value >> offset) & u16(1< u32 { return (value >> offset) & u32(1< u64 { return (value >> offset) & u64(1< u128 { return (value >> offset) & u128(1< uint { return (value >> offset) & uint(1< u8 { return (value >> offset) & u8(1< u16 { return (value >> offset) & u16(1< u32 { return (value >> offset) & u32(1< u64 { return (value >> offset) & u64(1< u128 { return (value >> offset) & u128(1< uint { return (value >> offset) & uint(1< i8 { +@(require_results) +bitfield_extract_i8 :: proc "contextless" (value: i8, offset, bits: uint) -> i8 { v := (u8(value) >> offset) & u8(1< i16 { +@(require_results) +bitfield_extract_i16 :: proc "contextless" (value: i16, offset, bits: uint) -> i16 { v := (u16(value) >> offset) & u16(1< i32 { +@(require_results) +bitfield_extract_i32 :: proc "contextless" (value: i32, offset, bits: uint) -> i32 { v := (u32(value) >> offset) & u32(1< i64 { +@(require_results) +bitfield_extract_i64 :: proc "contextless" (value: i64, offset, bits: uint) -> i64 { v := (u64(value) >> offset) & u64(1< i128 { +@(require_results) +bitfield_extract_i128 :: proc "contextless" (value: i128, offset, bits: uint) -> i128 { v := (u128(value) >> offset) & u128(1< int { +@(require_results) +bitfield_extract_int :: proc "contextless" (value: int, offset, bits: uint) -> int { v := (uint(value) >> offset) & uint(1< u8 { +@(require_results) +bitfield_insert_u8 :: proc "contextless" (base, insert: u8, offset, bits: uint) -> u8 { mask := u8(1< u16 { +@(require_results) +bitfield_insert_u16 :: proc "contextless" (base, insert: u16, offset, bits: uint) -> u16 { mask := u16(1< u32 { +@(require_results) +bitfield_insert_u32 :: proc "contextless" (base, insert: u32, offset, bits: uint) -> u32 { mask := u32(1< u64 { +@(require_results) +bitfield_insert_u64 :: proc "contextless" (base, insert: u64, offset, bits: uint) -> u64 { mask := u64(1< u128 { +@(require_results) +bitfield_insert_u128 :: proc "contextless" (base, insert: u128, offset, bits: uint) -> u128 { mask := u128(1< uint { +@(require_results) +bitfield_insert_uint :: proc "contextless" (base, insert: uint, offset, bits: uint) -> uint { mask := uint(1< i8 { +@(require_results) +bitfield_insert_i8 :: proc "contextless" (base, insert: i8, offset, bits: uint) -> i8 { mask := i8(1< i16 { +@(require_results) +bitfield_insert_i16 :: proc "contextless" (base, insert: i16, offset, bits: uint) -> i16 { mask := i16(1< i32 { +@(require_results) +bitfield_insert_i32 :: proc "contextless" (base, insert: i32, offset, bits: uint) -> i32 { mask := i32(1< i64 { +@(require_results) +bitfield_insert_i64 :: proc "contextless" (base, insert: i64, offset, bits: uint) -> i64 { mask := i64(1< i128 { +@(require_results) +bitfield_insert_i128 :: proc "contextless" (base, insert: i128, offset, bits: uint) -> i128 { mask := i128(1< int { +@(require_results) +bitfield_insert_int :: proc "contextless" (base, insert: int, offset, bits: uint) -> int { mask := int(1< Date: Mon, 22 May 2023 12:37:26 +0100 Subject: [PATCH 052/108] Restrict `---` to variable declarations only --- src/check_decl.cpp | 2 +- src/check_expr.cpp | 31 +++++++++++++++++++++++++------ src/check_stmt.cpp | 2 +- 3 files changed, 27 insertions(+), 8 deletions(-) diff --git a/src/check_decl.cpp b/src/check_decl.cpp index e97e86e8b..b16215571 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -123,7 +123,7 @@ gb_internal void check_init_variables(CheckerContext *ctx, Entity **lhs, isize l // an extra allocation TEMPORARY_ALLOCATOR_GUARD(); auto operands = array_make(temporary_allocator(), 0, 2*lhs_count); - check_unpack_arguments(ctx, lhs, lhs_count, &operands, inits, true, false); + check_unpack_arguments(ctx, lhs, lhs_count, &operands, inits, UnpackFlag_AllowOk|UnpackFlag_AllowUndef); isize rhs_count = operands.count; isize max = gb_min(lhs_count, rhs_count); diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 1552b1ef5..e0e74a3aa 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -5144,8 +5144,20 @@ gb_internal bool check_assignment_arguments(CheckerContext *ctx, Array } +typedef u32 UnpackFlags; +enum UnpackFlag : u32 { + UnpackFlag_None = 0, + UnpackFlag_AllowOk = 1<<0, + UnpackFlag_IsVariadic = 1<<1, + UnpackFlag_AllowUndef = 1<<2, +}; + + +gb_internal bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize lhs_count, Array *operands, Slice const &rhs, UnpackFlags flags) { + bool allow_ok = (flags & UnpackFlag_AllowOk) != 0; + bool is_variadic = (flags & UnpackFlag_IsVariadic) != 0; + bool allow_undef = (flags & UnpackFlag_AllowUndef) != 0; -gb_internal bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize lhs_count, Array *operands, Slice const &rhs, bool allow_ok, bool is_variadic) { bool optional_ok = false; isize tuple_index = 0; for_array(i, rhs) { @@ -5184,7 +5196,13 @@ gb_internal bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize } } - check_expr_base(c, &o, rhs[i], type_hint); + if (allow_undef && rhs[i] != nullptr && rhs[i]->kind == Ast_Undef) { + o.type = t_untyped_undef; + o.mode = Addressing_Value; + o.expr = rhs[i]; + } else { + check_expr_base(c, &o, rhs[i], type_hint); + } if (o.mode == Addressing_NoValue) { error_operand_no_value(&o); o.mode = Addressing_Invalid; @@ -5968,7 +5986,7 @@ gb_internal CallArgumentData check_call_arguments(CheckerContext *c, Operand *op lhs = populate_proc_parameter_list(c, proc_type, &lhs_count, &is_variadic); } if (operand->mode != Addressing_ProcGroup) { - check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, is_variadic); + check_unpack_arguments(c, lhs, lhs_count, &operands, args, is_variadic ? UnpackFlag_IsVariadic : UnpackFlag_None); } } @@ -6025,7 +6043,7 @@ gb_internal CallArgumentData check_call_arguments(CheckerContext *c, Operand *op isize lhs_count = -1; bool is_variadic = false; lhs = populate_proc_parameter_list(c, e->type, &lhs_count, &is_variadic); - check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, is_variadic); + check_unpack_arguments(c, lhs, lhs_count, &operands, args, is_variadic ? UnpackFlag_IsVariadic : UnpackFlag_None); CallArgumentData data = {}; CallArgumentError err = call_checker(c, call, e->type, e, operands, CallArgumentMode_ShowErrors, &data); @@ -6101,7 +6119,7 @@ gb_internal CallArgumentData check_call_arguments(CheckerContext *c, Operand *op } - check_unpack_arguments(c, lhs, lhs_count, &operands, args, false, false); + check_unpack_arguments(c, lhs, lhs_count, &operands, args, UnpackFlag_None); if (lhs != nullptr) { gb_free(heap_allocator(), lhs); @@ -6462,7 +6480,7 @@ gb_internal CallArgumentError check_polymorphic_record_type(CheckerContext *c, O lhs_count = params->variables.count; } - check_unpack_arguments(c, lhs, lhs_count, &operands, ce->args, false, false); + check_unpack_arguments(c, lhs, lhs_count, &operands, ce->args, UnpackFlag_None); } } @@ -9583,6 +9601,7 @@ gb_internal ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast case_ast_node(u, Undef, node); o->mode = Addressing_Value; o->type = t_untyped_undef; + error(node, "Use of --- outside of variable declaration"); case_end; diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 1e3b35c21..6c69ad59f 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -2176,7 +2176,7 @@ gb_internal void check_return_stmt(CheckerContext *ctx, Ast *node) { auto operands = array_make(heap_allocator(), 0, 2*rs->results.count); defer (array_free(&operands)); - check_unpack_arguments(ctx, result_entities, result_count, &operands, rs->results, true, false); + check_unpack_arguments(ctx, result_entities, result_count, &operands, rs->results, UnpackFlag_AllowOk); if (result_count == 0 && rs->results.count > 0) { error(rs->results[0], "No return values expected"); From 540f724b1f57d0d5a40b65a59f6ee82e070c6ee5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:42:02 +0100 Subject: [PATCH 053/108] Fix `---` on variable declarations --- src/check_expr.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/check_expr.cpp b/src/check_expr.cpp index e0e74a3aa..20a690e1e 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -5196,10 +5196,13 @@ gb_internal bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize } } - if (allow_undef && rhs[i] != nullptr && rhs[i]->kind == Ast_Undef) { + Ast *rhs_expr = unparen_expr(rhs[i]); + if (allow_undef && rhs_expr != nullptr && rhs_expr->kind == Ast_Undef) { + // NOTE(bill): Just handle this very specific logic here o.type = t_untyped_undef; o.mode = Addressing_Value; o.expr = rhs[i]; + add_type_and_value(c, rhs[i], o.mode, o.type, o.value); } else { check_expr_base(c, &o, rhs[i], type_hint); } From 8bf32ac697ea21ff3b37e5b31fe0fc10e700c9a4 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:53:29 +0100 Subject: [PATCH 054/108] Minor change to handling of propagation of errors with `---` as a value --- src/check_decl.cpp | 9 ++++---- src/check_expr.cpp | 45 +++++++++++++++++------------------- src/check_type.cpp | 6 ++--- src/checker.cpp | 4 ++-- src/llvm_backend.cpp | 10 ++------ src/llvm_backend_const.cpp | 2 +- src/llvm_backend_debug.cpp | 2 +- src/llvm_backend_expr.cpp | 16 ++++++------- src/llvm_backend_general.cpp | 4 ++-- src/llvm_backend_proc.cpp | 8 +++---- src/parser.cpp | 14 +++++------ src/parser.hpp | 2 +- src/parser_pos.cpp | 4 ++-- src/tokenizer.cpp | 6 ++--- src/types.cpp | 19 +++++++-------- 15 files changed, 69 insertions(+), 82 deletions(-) diff --git a/src/check_decl.cpp b/src/check_decl.cpp index b16215571..84b0d39d8 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -70,13 +70,12 @@ gb_internal Type *check_init_variable(CheckerContext *ctx, Entity *e, Operand *o // NOTE(bill): Use the type of the operand Type *t = operand->type; if (is_type_untyped(t)) { - if (t == t_invalid || is_type_untyped_nil(t)) { - error(e->token, "Invalid use of untyped nil in %.*s", LIT(context_name)); + if (is_type_untyped_uninit(t)) { + error(e->token, "Invalid use of --- in %.*s", LIT(context_name)); e->type = t_invalid; return nullptr; - } - if (t == t_invalid || is_type_untyped_undef(t)) { - error(e->token, "Invalid use of --- in %.*s", LIT(context_name)); + } else if (t == t_invalid || is_type_untyped_nil(t)) { + error(e->token, "Invalid use of untyped nil in %.*s", LIT(context_name)); e->type = t_invalid; return nullptr; } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 20a690e1e..830b5315d 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -646,11 +646,8 @@ gb_internal i64 check_distance_between_types(CheckerContext *c, Operand *operand Type *src = base_type(s); Type *dst = base_type(type); - if (is_type_untyped_undef(src)) { - if (type_has_undef(dst)) { - return 1; - } - return -1; + if (is_type_untyped_uninit(src)) { + return 1; } if (is_type_untyped_nil(src)) { @@ -993,13 +990,13 @@ gb_internal void check_assignment(CheckerContext *c, Operand *operand, Type *typ if (is_type_untyped(operand->type)) { Type *target_type = type; if (type == nullptr || is_type_any(type)) { - if (type == nullptr && is_type_untyped_nil(operand->type)) { - error(operand->expr, "Use of untyped nil in %.*s", LIT(context_name)); + if (type == nullptr && is_type_untyped_uninit(operand->type)) { + error(operand->expr, "Use of --- in %.*s", LIT(context_name)); operand->mode = Addressing_Invalid; return; } - if (type == nullptr && is_type_untyped_undef(operand->type)) { - error(operand->expr, "Use of --- in %.*s", LIT(context_name)); + if (type == nullptr && is_type_untyped_nil(operand->type)) { + error(operand->expr, "Use of untyped nil in %.*s", LIT(context_name)); operand->mode = Addressing_Invalid; return; } @@ -3969,7 +3966,7 @@ gb_internal void convert_to_typed(CheckerContext *c, Operand *operand, Type *tar case Type_Union: - if (!is_operand_nil(*operand) && !is_operand_undef(*operand)) { + if (!is_operand_nil(*operand) && !is_operand_uninit(*operand)) { TEMPORARY_ALLOCATOR_GUARD(); isize count = t->Union.variants.count; @@ -4036,8 +4033,8 @@ gb_internal void convert_to_typed(CheckerContext *c, Operand *operand, Type *tar error_line("\n\n"); return; - } else if (is_type_untyped_undef(operand->type) && type_has_undef(target_type)) { - target_type = t_untyped_undef; + } else if (is_type_untyped_uninit(operand->type)) { + target_type = t_untyped_uninit; } else if (!is_type_untyped_nil(operand->type) || !type_has_nil(target_type)) { begin_error_block(); defer (end_error_block()); @@ -4070,8 +4067,8 @@ gb_internal void convert_to_typed(CheckerContext *c, Operand *operand, Type *tar default: - if (is_type_untyped_undef(operand->type) && type_has_undef(target_type)) { - target_type = t_untyped_undef; + if (is_type_untyped_uninit(operand->type)) { + target_type = t_untyped_uninit; } else if (is_type_untyped_nil(operand->type) && type_has_nil(target_type)) { target_type = t_untyped_nil; } else { @@ -4083,8 +4080,8 @@ gb_internal void convert_to_typed(CheckerContext *c, Operand *operand, Type *tar } if (is_type_any(target_type) && is_type_untyped(operand->type)) { - if (is_type_untyped_nil(operand->type) && is_type_untyped_undef(operand->type)) { - + if (is_type_untyped_nil(operand->type) && is_type_untyped_uninit(operand->type)) { + } else { target_type = default_type(operand->type); } @@ -5197,9 +5194,9 @@ gb_internal bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize } Ast *rhs_expr = unparen_expr(rhs[i]); - if (allow_undef && rhs_expr != nullptr && rhs_expr->kind == Ast_Undef) { + if (allow_undef && rhs_expr != nullptr && rhs_expr->kind == Ast_Uninit) { // NOTE(bill): Just handle this very specific logic here - o.type = t_untyped_undef; + o.type = t_untyped_uninit; o.mode = Addressing_Value; o.expr = rhs[i]; add_type_and_value(c, rhs[i], o.mode, o.type, o.value); @@ -7167,11 +7164,11 @@ gb_internal bool check_set_index_data(Operand *o, Type *t, bool indirection, i64 } gb_internal bool ternary_compare_types(Type *x, Type *y) { - if (is_type_untyped_undef(x) && type_has_undef(y)) { + if (is_type_untyped_uninit(x)) { return true; } else if (is_type_untyped_nil(x) && type_has_nil(y)) { return true; - } else if (is_type_untyped_undef(y) && type_has_undef(x)) { + } else if (is_type_untyped_uninit(y)) { return true; } else if (is_type_untyped_nil(y) && type_has_nil(x)) { return true; @@ -7708,7 +7705,7 @@ gb_internal ExprKind check_ternary_if_expr(CheckerContext *c, Operand *o, Ast *n } o->type = x.type; - if (is_type_untyped_nil(o->type) || is_type_untyped_undef(o->type)) { + if (is_type_untyped_nil(o->type) || is_type_untyped_uninit(o->type)) { o->type = y.type; } @@ -9601,9 +9598,9 @@ gb_internal ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast check_ident(c, o, node, nullptr, type_hint, false); case_end; - case_ast_node(u, Undef, node); + case_ast_node(u, Uninit, node); o->mode = Addressing_Value; - o->type = t_untyped_undef; + o->type = t_untyped_uninit; error(node, "Use of --- outside of variable declaration"); case_end; @@ -10167,7 +10164,7 @@ gb_internal gbString write_expr_to_string(gbString str, Ast *node, bool shorthan str = string_append_string(str, bd->name.string); case_end; - case_ast_node(ud, Undef, node); + case_ast_node(ud, Uninit, node); str = gb_string_appendc(str, "---"); case_end; diff --git a/src/check_type.cpp b/src/check_type.cpp index dfe774f6b..bbfc25a12 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -135,7 +135,7 @@ gb_internal void check_struct_fields(CheckerContext *ctx, Ast *node, Slicemodule, var.var); - if (is_type_untyped_undef(init.type)) { - // LLVMSetInitializer(var.var.value, LLVMGetUndef(global_type)); - LLVMSetInitializer(var.var.value, LLVMConstNull(global_type)); - var.is_initialized = true; - continue; - } else if (is_type_untyped_nil(init.type)) { + if (is_type_untyped_nil(init.type)) { LLVMSetInitializer(var.var.value, LLVMConstNull(global_type)); var.is_initialized = true; continue; @@ -2363,8 +2358,7 @@ gb_internal bool lb_generate_code(lbGenerator *gen) { } } } - if (!var.is_initialized && - (is_type_untyped_nil(tav.type) || is_type_untyped_undef(tav.type))) { + if (!var.is_initialized && is_type_untyped_nil(tav.type)) { var.is_initialized = true; } } diff --git a/src/llvm_backend_const.cpp b/src/llvm_backend_const.cpp index 8db6e2a1f..ea25a4594 100644 --- a/src/llvm_backend_const.cpp +++ b/src/llvm_backend_const.cpp @@ -1,6 +1,6 @@ gb_internal bool lb_is_const(lbValue value) { LLVMValueRef v = value.value; - if (is_type_untyped_nil(value.type) || is_type_untyped_undef(value.type)) { + if (is_type_untyped_nil(value.type)) { // TODO(bill): Is this correct behaviour? return true; } diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp index fd26c41a0..bec719a4a 100644 --- a/src/llvm_backend_debug.cpp +++ b/src/llvm_backend_debug.cpp @@ -282,7 +282,7 @@ gb_internal LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) { case Basic_UntypedString: GB_PANIC("Basic_UntypedString"); break; case Basic_UntypedRune: GB_PANIC("Basic_UntypedRune"); break; case Basic_UntypedNil: GB_PANIC("Basic_UntypedNil"); break; - case Basic_UntypedUndef: GB_PANIC("Basic_UntypedUndef"); break; + case Basic_UntypedUninit: GB_PANIC("Basic_UntypedUninit"); break; default: GB_PANIC("Basic Unhandled"); break; } diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index 69443c9a3..143e38a8d 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -1486,12 +1486,12 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { GB_ASSERT(src != nullptr); GB_ASSERT(dst != nullptr); + if (is_type_untyped_uninit(src)) { + return lb_const_undef(m, t); + } if (is_type_untyped_nil(src)) { return lb_const_nil(m, t); } - if (is_type_untyped_undef(src)) { - return lb_const_undef(m, t); - } if (LLVMIsConstant(value.value)) { if (is_type_any(dst)) { @@ -2132,12 +2132,12 @@ gb_internal lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { if (is_type_any(dst)) { + if (is_type_untyped_uninit(src)) { + return lb_const_undef(p->module, t); + } if (is_type_untyped_nil(src)) { return lb_const_nil(p->module, t); } - if (is_type_untyped_undef(src)) { - return lb_const_undef(p->module, t); - } lbAddr result = lb_add_local_generated(p, t, true); @@ -3136,11 +3136,11 @@ gb_internal lbValue lb_build_expr_internal(lbProcedure *p, Ast *expr) { return lb_addr_load(p, lb_build_addr(p, expr)); case_end; - case_ast_node(u, Undef, expr) + case_ast_node(u, Uninit, expr) lbValue res = {}; if (is_type_untyped(type)) { res.value = nullptr; - res.type = t_untyped_undef; + res.type = t_untyped_uninit; } else { res.value = LLVMGetUndef(lb_type(m, type)); res.type = type; diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp index 7d2f574fe..628c1e5fa 100644 --- a/src/llvm_backend_general.cpp +++ b/src/llvm_backend_general.cpp @@ -677,7 +677,7 @@ gb_internal void lb_addr_store(lbProcedure *p, lbAddr addr, lbValue value) { return; } GB_ASSERT(value.type != nullptr); - if (is_type_untyped_undef(value.type)) { + if (is_type_untyped_uninit(value.type)) { Type *t = lb_addr_type(addr); value.type = t; value.value = LLVMGetUndef(lb_type(p->module, t)); @@ -1828,7 +1828,7 @@ gb_internal LLVMTypeRef lb_type_internal(lbModule *m, Type *type) { case Basic_UntypedString: GB_PANIC("Basic_UntypedString"); break; case Basic_UntypedRune: GB_PANIC("Basic_UntypedRune"); break; case Basic_UntypedNil: GB_PANIC("Basic_UntypedNil"); break; - case Basic_UntypedUndef: GB_PANIC("Basic_UntypedUndef"); break; + case Basic_UntypedUninit: GB_PANIC("Basic_UntypedUninit"); break; } break; case Type_Named: diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index ddf058668..b8353a466 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -3218,10 +3218,10 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { Entity *e = params->variables[i]; if (args[i].type == nullptr) { continue; + } else if (is_type_untyped_uninit(args[i].type)) { + args[i] = lb_const_undef(m, e->type); } else if (is_type_untyped_nil(args[i].type)) { args[i] = lb_const_nil(m, e->type); - } else if (is_type_untyped_undef(args[i].type)) { - args[i] = lb_const_undef(m, e->type); } } @@ -3409,10 +3409,10 @@ gb_internal lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { Entity *e = param_tuple->variables[i]; if (args[i].type == nullptr) { continue; + } else if (is_type_untyped_uninit(args[i].type)) { + args[i] = lb_const_undef(m, e->type); } else if (is_type_untyped_nil(args[i].type)) { args[i] = lb_const_nil(m, e->type); - } else if (is_type_untyped_undef(args[i].type)) { - args[i] = lb_const_undef(m, e->type); } } } diff --git a/src/parser.cpp b/src/parser.cpp index 698ba99ab..bb492fca9 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -115,7 +115,7 @@ gb_internal Ast *clone_ast(Ast *node, AstFile *f) { n->Ident.entity = nullptr; break; case Ast_Implicit: break; - case Ast_Undef: break; + case Ast_Uninit: break; case Ast_BasicLit: break; case Ast_BasicDirective: break; @@ -646,9 +646,9 @@ gb_internal Ast *ast_implicit(AstFile *f, Token token) { result->Implicit = token; return result; } -gb_internal Ast *ast_undef(AstFile *f, Token token) { - Ast *result = alloc_ast_node(f, Ast_Undef); - result->Undef = token; +gb_internal Ast *ast_uninit(AstFile *f, Token token) { + Ast *result = alloc_ast_node(f, Ast_Uninit); + result->Uninit = token; return result; } @@ -2092,8 +2092,8 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { case Token_Ident: return parse_ident(f); - case Token_Undef: - return ast_undef(f, expect_token(f, Token_Undef)); + case Token_Uninit: + return ast_uninit(f, expect_token(f, Token_Uninit)); case Token_context: return ast_implicit(f, expect_token(f, Token_context)); @@ -2292,7 +2292,7 @@ gb_internal Ast *parse_operand(AstFile *f, bool lhs) { skip_possible_newline_for_literal(f); - if (allow_token(f, Token_Undef)) { + if (allow_token(f, Token_Uninit)) { if (where_token.kind != Token_Invalid) { syntax_error(where_token, "'where' clauses are not allowed on procedure literals without a defined body (replaced with ---)"); } diff --git a/src/parser.hpp b/src/parser.hpp index aea3bbf21..d4883f287 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -373,7 +373,7 @@ gb_global char const *union_type_kind_strings[UnionType_COUNT] = { Entity *entity; \ }) \ AST_KIND(Implicit, "implicit", Token) \ - AST_KIND(Undef, "undef", Token) \ + AST_KIND(Uninit, "uninitialized value", Token) \ AST_KIND(BasicLit, "basic literal", struct { \ Token token; \ }) \ diff --git a/src/parser_pos.cpp b/src/parser_pos.cpp index 1274f05a0..52d49e897 100644 --- a/src/parser_pos.cpp +++ b/src/parser_pos.cpp @@ -2,7 +2,7 @@ gb_internal Token ast_token(Ast *node) { switch (node->kind) { case Ast_Ident: return node->Ident.token; case Ast_Implicit: return node->Implicit; - case Ast_Undef: return node->Undef; + case Ast_Uninit: return node->Uninit; case Ast_BasicLit: return node->BasicLit.token; case Ast_BasicDirective: return node->BasicDirective.token; case Ast_ProcGroup: return node->ProcGroup.token; @@ -137,7 +137,7 @@ Token ast_end_token(Ast *node) { return empty_token; case Ast_Ident: return node->Ident.token; case Ast_Implicit: return node->Implicit; - case Ast_Undef: return node->Undef; + case Ast_Uninit: return node->Uninit; case Ast_BasicLit: return node->BasicLit.token; case Ast_BasicDirective: return node->BasicDirective.token; case Ast_ProcGroup: return node->ProcGroup.close; diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 547a864fb..17a396b9f 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -54,7 +54,7 @@ TOKEN_KIND(Token__AssignOpEnd, ""), \ TOKEN_KIND(Token_Increment, "++"), \ TOKEN_KIND(Token_Decrement, "--"), \ TOKEN_KIND(Token_ArrowRight,"->"), \ - TOKEN_KIND(Token_Undef, "---"), \ + TOKEN_KIND(Token_Uninit, "---"), \ \ TOKEN_KIND(Token__ComparisonBegin, ""), \ TOKEN_KIND(Token_CmpEq, "=="), \ @@ -917,7 +917,7 @@ gb_internal void tokenizer_get_token(Tokenizer *t, Token *token, int repeat=0) { token->kind = Token_Decrement; if (t->curr_rune == '-') { advance_to_next_rune(t); - token->kind = Token_Undef; + token->kind = Token_Uninit; } break; case '>': @@ -1078,7 +1078,7 @@ semicolon_check:; case Token_Imag: case Token_Rune: case Token_String: - case Token_Undef: + case Token_Uninit: /*fallthrough*/ case Token_Question: case Token_Pointer: diff --git a/src/types.cpp b/src/types.cpp index 70c4bcdbe..35fbb719b 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -83,7 +83,7 @@ enum BasicKind { Basic_UntypedString, Basic_UntypedRune, Basic_UntypedNil, - Basic_UntypedUndef, + Basic_UntypedUninit, Basic_COUNT, @@ -515,7 +515,7 @@ gb_global Type basic_types[] = { {Type_Basic, {Basic_UntypedString, BasicFlag_String | BasicFlag_Untyped, 0, STR_LIT("untyped string")}}, {Type_Basic, {Basic_UntypedRune, BasicFlag_Integer | BasicFlag_Untyped, 0, STR_LIT("untyped rune")}}, {Type_Basic, {Basic_UntypedNil, BasicFlag_Untyped, 0, STR_LIT("untyped nil")}}, - {Type_Basic, {Basic_UntypedUndef, BasicFlag_Untyped, 0, STR_LIT("untyped undefined")}}, + {Type_Basic, {Basic_UntypedUninit, BasicFlag_Untyped, 0, STR_LIT("untyped uninitialized")}}, }; // gb_global Type basic_type_aliases[] = { @@ -589,7 +589,7 @@ gb_global Type *t_untyped_quaternion = &basic_types[Basic_UntypedQuaternion]; gb_global Type *t_untyped_string = &basic_types[Basic_UntypedString]; gb_global Type *t_untyped_rune = &basic_types[Basic_UntypedRune]; gb_global Type *t_untyped_nil = &basic_types[Basic_UntypedNil]; -gb_global Type *t_untyped_undef = &basic_types[Basic_UntypedUndef]; +gb_global Type *t_untyped_uninit = &basic_types[Basic_UntypedUninit]; @@ -1866,14 +1866,15 @@ gb_internal bool is_type_typeid(Type *t) { } gb_internal bool is_type_untyped_nil(Type *t) { t = base_type(t); - return (t->kind == Type_Basic && t->Basic.kind == Basic_UntypedNil); + // NOTE(bill): checking for `nil` or `---` at once is just to improve the error handling + return (t->kind == Type_Basic && (t->Basic.kind == Basic_UntypedNil || t->Basic.kind == Basic_UntypedUninit)); } -gb_internal bool is_type_untyped_undef(Type *t) { +gb_internal bool is_type_untyped_uninit(Type *t) { t = base_type(t); - return (t->kind == Type_Basic && t->Basic.kind == Basic_UntypedUndef); + // NOTE(bill): checking for `nil` or `---` at once is just to improve the error handling + return (t->kind == Type_Basic && t->Basic.kind == Basic_UntypedUninit); } - gb_internal bool is_type_empty_union(Type *t) { t = base_type(t); return t->kind == Type_Union && t->Union.variants.count == 0; @@ -2206,10 +2207,6 @@ gb_internal bool is_type_polymorphic(Type *t, bool or_specialized=false) { } -gb_internal gb_inline bool type_has_undef(Type *t) { - return true; -} - gb_internal bool type_has_nil(Type *t) { t = base_type(t); switch (t->kind) { From 730192adc496262f5a705270779334e0f2ee25fe Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 14:51:46 +0100 Subject: [PATCH 055/108] Add procedure groups for `Device_newBuffer` and `Texture_newTextureView` --- vendor/darwin/Metal/MetalClasses.odin | 28 +++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/vendor/darwin/Metal/MetalClasses.odin b/vendor/darwin/Metal/MetalClasses.odin index 66cf68cce..93e772e5c 100644 --- a/vendor/darwin/Metal/MetalClasses.odin +++ b/vendor/darwin/Metal/MetalClasses.odin @@ -6962,7 +6962,6 @@ Device_newBufferWithBytes :: #force_inline proc(self: ^Device, bytes: []byte, op Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", raw_data(bytes), NS.UInteger(len(bytes)), options, deallocator) } - @(objc_type=Device, objc_name="newBufferWithSlice") Device_newBufferWithSlice :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions) -> ^Buffer { return Device_newBufferWithBytes(self, mem.slice_to_bytes(slice), options) @@ -6971,11 +6970,20 @@ Device_newBufferWithSlice :: #force_inline proc(self: ^Device, slice: $S/[]$E, o Device_newBufferWithSliceNoCopy :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return Device_newBufferWithBytesNotCopy(self, mem.slice_to_bytes(slice), options, deallocator) } - -@(objc_type=Device, objc_name="newBuffer") -Device_newBuffer :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { +@(objc_type=Device, objc_name="newBufferWithLength") +Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) } + +@(objc_type=Device, objc_name="newBuffer") +Device_newBuffer :: proc{ + Device_newBufferWithBytes, + Device_newBufferWithBytesNoCopy, + Device_newBufferWithSlice, + Device_newBufferWithSliceNoCopy, + Device_newBufferWithLength, +} + @(objc_type=Device, objc_name="newCommandQueue") Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^CommandQueue { return msgSend(^CommandQueue, self, "newCommandQueue") @@ -9323,8 +9331,9 @@ Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, devi Texture_newSharedTextureHandle :: #force_inline proc(self: ^Texture) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle") } -@(objc_type=Texture, objc_name="newTextureView") -Texture_newTextureView :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { + +@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat") +Texture_newTextureViewWithPixelFormat :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat) } @(objc_type=Texture, objc_name="newTextureViewWithLevels") @@ -9335,6 +9344,13 @@ Texture_newTextureViewWithLevels :: #force_inline proc(self: ^Texture, pixelForm Texture_newTextureViewWithLevelsAndSwizzle :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) } +@(objc_type=Texture, objc_name="newTextureView") +Texture_newTextureView :: proc{ + Texture_newTextureViewWithPixelFormat, + Texture_newTextureViewWithLevels, + Texture_newTextureViewWithLevelsAndSwizzle, +} + @(objc_type=Texture, objc_name="parentRelativeLevel") Texture_parentRelativeLevel :: #force_inline proc(self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "parentRelativeLevel") From 8f563df7c553732c96dc08b31813c08c63d028de Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 14:59:24 +0100 Subject: [PATCH 056/108] Use `proc "c"` calling convention in NS Foundation package --- vendor/darwin/Foundation/NSApplication.odin | 106 ++++++------ vendor/darwin/Foundation/NSArray.odin | 14 +- .../darwin/Foundation/NSAutoreleasePool.odin | 12 +- vendor/darwin/Foundation/NSBundle.odin | 74 ++++----- vendor/darwin/Foundation/NSData.odin | 8 +- vendor/darwin/Foundation/NSDate.odin | 6 +- vendor/darwin/Foundation/NSDictionary.odin | 18 +- vendor/darwin/Foundation/NSEnumerator.odin | 12 +- vendor/darwin/Foundation/NSError.odin | 22 +-- vendor/darwin/Foundation/NSLock.odin | 20 +-- vendor/darwin/Foundation/NSMenu.odin | 22 +-- vendor/darwin/Foundation/NSNotification.odin | 20 +-- vendor/darwin/Foundation/NSNumber.odin | 108 ++++++------ vendor/darwin/Foundation/NSObject.odin | 28 ++-- vendor/darwin/Foundation/NSOpenPanel.odin | 12 +- vendor/darwin/Foundation/NSRange.odin | 8 +- vendor/darwin/Foundation/NSSavePanel.odin | 2 +- vendor/darwin/Foundation/NSString.odin | 30 ++-- vendor/darwin/Foundation/NSURL.odin | 10 +- vendor/darwin/Foundation/NSUserDefaults.odin | 4 +- vendor/darwin/Foundation/NSWindow.odin | 154 +++++++++--------- vendor/darwin/Foundation/objc.odin | 6 +- 22 files changed, 348 insertions(+), 348 deletions(-) diff --git a/vendor/darwin/Foundation/NSApplication.odin b/vendor/darwin/Foundation/NSApplication.odin index c2d854f4c..48682aef7 100644 --- a/vendor/darwin/Foundation/NSApplication.odin +++ b/vendor/darwin/Foundation/NSApplication.odin @@ -58,38 +58,38 @@ ApplicationPresentationOptionsDisableCursorLocationAssistance :: ApplicationPres Application :: struct {using _: Object} @(objc_type=Application, objc_name="sharedApplication", objc_is_class_method=true) -Application_sharedApplication :: proc() -> ^Application { +Application_sharedApplication :: proc "c" () -> ^Application { return msgSend(^Application, Application, "sharedApplication") } @(objc_type=Application, objc_name="setActivationPolicy") -Application_setActivationPolicy :: proc(self: ^Application, activationPolicy: ActivationPolicy) -> BOOL { +Application_setActivationPolicy :: proc "c" (self: ^Application, activationPolicy: ActivationPolicy) -> BOOL { return msgSend(BOOL, self, "setActivationPolicy:", activationPolicy) } @(objc_type=Application, objc_name="activateIgnoringOtherApps") -Application_activateIgnoringOtherApps :: proc(self: ^Application, ignoreOtherApps: BOOL) { +Application_activateIgnoringOtherApps :: proc "c" (self: ^Application, ignoreOtherApps: BOOL) { msgSend(nil, self, "activateIgnoringOtherApps:", ignoreOtherApps) } @(objc_type=Application, objc_name="setMainMenu") -Application_setMainMenu :: proc(self: ^Application, menu: ^Menu) { +Application_setMainMenu :: proc "c" (self: ^Application, menu: ^Menu) { msgSend(nil, self, "setMainMenu:", menu) } @(objc_type=Application, objc_name="windows") -Application_windows :: proc(self: ^Application) -> ^Array { +Application_windows :: proc "c" (self: ^Application) -> ^Array { return msgSend(^Array, self, "windows") } @(objc_type=Application, objc_name="run") -Application_run :: proc(self: ^Application) { +Application_run :: proc "c" (self: ^Application) { msgSend(nil, self, "run") } @(objc_type=Application, objc_name="terminate") -Application_terminate :: proc(self: ^Application, sender: ^Object) { +Application_terminate :: proc "c" (self: ^Application, sender: ^Object) { msgSend(nil, self, "terminate:", sender) } @@ -99,81 +99,81 @@ Application_terminate :: proc(self: ^Application, sender: ^Object) { RunningApplication :: struct {using _: Object} @(objc_type=RunningApplication, objc_name="currentApplication", objc_is_class_method=true) -RunningApplication_currentApplication :: proc() -> ^RunningApplication { +RunningApplication_currentApplication :: proc "c" () -> ^RunningApplication { return msgSend(^RunningApplication, RunningApplication, "currentApplication") } @(objc_type=RunningApplication, objc_name="localizedName") -RunningApplication_localizedName :: proc(self: ^RunningApplication) -> ^String { +RunningApplication_localizedName :: proc "c" (self: ^RunningApplication) -> ^String { return msgSend(^String, self, "localizedName") } ApplicationDelegateTemplate :: struct { // Launching Applications - applicationWillFinishLaunching: proc(notification: ^Notification), - applicationDidFinishLaunching: proc(notification: ^Notification), + applicationWillFinishLaunching: proc(notification: ^Notification), + applicationDidFinishLaunching: proc(notification: ^Notification), // Managing Active Status - applicationWillBecomeActive: proc(notification: ^Notification), - applicationDidBecomeActive: proc(notification: ^Notification), - applicationWillResignActive: proc(notification: ^Notification), - applicationDidResignActive: proc(notification: ^Notification), + applicationWillBecomeActive: proc(notification: ^Notification), + applicationDidBecomeActive: proc(notification: ^Notification), + applicationWillResignActive: proc(notification: ^Notification), + applicationDidResignActive: proc(notification: ^Notification), // Terminating Applications - applicationShouldTerminate: proc(sender: ^Application) -> ApplicationTerminateReply, - applicationShouldTerminateAfterLastWindowClosed: proc(sender: ^Application) -> BOOL, - applicationWillTerminate: proc(notification: ^Notification), + applicationShouldTerminate: proc(sender: ^Application) -> ApplicationTerminateReply, + applicationShouldTerminateAfterLastWindowClosed: proc(sender: ^Application) -> BOOL, + applicationWillTerminate: proc(notification: ^Notification), // Hiding Applications - applicationWillHide: proc(notification: ^Notification), - applicationDidHide: proc(notification: ^Notification), - applicationWillUnhide: proc(notification: ^Notification), - applicationDidUnhide: proc(notification: ^Notification), + applicationWillHide: proc(notification: ^Notification), + applicationDidHide: proc(notification: ^Notification), + applicationWillUnhide: proc(notification: ^Notification), + applicationDidUnhide: proc(notification: ^Notification), // Managing Windows - applicationWillUpdate: proc(notification: ^Notification), - applicationDidUpdate: proc(notification: ^Notification), - applicationShouldHandleReopenHasVisibleWindows: proc(sender: ^Application, flag: BOOL) -> BOOL, + applicationWillUpdate: proc(notification: ^Notification), + applicationDidUpdate: proc(notification: ^Notification), + applicationShouldHandleReopenHasVisibleWindows: proc(sender: ^Application, flag: BOOL) -> BOOL, // Managing the Dock Menu - applicationDockMenu: proc(sender: ^Application) -> ^Menu, + applicationDockMenu: proc(sender: ^Application) -> ^Menu, // Localizing Keyboard Shortcuts - applicationShouldAutomaticallyLocalizeKeyEquivalents: proc(application: ^Application) -> BOOL, + applicationShouldAutomaticallyLocalizeKeyEquivalents: proc(application: ^Application) -> BOOL, // Displaying Errors - applicationWillPresentError: proc(application: ^Application, error: ^Error) -> ^Error, + applicationWillPresentError: proc(application: ^Application, error: ^Error) -> ^Error, // Managing the Screen - applicationDidChangeScreenParameters: proc(notification: ^Notification), + applicationDidChangeScreenParameters: proc(notification: ^Notification), // Continuing User Activities - applicationWillContinueUserActivityWithType: proc(application: ^Application, userActivityType: ^String) -> BOOL, - applicationContinueUserActivityRestorationHandler: proc(application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> BOOL, - applicationDidFailToContinueUserActivityWithTypeError: proc(application: ^Application, userActivityType: ^String, error: ^Error), - applicationDidUpdateUserActivity: proc(application: ^Application, userActivity: ^UserActivity), + applicationWillContinueUserActivityWithType: proc(application: ^Application, userActivityType: ^String) -> BOOL, + applicationContinueUserActivityRestorationHandler: proc(application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> BOOL, + applicationDidFailToContinueUserActivityWithTypeError: proc(application: ^Application, userActivityType: ^String, error: ^Error), + applicationDidUpdateUserActivity: proc(application: ^Application, userActivity: ^UserActivity), // Handling Push Notifications applicationDidRegisterForRemoteNotificationsWithDeviceToken: proc(application: ^Application, deviceToken: ^Data), applicationDidFailToRegisterForRemoteNotificationsWithError: proc(application: ^Application, error: ^Error), - applicationDidReceiveRemoteNotification: proc(application: ^Application, userInfo: ^Dictionary), + applicationDidReceiveRemoteNotification: proc(application: ^Application, userInfo: ^Dictionary), // Handling CloudKit Invitations // TODO: if/when we have cloud kit bindings implement - // applicationUserDidAcceptCloudKitShareWithMetadata: proc(application: ^Application, metadata: ^CKShareMetadata), + // applicationUserDidAcceptCloudKitShareWithMetadata: proc(application: ^Application, metadata: ^CKShareMetadata), // Handling SiriKit Intents // TODO: if/when we have siri kit bindings implement - // applicationHandlerForIntent: proc(application: ^Application, intent: ^INIntent) -> id, + // applicationHandlerForIntent: proc(application: ^Application, intent: ^INIntent) -> id, // Opening Files - applicationOpenURLs: proc(application: ^Application, urls: ^Array), - applicationOpenFile: proc(sender: ^Application, filename: ^String) -> BOOL, - applicationOpenFileWithoutUI: proc(sender: id, filename: ^String) -> BOOL, - applicationOpenTempFile: proc(sender: ^Application, filename: ^String) -> BOOL, - applicationOpenFiles: proc(sender: ^Application, filenames: ^Array), - applicationShouldOpenUntitledFile: proc(sender: ^Application) -> BOOL, - applicationOpenUntitledFile: proc(sender: ^Application) -> BOOL, + applicationOpenURLs: proc(application: ^Application, urls: ^Array), + applicationOpenFile: proc(sender: ^Application, filename: ^String) -> BOOL, + applicationOpenFileWithoutUI: proc(sender: id, filename: ^String) -> BOOL, + applicationOpenTempFile: proc(sender: ^Application, filename: ^String) -> BOOL, + applicationOpenFiles: proc(sender: ^Application, filenames: ^Array), + applicationShouldOpenUntitledFile: proc(sender: ^Application) -> BOOL, + applicationOpenUntitledFile: proc(sender: ^Application) -> BOOL, // Printing - applicationPrintFile: proc(sender: ^Application, filename: ^String) -> BOOL, - applicationPrintFilesWithSettingsShowPrintPanels: proc(application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: BOOL) -> ApplicationPrintReply, + applicationPrintFile: proc(sender: ^Application, filename: ^String) -> BOOL, + applicationPrintFilesWithSettingsShowPrintPanels: proc(application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: BOOL) -> ApplicationPrintReply, // Restoring Application State - applicationSupportsSecureRestorableState: proc(app: ^Application) -> BOOL, - applicationProtectedDataDidBecomeAvailable: proc(notification: ^Notification), - applicationProtectedDataWillBecomeUnavailable: proc(notification: ^Notification), - applicationWillEncodeRestorableState: proc(app: ^Application, coder: ^Coder), - applicationDidDecodeRestorableState: proc(app: ^Application, coder: ^Coder), + applicationSupportsSecureRestorableState: proc(app: ^Application) -> BOOL, + applicationProtectedDataDidBecomeAvailable: proc(notification: ^Notification), + applicationProtectedDataWillBecomeUnavailable: proc(notification: ^Notification), + applicationWillEncodeRestorableState: proc(app: ^Application, coder: ^Coder), + applicationDidDecodeRestorableState: proc(app: ^Application, coder: ^Coder), // Handling Changes to the Occlusion State - applicationDidChangeOcclusionState: proc(notification: ^Notification), + applicationDidChangeOcclusionState: proc(notification: ^Notification), // Scripting Your App - applicationDelegateHandlesKey: proc(sender: ^Application, key: ^String) -> BOOL, + applicationDelegateHandlesKey: proc(sender: ^Application, key: ^String) -> BOOL, } ApplicationDelegate :: struct { using _: Object } @@ -559,6 +559,6 @@ application_delegate_register_and_alloc :: proc(template: ApplicationDelegateTem } @(objc_type=Application, objc_name="setDelegate") -Application_setDelegate :: proc(self: ^Application, delegate: ^ApplicationDelegate) { +Application_setDelegate :: proc "c" (self: ^Application, delegate: ^ApplicationDelegate) { msgSend(nil, self, "setDelegate:", delegate) } diff --git a/vendor/darwin/Foundation/NSArray.odin b/vendor/darwin/Foundation/NSArray.odin index d6021838b..3e6520c0d 100644 --- a/vendor/darwin/Foundation/NSArray.odin +++ b/vendor/darwin/Foundation/NSArray.odin @@ -8,35 +8,35 @@ Array :: struct { } @(objc_type=Array, objc_name="alloc", objc_is_class_method=true) -Array_alloc :: proc() -> ^Array { +Array_alloc :: proc "c" () -> ^Array { return msgSend(^Array, Array, "alloc") } @(objc_type=Array, objc_name="init") -Array_init :: proc(self: ^Array) -> ^Array { +Array_init :: proc "c" (self: ^Array) -> ^Array { return msgSend(^Array, self, "init") } @(objc_type=Array, objc_name="initWithObjects") -Array_initWithObjects :: proc(self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array { +Array_initWithObjects :: proc "c" (self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array { return msgSend(^Array, self, "initWithObjects:count:", objects, count) } @(objc_type=Array, objc_name="initWithCoder") -Array_initWithCoder :: proc(self: ^Array, coder: ^Coder) -> ^Array { +Array_initWithCoder :: proc "c" (self: ^Array, coder: ^Coder) -> ^Array { return msgSend(^Array, self, "initWithCoder:", coder) } @(objc_type=Array, objc_name="object") -Array_object :: proc(self: ^Array, index: UInteger) -> ^Object { +Array_object :: proc "c" (self: ^Array, index: UInteger) -> ^Object { return msgSend(^Object, self, "objectAtIndex:", index) } @(objc_type=Array, objc_name="objectAs") -Array_objectAs :: proc(self: ^Array, index: UInteger, $T: typeid) -> T where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { +Array_objectAs :: proc "c" (self: ^Array, index: UInteger, $T: typeid) -> T where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { return (T)(Array_object(self, index)) } @(objc_type=Array, objc_name="count") -Array_count :: proc(self: ^Array) -> UInteger { +Array_count :: proc "c" (self: ^Array) -> UInteger { return msgSend(UInteger, self, "count") } diff --git a/vendor/darwin/Foundation/NSAutoreleasePool.odin b/vendor/darwin/Foundation/NSAutoreleasePool.odin index a388a7146..8eb3657b6 100644 --- a/vendor/darwin/Foundation/NSAutoreleasePool.odin +++ b/vendor/darwin/Foundation/NSAutoreleasePool.odin @@ -4,30 +4,30 @@ package objc_Foundation AutoreleasePool :: struct {using _: Object} @(objc_type=AutoreleasePool, objc_name="alloc", objc_is_class_method=true) -AutoreleasePool_alloc :: proc() -> ^AutoreleasePool { +AutoreleasePool_alloc :: proc "c" () -> ^AutoreleasePool { return msgSend(^AutoreleasePool, AutoreleasePool, "alloc") } @(objc_type=AutoreleasePool, objc_name="init") -AutoreleasePool_init :: proc(self: ^AutoreleasePool) -> ^AutoreleasePool { +AutoreleasePool_init :: proc "c" (self: ^AutoreleasePool) -> ^AutoreleasePool { return msgSend(^AutoreleasePool, self, "init") } @(objc_type=AutoreleasePool, objc_name="drain") -AutoreleasePool_drain :: proc(self: ^AutoreleasePool) { +AutoreleasePool_drain :: proc "c" (self: ^AutoreleasePool) { msgSend(nil, self, "drain") } @(objc_type=AutoreleasePool, objc_name="addObject") -AutoreleasePool_addObject :: proc(self: ^AutoreleasePool, obj: ^Object) { +AutoreleasePool_addObject :: proc "c" (self: ^AutoreleasePool, obj: ^Object) { msgSend(nil, self, "addObject:", obj) } @(objc_type=AutoreleasePool, objc_name="showPools") -AutoreleasePool_showPools :: proc(self: ^AutoreleasePool, obj: ^Object) { +AutoreleasePool_showPools :: proc "c" (self: ^AutoreleasePool, obj: ^Object) { msgSend(nil, self, "showPools") } @(deferred_out=AutoreleasePool_drain) -scoped_autoreleasepool :: proc() -> ^AutoreleasePool { +scoped_autoreleasepool :: proc "c" () -> ^AutoreleasePool { return AutoreleasePool.alloc()->init() } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSBundle.odin b/vendor/darwin/Foundation/NSBundle.odin index 5e136378b..25fc8df32 100644 --- a/vendor/darwin/Foundation/NSBundle.odin +++ b/vendor/darwin/Foundation/NSBundle.odin @@ -4,188 +4,188 @@ package objc_Foundation Bundle :: struct { using _: Object } @(objc_type=Bundle, objc_name="mainBundle", objc_is_class_method=true) -Bundle_mainBundle :: proc() -> ^Bundle { +Bundle_mainBundle :: proc "c" () -> ^Bundle { return msgSend(^Bundle, Bundle, "mainBundle") } @(objc_type=Bundle, objc_name="bundleWithPath", objc_is_class_method=true) -Bundle_bundleWithPath :: proc(path: ^String) -> ^Bundle { +Bundle_bundleWithPath :: proc "c" (path: ^String) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithPath:", path) } @(objc_type=Bundle, objc_name="bundleWithURL", objc_is_class_method=true) -Bundle_bundleWithURL :: proc(url: ^URL) -> ^Bundle { +Bundle_bundleWithURL :: proc "c" (url: ^URL) -> ^Bundle { return msgSend(^Bundle, Bundle, "bundleWithUrl:", url) } @(objc_type=Bundle, objc_name="alloc", objc_is_class_method=true) -Bundle_alloc :: proc() -> ^Bundle { +Bundle_alloc :: proc "c" () -> ^Bundle { return msgSend(^Bundle, Bundle, "alloc") } @(objc_type=Bundle, objc_name="init") -Bundle_init :: proc(self: ^Bundle) -> ^Bundle { +Bundle_init :: proc "c" (self: ^Bundle) -> ^Bundle { return msgSend(^Bundle, self, "init") } @(objc_type=Bundle, objc_name="initWithPath") -Bundle_initWithPath :: proc(self: ^Bundle, path: ^String) -> ^Bundle { +Bundle_initWithPath :: proc "c" (self: ^Bundle, path: ^String) -> ^Bundle { return msgSend(^Bundle, self, "initWithPath:", path) } @(objc_type=Bundle, objc_name="initWithURL") -Bundle_initWithURL :: proc(self: ^Bundle, url: ^URL) -> ^Bundle { +Bundle_initWithURL :: proc "c" (self: ^Bundle, url: ^URL) -> ^Bundle { return msgSend(^Bundle, self, "initWithUrl:", url) } @(objc_type=Bundle, objc_name="allBundles") -Bundle_allBundles :: proc() -> (all: ^Array) { +Bundle_allBundles :: proc "c" () -> (all: ^Array) { return msgSend(type_of(all), Bundle, "allBundles") } @(objc_type=Bundle, objc_name="allFrameworks") -Bundle_allFrameworks :: proc() -> (all: ^Array) { +Bundle_allFrameworks :: proc "c" () -> (all: ^Array) { return msgSend(type_of(all), Bundle, "allFrameworks") } @(objc_type=Bundle, objc_name="load") -Bundle_load :: proc(self: ^Bundle) -> BOOL { +Bundle_load :: proc "c" (self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "load") } @(objc_type=Bundle, objc_name="unload") -Bundle_unload :: proc(self: ^Bundle) -> BOOL { +Bundle_unload :: proc "c" (self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "unload") } @(objc_type=Bundle, objc_name="isLoaded") -Bundle_isLoaded :: proc(self: ^Bundle) -> BOOL { +Bundle_isLoaded :: proc "c" (self: ^Bundle) -> BOOL { return msgSend(BOOL, self, "isLoaded") } @(objc_type=Bundle, objc_name="preflightAndReturnError") -Bundle_preflightAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { +Bundle_preflightAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: BOOL, error: ^Error) { ok = msgSend(BOOL, self, "preflightAndReturnError:", &error) return } @(objc_type=Bundle, objc_name="loadAndReturnError") -Bundle_loadAndReturnError :: proc(self: ^Bundle) -> (ok: BOOL, error: ^Error) { +Bundle_loadAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: BOOL, error: ^Error) { ok = msgSend(BOOL, self, "loadAndReturnError:", &error) return } @(objc_type=Bundle, objc_name="bundleURL") -Bundle_bundleURL :: proc(self: ^Bundle) -> ^URL { +Bundle_bundleURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "bundleURL") } @(objc_type=Bundle, objc_name="resourceURL") -Bundle_resourceURL :: proc(self: ^Bundle) -> ^URL { +Bundle_resourceURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "resourceURL") } @(objc_type=Bundle, objc_name="executableURL") -Bundle_executableURL :: proc(self: ^Bundle) -> ^URL { +Bundle_executableURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "executableURL") } @(objc_type=Bundle, objc_name="URLForAuxiliaryExecutable") -Bundle_URLForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^URL { +Bundle_URLForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^URL { return msgSend(^URL, self, "URLForAuxiliaryExecutable:", executableName) } @(objc_type=Bundle, objc_name="privateFrameworksURL") -Bundle_privateFrameworksURL :: proc(self: ^Bundle) -> ^URL { +Bundle_privateFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "privateFrameworksURL") } @(objc_type=Bundle, objc_name="sharedFrameworksURL") -Bundle_sharedFrameworksURL :: proc(self: ^Bundle) -> ^URL { +Bundle_sharedFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedFrameworksURL") } @(objc_type=Bundle, objc_name="sharedSupportURL") -Bundle_sharedSupportURL :: proc(self: ^Bundle) -> ^URL { +Bundle_sharedSupportURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "sharedSupportURL") } @(objc_type=Bundle, objc_name="builtInPlugInsURL") -Bundle_builtInPlugInsURL :: proc(self: ^Bundle) -> ^URL { +Bundle_builtInPlugInsURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "builtInPlugInsURL") } @(objc_type=Bundle, objc_name="appStoreReceiptURL") -Bundle_appStoreReceiptURL :: proc(self: ^Bundle) -> ^URL { +Bundle_appStoreReceiptURL :: proc "c" (self: ^Bundle) -> ^URL { return msgSend(^URL, self, "appStoreReceiptURL") } @(objc_type=Bundle, objc_name="bundlePath") -Bundle_bundlePath :: proc(self: ^Bundle) -> ^String { +Bundle_bundlePath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "bundlePath") } @(objc_type=Bundle, objc_name="resourcePath") -Bundle_resourcePath :: proc(self: ^Bundle) -> ^String { +Bundle_resourcePath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "resourcePath") } @(objc_type=Bundle, objc_name="executablePath") -Bundle_executablePath :: proc(self: ^Bundle) -> ^String { +Bundle_executablePath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "executablePath") } @(objc_type=Bundle, objc_name="PathForAuxiliaryExecutable") -Bundle_PathForAuxiliaryExecutable :: proc(self: ^Bundle, executableName: ^String) -> ^String { +Bundle_PathForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^String { return msgSend(^String, self, "PathForAuxiliaryExecutable:", executableName) } @(objc_type=Bundle, objc_name="privateFrameworksPath") -Bundle_privateFrameworksPath :: proc(self: ^Bundle) -> ^String { +Bundle_privateFrameworksPath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "privateFrameworksPath") } @(objc_type=Bundle, objc_name="sharedFrameworksPath") -Bundle_sharedFrameworksPath :: proc(self: ^Bundle) -> ^String { +Bundle_sharedFrameworksPath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedFrameworksPath") } @(objc_type=Bundle, objc_name="sharedSupportPath") -Bundle_sharedSupportPath :: proc(self: ^Bundle) -> ^String { +Bundle_sharedSupportPath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "sharedSupportPath") } @(objc_type=Bundle, objc_name="builtInPlugInsPath") -Bundle_builtInPlugInsPath :: proc(self: ^Bundle) -> ^String { +Bundle_builtInPlugInsPath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "builtInPlugInsPath") } @(objc_type=Bundle, objc_name="appStoreReceiptPath") -Bundle_appStoreReceiptPath :: proc(self: ^Bundle) -> ^String { +Bundle_appStoreReceiptPath :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "appStoreReceiptPath") } @(objc_type=Bundle, objc_name="bundleIdentifier") -Bundle_bundleIdentifier :: proc(self: ^Bundle) -> ^String { +Bundle_bundleIdentifier :: proc "c" (self: ^Bundle) -> ^String { return msgSend(^String, self, "bundleIdentifier") } @(objc_type=Bundle, objc_name="infoDictionary") -Bundle_infoDictionary :: proc(self: ^Bundle) -> ^Dictionary { +Bundle_infoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary { return msgSend(^Dictionary, self, "infoDictionary") } @(objc_type=Bundle, objc_name="localizedInfoDictionary") -Bundle_localizedInfoDictionary :: proc(self: ^Bundle) -> ^Dictionary { +Bundle_localizedInfoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary { return msgSend(^Dictionary, self, "localizedInfoDictionary") } @(objc_type=Bundle, objc_name="objectForInfoDictionaryKey") -Bundle_objectForInfoDictionaryKey :: proc(self: ^Bundle, key: ^String) -> ^Object { +Bundle_objectForInfoDictionaryKey :: proc "c" (self: ^Bundle, key: ^String) -> ^Object { return msgSend(^Object, self, "objectForInfoDictionaryKey:", key) } @(objc_type=Bundle, objc_name="localizedStringForKey") -Bundle_localizedStringForKey :: proc(self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String { +Bundle_localizedStringForKey :: proc "c" (self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String { return msgSend(^String, self, "localizedStringForKey:value:table:", key, value, tableName) } diff --git a/vendor/darwin/Foundation/NSData.odin b/vendor/darwin/Foundation/NSData.odin index 3c6369e86..04c1ce25d 100644 --- a/vendor/darwin/Foundation/NSData.odin +++ b/vendor/darwin/Foundation/NSData.odin @@ -4,21 +4,21 @@ package objc_Foundation Data :: struct {using _: Copying(Data)} @(objc_type=Data, objc_name="alloc", objc_is_class_method=true) -Data_alloc :: proc() -> ^Data { +Data_alloc :: proc "c" () -> ^Data { return msgSend(^Data, Data, "alloc") } @(objc_type=Data, objc_name="init") -Data_init :: proc(self: ^Data) -> ^Data { +Data_init :: proc "c" (self: ^Data) -> ^Data { return msgSend(^Data, self, "init") } @(objc_type=Data, objc_name="mutableBytes") -Data_mutableBytes :: proc(self: ^Data) -> rawptr { +Data_mutableBytes :: proc "c" (self: ^Data) -> rawptr { return msgSend(rawptr, self, "mutableBytes") } @(objc_type=Data, objc_name="length") -Data_length :: proc(self: ^Data) -> UInteger { +Data_length :: proc "c" (self: ^Data) -> UInteger { return msgSend(UInteger, self, "length") } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSDate.odin b/vendor/darwin/Foundation/NSDate.odin index e30cb07d0..f8096c698 100644 --- a/vendor/darwin/Foundation/NSDate.odin +++ b/vendor/darwin/Foundation/NSDate.odin @@ -4,16 +4,16 @@ package objc_Foundation Date :: struct {using _: Copying(Date)} @(objc_type=Date, objc_name="alloc", objc_is_class_method=true) -Date_alloc :: proc() -> ^Date { +Date_alloc :: proc "c" () -> ^Date { return msgSend(^Date, Date, "alloc") } @(objc_type=Date, objc_name="init") -Date_init :: proc(self: ^Date) -> ^Date { +Date_init :: proc "c" (self: ^Date) -> ^Date { return msgSend(^Date, self, "init") } @(objc_type=Date, objc_name="dateWithTimeIntervalSinceNow") -Date_dateWithTimeIntervalSinceNow :: proc(secs: TimeInterval) -> ^Date { +Date_dateWithTimeIntervalSinceNow :: proc "c" (secs: TimeInterval) -> ^Date { return msgSend(^Date, Date, "dateWithTimeIntervalSinceNow:", secs) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSDictionary.odin b/vendor/darwin/Foundation/NSDictionary.odin index 3832c05f1..8af58cf62 100644 --- a/vendor/darwin/Foundation/NSDictionary.odin +++ b/vendor/darwin/Foundation/NSDictionary.odin @@ -4,47 +4,47 @@ package objc_Foundation Dictionary :: struct {using _: Copying(Dictionary)} @(objc_type=Dictionary, objc_name="dictionary", objc_is_class_method=true) -Dictionary_dictionary :: proc() -> ^Dictionary { +Dictionary_dictionary :: proc "c" () -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionary") } @(objc_type=Dictionary, objc_name="dictionaryWithObject", objc_is_class_method=true) -Dictionary_dictionaryWithObject :: proc(object: ^Object, forKey: ^Object) -> ^Dictionary { +Dictionary_dictionaryWithObject :: proc "c" (object: ^Object, forKey: ^Object) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObject:forKey:", object, forKey) } @(objc_type=Dictionary, objc_name="dictionaryWithObjects", objc_is_class_method=true) -Dictionary_dictionaryWithObjects :: proc(objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { +Dictionary_dictionaryWithObjects :: proc "c" (objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "dictionaryWithObjects:forKeys:count", objects, forKeys, count) } @(objc_type=Dictionary, objc_name="alloc", objc_is_class_method=true) -Dictionary_alloc :: proc() -> ^Dictionary { +Dictionary_alloc :: proc "c" () -> ^Dictionary { return msgSend(^Dictionary, Dictionary, "alloc") } @(objc_type=Dictionary, objc_name="init") -Dictionary_init :: proc(self: ^Dictionary) -> ^Dictionary { +Dictionary_init :: proc "c" (self: ^Dictionary) -> ^Dictionary { return msgSend(^Dictionary, self, "init") } @(objc_type=Dictionary, objc_name="initWithObjects") -Dictionary_initWithObjects :: proc(self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { +Dictionary_initWithObjects :: proc "c" (self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary { return msgSend(^Dictionary, self, "initWithObjects:forKeys:count", objects, forKeys, count) } @(objc_type=Dictionary, objc_name="objectForKey") -Dictionary_objectForKey :: proc(self: ^Dictionary, key: ^Object) -> ^Object { +Dictionary_objectForKey :: proc "c" (self: ^Dictionary, key: ^Object) -> ^Object { return msgSend(^Dictionary, self, "objectForKey:", key) } @(objc_type=Dictionary, objc_name="count") -Dictionary_count :: proc(self: ^Dictionary) -> UInteger { +Dictionary_count :: proc "c" (self: ^Dictionary) -> UInteger { return msgSend(UInteger, self, "count") } @(objc_type=Dictionary, objc_name="keyEnumerator") -Dictionary_keyEnumerator :: proc(self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) { +Dictionary_keyEnumerator :: proc "c" (self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) { return msgSend(type_of(enumerator), self, "keyEnumerator") } diff --git a/vendor/darwin/Foundation/NSEnumerator.odin b/vendor/darwin/Foundation/NSEnumerator.odin index 1c7ddeed2..555e58141 100644 --- a/vendor/darwin/Foundation/NSEnumerator.odin +++ b/vendor/darwin/Foundation/NSEnumerator.odin @@ -20,30 +20,30 @@ Enumerator :: struct($T: typeid) where intrinsics.type_is_pointer(T), intrinsics @(objc_type=FastEnumeration, objc_name="alloc", objc_is_class_method=true) -FastEnumeration_alloc :: proc() -> ^FastEnumeration { +FastEnumeration_alloc :: proc "c" () -> ^FastEnumeration { return msgSend(^FastEnumeration, FastEnumeration, "alloc") } @(objc_type=FastEnumeration, objc_name="init") -FastEnumeration_init :: proc(self: ^FastEnumeration) -> ^FastEnumeration { +FastEnumeration_init :: proc "c" (self: ^FastEnumeration) -> ^FastEnumeration { return msgSend(^FastEnumeration, self, "init") } @(objc_type=FastEnumeration, objc_name="countByEnumerating") -FastEnumeration_countByEnumerating :: proc(self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger { +FastEnumeration_countByEnumerating :: proc "c" (self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger { return msgSend(UInteger, self, "countByEnumeratingWithState:objects:count:", state, buffer, len) } -Enumerator_nextObject :: proc(self: ^$E/Enumerator($T)) -> T { +Enumerator_nextObject :: proc "c" (self: ^$E/Enumerator($T)) -> T { return msgSend(T, self, "nextObject") } -Enumerator_allObjects :: proc(self: ^$E/Enumerator($T)) -> (all: ^Array) { +Enumerator_allObjects :: proc "c" (self: ^$E/Enumerator($T)) -> (all: ^Array) { return msgSend(type_of(all), self, "allObjects") } -Enumerator_iterator :: proc(self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) { +Enumerator_iterator :: proc "contextless" (self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) { obj = msgSend(T, self, "nextObject") ok = obj != nil return diff --git a/vendor/darwin/Foundation/NSError.odin b/vendor/darwin/Foundation/NSError.odin index 23e6eaba7..1657befe2 100644 --- a/vendor/darwin/Foundation/NSError.odin +++ b/vendor/darwin/Foundation/NSError.odin @@ -33,56 +33,56 @@ Error :: struct { using _: Copying(Error) } @(objc_type=Error, objc_name="alloc", objc_is_class_method=true) -Error_alloc :: proc() -> ^Error { +Error_alloc :: proc "c" () -> ^Error { return msgSend(^Error, Error, "alloc") } @(objc_type=Error, objc_name="init") -Error_init :: proc(self: ^Error) -> ^Error { +Error_init :: proc "c" (self: ^Error) -> ^Error { return msgSend(^Error, self, "init") } @(objc_type=Error, objc_name="errorWithDomain", objc_is_class_method=true) -Error_errorWithDomain :: proc(domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { +Error_errorWithDomain :: proc "c" (domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { return msgSend(^Error, Error, "errorWithDomain:code:userInfo:", domain, code, userInfo) } @(objc_type=Error, objc_name="initWithDomain") -Error_initWithDomain :: proc(self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { +Error_initWithDomain :: proc "c" (self: ^Error, domain: ErrorDomain, code: Integer, userInfo: ^Dictionary) -> ^Error { return msgSend(^Error, self, "initWithDomain:code:userInfo:", domain, code, userInfo) } @(objc_type=Error, objc_name="code") -Error_code :: proc(self: ^Error) -> Integer { +Error_code :: proc "c" (self: ^Error) -> Integer { return msgSend(Integer, self, "code") } @(objc_type=Error, objc_name="domain") -Error_domain :: proc(self: ^Error) -> ErrorDomain { +Error_domain :: proc "c" (self: ^Error) -> ErrorDomain { return msgSend(ErrorDomain, self, "domain") } @(objc_type=Error, objc_name="userInfo") -Error_userInfo :: proc(self: ^Error) -> ^Dictionary { +Error_userInfo :: proc "c" (self: ^Error) -> ^Dictionary { return msgSend(^Dictionary, self, "userInfo") } @(objc_type=Error, objc_name="localizedDescription") -Error_localizedDescription :: proc(self: ^Error) -> ^String { +Error_localizedDescription :: proc "c" (self: ^Error) -> ^String { return msgSend(^String, self, "localizedDescription") } @(objc_type=Error, objc_name="localizedRecoveryOptions") -Error_localizedRecoveryOptions :: proc(self: ^Error) -> (options: ^Array) { +Error_localizedRecoveryOptions :: proc "c" (self: ^Error) -> (options: ^Array) { return msgSend(type_of(options), self, "localizedRecoveryOptions") } @(objc_type=Error, objc_name="localizedRecoverySuggestion") -Error_localizedRecoverySuggestion :: proc(self: ^Error) -> ^String { +Error_localizedRecoverySuggestion :: proc "c" (self: ^Error) -> ^String { return msgSend(^String, self, "localizedRecoverySuggestion") } @(objc_type=Error, objc_name="localizedFailureReason") -Error_localizedFailureReason :: proc(self: ^Error) -> ^String { +Error_localizedFailureReason :: proc "c" (self: ^Error) -> ^String { return msgSend(^String, self, "localizedFailureReason") } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSLock.odin b/vendor/darwin/Foundation/NSLock.odin index c48b5dbad..168380669 100644 --- a/vendor/darwin/Foundation/NSLock.odin +++ b/vendor/darwin/Foundation/NSLock.odin @@ -2,10 +2,10 @@ package objc_Foundation Locking :: struct($T: typeid) {using _: Object} -Locking_lock :: proc(self: ^Locking($T)) { +Locking_lock :: proc "c" (self: ^Locking($T)) { msgSend(nil, self, "lock") } -Locking_unlock :: proc(self: ^Locking($T)) { +Locking_unlock :: proc "c" (self: ^Locking($T)) { msgSend(nil, self, "unlock") } @@ -14,40 +14,40 @@ Condition :: struct {using _: Locking(Condition) } @(objc_type=Condition, objc_name="alloc", objc_is_class_method=true) -Condition_alloc :: proc() -> ^Condition { +Condition_alloc :: proc "c" () -> ^Condition { return msgSend(^Condition, Condition, "alloc") } @(objc_type=Condition, objc_name="init") -Condition_init :: proc(self: ^Condition) -> ^Condition { +Condition_init :: proc "c" (self: ^Condition) -> ^Condition { return msgSend(^Condition, self, "init") } @(objc_type=Condition, objc_name="wait") -Condition_wait :: proc(self: ^Condition) { +Condition_wait :: proc "c" (self: ^Condition) { msgSend(nil, self, "wait") } @(objc_type=Condition, objc_name="waitUntilDate") -Condition_waitUntilDate :: proc(self: ^Condition, limit: ^Date) -> BOOL { +Condition_waitUntilDate :: proc "c" (self: ^Condition, limit: ^Date) -> BOOL { return msgSend(BOOL, self, "waitUntilDate:", limit) } @(objc_type=Condition, objc_name="signal") -Condition_signal :: proc(self: ^Condition) { +Condition_signal :: proc "c" (self: ^Condition) { msgSend(nil, self, "signal") } @(objc_type=Condition, objc_name="broadcast") -Condition_broadcast :: proc(self: ^Condition) { +Condition_broadcast :: proc "c" (self: ^Condition) { msgSend(nil, self, "broadcast") } @(objc_type=Condition, objc_name="lock") -Condition_lock :: proc(self: ^Condition) { +Condition_lock :: proc "c" (self: ^Condition) { msgSend(nil, self, "lock") } @(objc_type=Condition, objc_name="unlock") -Condition_unlock :: proc(self: ^Condition) { +Condition_unlock :: proc "c" (self: ^Condition) { msgSend(nil, self, "unlock") } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSMenu.odin b/vendor/darwin/Foundation/NSMenu.odin index 964e3061d..6ed9b9918 100644 --- a/vendor/darwin/Foundation/NSMenu.odin +++ b/vendor/darwin/Foundation/NSMenu.odin @@ -27,11 +27,11 @@ MenuItemCallback :: proc "c" (unused: rawptr, name: SEL, sender: ^Object) MenuItem :: struct {using _: Object} @(objc_type=MenuItem, objc_name="alloc", objc_is_class_method=true) -MenuItem_alloc :: proc() -> ^MenuItem { +MenuItem_alloc :: proc "c" () -> ^MenuItem { return msgSend(^MenuItem, MenuItem, "alloc") } @(objc_type=MenuItem, objc_name="registerActionCallback", objc_is_class_method=true) -MenuItem_registerActionCallback :: proc(name: cstring, callback: MenuItemCallback) -> SEL { +MenuItem_registerActionCallback :: proc "c" (name: cstring, callback: MenuItemCallback) -> SEL { s := string(name) n := len(s) sel: SEL @@ -51,22 +51,22 @@ MenuItem_registerActionCallback :: proc(name: cstring, callback: MenuItemCallbac } @(objc_type=MenuItem, objc_name="init") -MenuItem_init :: proc(self: ^MenuItem) -> ^MenuItem { +MenuItem_init :: proc "c" (self: ^MenuItem) -> ^MenuItem { return msgSend(^MenuItem, self, "init") } @(objc_type=MenuItem, objc_name="setKeyEquivalentModifierMask") -MenuItem_setKeyEquivalentModifierMask :: proc(self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) { +MenuItem_setKeyEquivalentModifierMask :: proc "c" (self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) { msgSend(nil, self, "setKeyEquivalentModifierMask:", modifierMask) } @(objc_type=MenuItem, objc_name="keyEquivalentModifierMask") -MenuItem_keyEquivalentModifierMask :: proc(self: ^MenuItem) -> KeyEquivalentModifierMask { +MenuItem_keyEquivalentModifierMask :: proc "c" (self: ^MenuItem) -> KeyEquivalentModifierMask { return msgSend(KeyEquivalentModifierMask, self, "keyEquivalentModifierMask") } @(objc_type=MenuItem, objc_name="setSubmenu") -MenuItem_setSubmenu :: proc(self: ^MenuItem, submenu: ^Menu) { +MenuItem_setSubmenu :: proc "c" (self: ^MenuItem, submenu: ^Menu) { msgSend(nil, self, "setSubmenu:", submenu) } @@ -77,27 +77,27 @@ MenuItem_setSubmenu :: proc(self: ^MenuItem, submenu: ^Menu) { Menu :: struct {using _: Object} @(objc_type=Menu, objc_name="alloc", objc_is_class_method=true) -Menu_alloc :: proc() -> ^Menu { +Menu_alloc :: proc "c" () -> ^Menu { return msgSend(^Menu, Menu, "alloc") } @(objc_type=Menu, objc_name="init") -Menu_init :: proc(self: ^Menu) -> ^Menu { +Menu_init :: proc "c" (self: ^Menu) -> ^Menu { return msgSend(^Menu, self, "init") } @(objc_type=Menu, objc_name="initWithTitle") -Menu_initWithTitle :: proc(self: ^Menu, title: ^String) -> ^Menu { +Menu_initWithTitle :: proc "c" (self: ^Menu, title: ^String) -> ^Menu { return msgSend(^Menu, self, "initWithTitle:", title) } @(objc_type=Menu, objc_name="addItem") -Menu_addItem :: proc(self: ^Menu, item: ^MenuItem) { +Menu_addItem :: proc "c" (self: ^Menu, item: ^MenuItem) { msgSend(nil, self, "addItem:", item) } @(objc_type=Menu, objc_name="addItemWithTitle") -Menu_addItemWithTitle :: proc(self: ^Menu, title: ^String, selector: SEL, keyEquivalent: ^String) -> ^MenuItem { +Menu_addItemWithTitle :: proc "c" (self: ^Menu, title: ^String, selector: SEL, keyEquivalent: ^String) -> ^MenuItem { return msgSend(^MenuItem, self, "addItemWithTitle:action:keyEquivalent:", title, selector, keyEquivalent) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSNotification.odin b/vendor/darwin/Foundation/NSNotification.odin index 13718c024..f766d0cab 100644 --- a/vendor/darwin/Foundation/NSNotification.odin +++ b/vendor/darwin/Foundation/NSNotification.odin @@ -5,27 +5,27 @@ Notification :: struct{using _: Object} @(objc_type=Notification, objc_name="alloc", objc_is_class_method=true) -Notification_alloc :: proc() -> ^Notification { +Notification_alloc :: proc "c" () -> ^Notification { return msgSend(^Notification, Notification, "alloc") } @(objc_type=Notification, objc_name="init") -Notification_init :: proc(self: ^Notification) -> ^Notification { +Notification_init :: proc "c" (self: ^Notification) -> ^Notification { return msgSend(^Notification, self, "init") } @(objc_type=Notification, objc_name="name") -Notification_name :: proc(self: ^Notification) -> ^String { +Notification_name :: proc "c" (self: ^Notification) -> ^String { return msgSend(^String, self, "name") } @(objc_type=Notification, objc_name="object") -Notification_object :: proc(self: ^Notification) -> ^Object { +Notification_object :: proc "c" (self: ^Notification) -> ^Object { return msgSend(^Object, self, "object") } @(objc_type=Notification, objc_name="userInfo") -Notification_userInfo :: proc(self: ^Notification) -> ^Dictionary { +Notification_userInfo :: proc "c" (self: ^Notification) -> ^Dictionary { return msgSend(^Dictionary, self, "userInfo") } @@ -36,25 +36,25 @@ NotificationCenter :: struct{using _: Object} @(objc_type=NotificationCenter, objc_name="alloc", objc_is_class_method=true) -NotificationCenter_alloc :: proc() -> ^NotificationCenter { +NotificationCenter_alloc :: proc "c" () -> ^NotificationCenter { return msgSend(^NotificationCenter, NotificationCenter, "alloc") } @(objc_type=NotificationCenter, objc_name="init") -NotificationCenter_init :: proc(self: ^NotificationCenter) -> ^NotificationCenter { +NotificationCenter_init :: proc "c" (self: ^NotificationCenter) -> ^NotificationCenter { return msgSend(^NotificationCenter, self, "init") } @(objc_type=NotificationCenter, objc_name="defaultCenter", objc_is_class_method=true) -NotificationCenter_defaultCenter :: proc() -> ^NotificationCenter { +NotificationCenter_defaultCenter :: proc "c" () -> ^NotificationCenter { return msgSend(^NotificationCenter, NotificationCenter, "defaultCenter") } @(objc_type=NotificationCenter, objc_name="addObserver") -NotificationCenter_addObserverName :: proc(self: ^NotificationCenter, name: NotificationName, pObj: ^Object, pQueue: rawptr, block: ^Block) -> ^Object { +NotificationCenter_addObserverName :: proc "c" (self: ^NotificationCenter, name: NotificationName, pObj: ^Object, pQueue: rawptr, block: ^Block) -> ^Object { return msgSend(^Object, self, "addObserverName:object:queue:block:", name, pObj, pQueue, block) } @(objc_type=NotificationCenter, objc_name="removeObserver") -NotificationCenter_removeObserver :: proc(self: ^NotificationCenter, pObserver: ^Object) { +NotificationCenter_removeObserver :: proc "c" (self: ^NotificationCenter, pObserver: ^Object) { msgSend(nil, self, "removeObserver:", pObserver) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSNumber.odin b/vendor/darwin/Foundation/NSNumber.odin index d459e673f..ce31e30dc 100644 --- a/vendor/darwin/Foundation/NSNumber.odin +++ b/vendor/darwin/Foundation/NSNumber.odin @@ -12,37 +12,37 @@ when ODIN_OS == .Darwin { Value :: struct{using _: Copying(Value)} @(objc_type=Value, objc_name="alloc", objc_is_class_method=true) -Value_alloc :: proc() -> ^Value { +Value_alloc :: proc "c" () -> ^Value { return msgSend(^Value, Value, "alloc") } @(objc_type=Value, objc_name="init") -Value_init :: proc(self: ^Value) -> ^Value { +Value_init :: proc "c" (self: ^Value) -> ^Value { return msgSend(^Value, self, "init") } @(objc_type=Value, objc_name="valueWithBytes", objc_is_class_method=true) -Value_valueWithBytes :: proc(value: rawptr, type: cstring) -> ^Value { +Value_valueWithBytes :: proc "c" (value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, Value, "valueWithBytes:objCType:", value, type) } @(objc_type=Value, objc_name="valueWithPointer", objc_is_class_method=true) -Value_valueWithPointer :: proc(pointer: rawptr) -> ^Value { +Value_valueWithPointer :: proc "c" (pointer: rawptr) -> ^Value { return msgSend(^Value, Value, "valueWithPointer:", pointer) } @(objc_type=Value, objc_name="initWithBytes") -Value_initWithBytes :: proc(self: ^Value, value: rawptr, type: cstring) -> ^Value { +Value_initWithBytes :: proc "c" (self: ^Value, value: rawptr, type: cstring) -> ^Value { return msgSend(^Value, self, "initWithBytes:objCType:", value, type) } @(objc_type=Value, objc_name="initWithCoder") -Value_initWithCoder :: proc(self: ^Value, coder: ^Coder) -> ^Value { +Value_initWithCoder :: proc "c" (self: ^Value, coder: ^Coder) -> ^Value { return msgSend(^Value, self, "initWithCoder:", coder) } @(objc_type=Value, objc_name="getValue") -Value_getValue :: proc(self: ^Value, value: rawptr, size: UInteger) { +Value_getValue :: proc "c" (self: ^Value, value: rawptr, size: UInteger) { msgSend(nil, self, "getValue:size:", value, size) } @@ -67,28 +67,28 @@ Value_pointerValue :: proc "c" (self: ^Value) -> rawptr { Number :: struct{using _: Copying(Number), using _: Value} @(objc_type=Number, objc_name="alloc", objc_is_class_method=true) -Number_alloc :: proc() -> ^Number { +Number_alloc :: proc "c" () -> ^Number { return msgSend(^Number, Number, "alloc") } @(objc_type=Number, objc_name="init") -Number_init :: proc(self: ^Number) -> ^Number { +Number_init :: proc "c" (self: ^Number) -> ^Number { return msgSend(^Number, self, "init") } -@(objc_type=Number, objc_name="numberWithI8", objc_is_class_method=true) Number_numberWithI8 :: proc(value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } -@(objc_type=Number, objc_name="numberWithU8", objc_is_class_method=true) Number_numberWithU8 :: proc(value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } -@(objc_type=Number, objc_name="numberWithI16", objc_is_class_method=true) Number_numberWithI16 :: proc(value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } -@(objc_type=Number, objc_name="numberWithU16", objc_is_class_method=true) Number_numberWithU16 :: proc(value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } -@(objc_type=Number, objc_name="numberWithI32", objc_is_class_method=true) Number_numberWithI32 :: proc(value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } -@(objc_type=Number, objc_name="numberWithU32", objc_is_class_method=true) Number_numberWithU32 :: proc(value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } -@(objc_type=Number, objc_name="numberWithInt", objc_is_class_method=true) Number_numberWithInt :: proc(value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } -@(objc_type=Number, objc_name="numberWithUint", objc_is_class_method=true) Number_numberWithUint :: proc(value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } -@(objc_type=Number, objc_name="numberWithU64", objc_is_class_method=true) Number_numberWithU64 :: proc(value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } -@(objc_type=Number, objc_name="numberWithI64", objc_is_class_method=true) Number_numberWithI64 :: proc(value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } -@(objc_type=Number, objc_name="numberWithF32", objc_is_class_method=true) Number_numberWithF32 :: proc(value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } -@(objc_type=Number, objc_name="numberWithF64", objc_is_class_method=true) Number_numberWithF64 :: proc(value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } -@(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc(value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } +@(objc_type=Number, objc_name="numberWithI8", objc_is_class_method=true) Number_numberWithI8 :: proc "c" (value: i8) -> ^Number { return msgSend(^Number, Number, "numberWithChar:", value) } +@(objc_type=Number, objc_name="numberWithU8", objc_is_class_method=true) Number_numberWithU8 :: proc "c" (value: u8) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedChar:", value) } +@(objc_type=Number, objc_name="numberWithI16", objc_is_class_method=true) Number_numberWithI16 :: proc "c" (value: i16) -> ^Number { return msgSend(^Number, Number, "numberWithShort:", value) } +@(objc_type=Number, objc_name="numberWithU16", objc_is_class_method=true) Number_numberWithU16 :: proc "c" (value: u16) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedShort:", value) } +@(objc_type=Number, objc_name="numberWithI32", objc_is_class_method=true) Number_numberWithI32 :: proc "c" (value: i32) -> ^Number { return msgSend(^Number, Number, "numberWithInt:", value) } +@(objc_type=Number, objc_name="numberWithU32", objc_is_class_method=true) Number_numberWithU32 :: proc "c" (value: u32) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedInt:", value) } +@(objc_type=Number, objc_name="numberWithInt", objc_is_class_method=true) Number_numberWithInt :: proc "c" (value: int) -> ^Number { return msgSend(^Number, Number, "numberWithLong:", value) } +@(objc_type=Number, objc_name="numberWithUint", objc_is_class_method=true) Number_numberWithUint :: proc "c" (value: uint) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLong:", value) } +@(objc_type=Number, objc_name="numberWithU64", objc_is_class_method=true) Number_numberWithU64 :: proc "c" (value: u64) -> ^Number { return msgSend(^Number, Number, "numberWithLongLong:", value) } +@(objc_type=Number, objc_name="numberWithI64", objc_is_class_method=true) Number_numberWithI64 :: proc "c" (value: i64) -> ^Number { return msgSend(^Number, Number, "numberWithUnsignedLongLong:", value) } +@(objc_type=Number, objc_name="numberWithF32", objc_is_class_method=true) Number_numberWithF32 :: proc "c" (value: f32) -> ^Number { return msgSend(^Number, Number, "numberWithFloat:", value) } +@(objc_type=Number, objc_name="numberWithF64", objc_is_class_method=true) Number_numberWithF64 :: proc "c" (value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } +@(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc "c" (value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } Number_number :: proc{ Number_numberWithI8, @@ -106,49 +106,49 @@ Number_number :: proc{ Number_numberWithBool, } -@(objc_type=Number, objc_name="initWithI8") Number_initWithI8 :: proc(self: ^Number, value: i8) -> ^Number { return msgSend(^Number, self, "initWithChar:", value) } -@(objc_type=Number, objc_name="initWithU8") Number_initWithU8 :: proc(self: ^Number, value: u8) -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:", value) } -@(objc_type=Number, objc_name="initWithI16") Number_initWithI16 :: proc(self: ^Number, value: i16) -> ^Number { return msgSend(^Number, self, "initWithShort:", value) } -@(objc_type=Number, objc_name="initWithU16") Number_initWithU16 :: proc(self: ^Number, value: u16) -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:", value) } -@(objc_type=Number, objc_name="initWithI32") Number_initWithI32 :: proc(self: ^Number, value: i32) -> ^Number { return msgSend(^Number, self, "initWithInt:", value) } -@(objc_type=Number, objc_name="initWithU32") Number_initWithU32 :: proc(self: ^Number, value: u32) -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:", value) } -@(objc_type=Number, objc_name="initWithInt") Number_initWithInt :: proc(self: ^Number, value: int) -> ^Number { return msgSend(^Number, self, "initWithLong:", value) } -@(objc_type=Number, objc_name="initWithUint") Number_initWithUint :: proc(self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:", value) } -@(objc_type=Number, objc_name="initWithU64") Number_initWithU64 :: proc(self: ^Number, value: u64) -> ^Number { return msgSend(^Number, self, "initWithLongLong:", value) } -@(objc_type=Number, objc_name="initWithI64") Number_initWithI64 :: proc(self: ^Number, value: i64) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) } -@(objc_type=Number, objc_name="initWithF32") Number_initWithF32 :: proc(self: ^Number, value: f32) -> ^Number { return msgSend(^Number, self, "initWithFloat:", value) } -@(objc_type=Number, objc_name="initWithF64") Number_initWithF64 :: proc(self: ^Number, value: f64) -> ^Number { return msgSend(^Number, self, "initWithDouble:", value) } -@(objc_type=Number, objc_name="initWithBool") Number_initWithBool :: proc(self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:", value) } +@(objc_type=Number, objc_name="initWithI8") Number_initWithI8 :: proc "c" (self: ^Number, value: i8) -> ^Number { return msgSend(^Number, self, "initWithChar:", value) } +@(objc_type=Number, objc_name="initWithU8") Number_initWithU8 :: proc "c" (self: ^Number, value: u8) -> ^Number { return msgSend(^Number, self, "initWithUnsignedChar:", value) } +@(objc_type=Number, objc_name="initWithI16") Number_initWithI16 :: proc "c" (self: ^Number, value: i16) -> ^Number { return msgSend(^Number, self, "initWithShort:", value) } +@(objc_type=Number, objc_name="initWithU16") Number_initWithU16 :: proc "c" (self: ^Number, value: u16) -> ^Number { return msgSend(^Number, self, "initWithUnsignedShort:", value) } +@(objc_type=Number, objc_name="initWithI32") Number_initWithI32 :: proc "c" (self: ^Number, value: i32) -> ^Number { return msgSend(^Number, self, "initWithInt:", value) } +@(objc_type=Number, objc_name="initWithU32") Number_initWithU32 :: proc "c" (self: ^Number, value: u32) -> ^Number { return msgSend(^Number, self, "initWithUnsignedInt:", value) } +@(objc_type=Number, objc_name="initWithInt") Number_initWithInt :: proc "c" (self: ^Number, value: int) -> ^Number { return msgSend(^Number, self, "initWithLong:", value) } +@(objc_type=Number, objc_name="initWithUint") Number_initWithUint :: proc "c" (self: ^Number, value: uint) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLong:", value) } +@(objc_type=Number, objc_name="initWithU64") Number_initWithU64 :: proc "c" (self: ^Number, value: u64) -> ^Number { return msgSend(^Number, self, "initWithLongLong:", value) } +@(objc_type=Number, objc_name="initWithI64") Number_initWithI64 :: proc "c" (self: ^Number, value: i64) -> ^Number { return msgSend(^Number, self, "initWithUnsignedLongLong:", value) } +@(objc_type=Number, objc_name="initWithF32") Number_initWithF32 :: proc "c" (self: ^Number, value: f32) -> ^Number { return msgSend(^Number, self, "initWithFloat:", value) } +@(objc_type=Number, objc_name="initWithF64") Number_initWithF64 :: proc "c" (self: ^Number, value: f64) -> ^Number { return msgSend(^Number, self, "initWithDouble:", value) } +@(objc_type=Number, objc_name="initWithBool") Number_initWithBool :: proc "c" (self: ^Number, value: BOOL) -> ^Number { return msgSend(^Number, self, "initWithBool:", value) } -@(objc_type=Number, objc_name="i8Value") Number_i8Value :: proc(self: ^Number) -> i8 { return msgSend(i8, self, "charValue") } -@(objc_type=Number, objc_name="u8Value") Number_u8Value :: proc(self: ^Number) -> u8 { return msgSend(u8, self, "unsignedCharValue") } -@(objc_type=Number, objc_name="i16Value") Number_i16Value :: proc(self: ^Number) -> i16 { return msgSend(i16, self, "shortValue") } -@(objc_type=Number, objc_name="u16Value") Number_u16Value :: proc(self: ^Number) -> u16 { return msgSend(u16, self, "unsignedShortValue") } -@(objc_type=Number, objc_name="i32Value") Number_i32Value :: proc(self: ^Number) -> i32 { return msgSend(i32, self, "intValue") } -@(objc_type=Number, objc_name="u32Value") Number_u32Value :: proc(self: ^Number) -> u32 { return msgSend(u32, self, "unsignedIntValue") } -@(objc_type=Number, objc_name="intValue") Number_intValue :: proc(self: ^Number) -> int { return msgSend(int, self, "longValue") } -@(objc_type=Number, objc_name="uintValue") Number_uintValue :: proc(self: ^Number) -> uint { return msgSend(uint, self, "unsignedLongValue") } -@(objc_type=Number, objc_name="u64Value") Number_u64Value :: proc(self: ^Number) -> u64 { return msgSend(u64, self, "longLongValue") } -@(objc_type=Number, objc_name="i64Value") Number_i64Value :: proc(self: ^Number) -> i64 { return msgSend(i64, self, "unsignedLongLongValue") } -@(objc_type=Number, objc_name="f32Value") Number_f32Value :: proc(self: ^Number) -> f32 { return msgSend(f32, self, "floatValue") } -@(objc_type=Number, objc_name="f64Value") Number_f64Value :: proc(self: ^Number) -> f64 { return msgSend(f64, self, "doubleValue") } -@(objc_type=Number, objc_name="boolValue") Number_boolValue :: proc(self: ^Number) -> BOOL { return msgSend(BOOL, self, "boolValue") } -@(objc_type=Number, objc_name="integerValue") Number_integerValue :: proc(self: ^Number) -> Integer { return msgSend(Integer, self, "integerValue") } -@(objc_type=Number, objc_name="uintegerValue") Number_uintegerValue :: proc(self: ^Number) -> UInteger { return msgSend(UInteger, self, "unsignedIntegerValue") } -@(objc_type=Number, objc_name="stringValue") Number_stringValue :: proc(self: ^Number) -> ^String { return msgSend(^String, self, "stringValue") } +@(objc_type=Number, objc_name="i8Value") Number_i8Value :: proc "c" (self: ^Number) -> i8 { return msgSend(i8, self, "charValue") } +@(objc_type=Number, objc_name="u8Value") Number_u8Value :: proc "c" (self: ^Number) -> u8 { return msgSend(u8, self, "unsignedCharValue") } +@(objc_type=Number, objc_name="i16Value") Number_i16Value :: proc "c" (self: ^Number) -> i16 { return msgSend(i16, self, "shortValue") } +@(objc_type=Number, objc_name="u16Value") Number_u16Value :: proc "c" (self: ^Number) -> u16 { return msgSend(u16, self, "unsignedShortValue") } +@(objc_type=Number, objc_name="i32Value") Number_i32Value :: proc "c" (self: ^Number) -> i32 { return msgSend(i32, self, "intValue") } +@(objc_type=Number, objc_name="u32Value") Number_u32Value :: proc "c" (self: ^Number) -> u32 { return msgSend(u32, self, "unsignedIntValue") } +@(objc_type=Number, objc_name="intValue") Number_intValue :: proc "c" (self: ^Number) -> int { return msgSend(int, self, "longValue") } +@(objc_type=Number, objc_name="uintValue") Number_uintValue :: proc "c" (self: ^Number) -> uint { return msgSend(uint, self, "unsignedLongValue") } +@(objc_type=Number, objc_name="u64Value") Number_u64Value :: proc "c" (self: ^Number) -> u64 { return msgSend(u64, self, "longLongValue") } +@(objc_type=Number, objc_name="i64Value") Number_i64Value :: proc "c" (self: ^Number) -> i64 { return msgSend(i64, self, "unsignedLongLongValue") } +@(objc_type=Number, objc_name="f32Value") Number_f32Value :: proc "c" (self: ^Number) -> f32 { return msgSend(f32, self, "floatValue") } +@(objc_type=Number, objc_name="f64Value") Number_f64Value :: proc "c" (self: ^Number) -> f64 { return msgSend(f64, self, "doubleValue") } +@(objc_type=Number, objc_name="boolValue") Number_boolValue :: proc "c" (self: ^Number) -> BOOL { return msgSend(BOOL, self, "boolValue") } +@(objc_type=Number, objc_name="integerValue") Number_integerValue :: proc "c" (self: ^Number) -> Integer { return msgSend(Integer, self, "integerValue") } +@(objc_type=Number, objc_name="uintegerValue") Number_uintegerValue :: proc "c" (self: ^Number) -> UInteger { return msgSend(UInteger, self, "unsignedIntegerValue") } +@(objc_type=Number, objc_name="stringValue") Number_stringValue :: proc "c" (self: ^Number) -> ^String { return msgSend(^String, self, "stringValue") } @(objc_type=Number, objc_name="compare") -Number_compare :: proc(self, other: ^Number) -> ComparisonResult { +Number_compare :: proc "c" (self, other: ^Number) -> ComparisonResult { return msgSend(ComparisonResult, self, "compare:", other) } @(objc_type=Number, objc_name="isEqualToNumber") -Number_isEqualToNumber :: proc(self, other: ^Number) -> BOOL { +Number_isEqualToNumber :: proc "c" (self, other: ^Number) -> BOOL { return msgSend(BOOL, self, "isEqualToNumber:", other) } @(objc_type=Number, objc_name="descriptionWithLocale") -Number_descriptionWithLocale :: proc(self: ^Number, locale: ^Object) -> ^String { +Number_descriptionWithLocale :: proc "c" (self: ^Number, locale: ^Object) -> ^String { return msgSend(^String, self, "descriptionWithLocale:", locale) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSObject.odin b/vendor/darwin/Foundation/NSObject.odin index 6ec5939ee..fdcf05880 100644 --- a/vendor/darwin/Foundation/NSObject.odin +++ b/vendor/darwin/Foundation/NSObject.odin @@ -21,67 +21,67 @@ Object :: struct {using _: intrinsics.objc_object} @(objc_class="NSObject") Copying :: struct($T: typeid) {using _: Object} -alloc :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { +alloc :: proc "c" ($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, T, "alloc") } @(objc_type=Object, objc_name="init") -init :: proc(self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { +init :: proc "c" (self: ^$T) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "init") } @(objc_type=Object, objc_name="copy") -copy :: proc(self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) { +copy :: proc "c" (self: ^Copying($T)) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return msgSend(^T, self, "copy") } -new :: proc($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { +new :: proc "c" ($T: typeid) -> ^T where intrinsics.type_is_subtype_of(T, Object) { return init(alloc(T)) } @(objc_type=Object, objc_name="retain") -retain :: proc(self: ^Object) { +retain :: proc "c" (self: ^Object) { _ = msgSend(^Object, self, "retain") } @(objc_type=Object, objc_name="release") -release :: proc(self: ^Object) { +release :: proc "c" (self: ^Object) { msgSend(nil, self, "release") } @(objc_type=Object, objc_name="autorelease") -autorelease :: proc(self: ^Object) { +autorelease :: proc "c" (self: ^Object) { msgSend(nil, self, "autorelease") } @(objc_type=Object, objc_name="retainCount") -retainCount :: proc(self: ^Object) -> UInteger { +retainCount :: proc "c" (self: ^Object) -> UInteger { return msgSend(UInteger, self, "retainCount") } @(objc_type=Object, objc_name="class") -class :: proc(self: ^Object) -> Class { +class :: proc "c" (self: ^Object) -> Class { return msgSend(Class, self, "class") } @(objc_type=Object, objc_name="hash") -hash :: proc(self: ^Object) -> UInteger { +hash :: proc "c" (self: ^Object) -> UInteger { return msgSend(UInteger, self, "hash") } @(objc_type=Object, objc_name="isEqual") -isEqual :: proc(self, pObject: ^Object) -> BOOL { +isEqual :: proc "c" (self, pObject: ^Object) -> BOOL { return msgSend(BOOL, self, "isEqual:", pObject) } @(objc_type=Object, objc_name="description") -description :: proc(self: ^Object) -> ^String { +description :: proc "c" (self: ^Object) -> ^String { return msgSend(^String, self, "description") } @(objc_type=Object, objc_name="debugDescription") -debugDescription :: proc(self: ^Object) -> ^String { +debugDescription :: proc "c" (self: ^Object) -> ^String { if msgSendSafeCheck(self, intrinsics.objc_find_selector("debugDescription")) { return msgSend(^String, self, "debugDescription") } return nil } -bridgingCast :: proc($T: typeid, obj: ^Object) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { +bridgingCast :: proc "c" ($T: typeid, obj: ^Object) where intrinsics.type_is_pointer(T), intrinsics.type_is_subtype_of(T, ^Object) { return (T)(obj) } diff --git a/vendor/darwin/Foundation/NSOpenPanel.odin b/vendor/darwin/Foundation/NSOpenPanel.odin index fe39fef7b..ac5f9674e 100644 --- a/vendor/darwin/Foundation/NSOpenPanel.odin +++ b/vendor/darwin/Foundation/NSOpenPanel.odin @@ -4,28 +4,28 @@ package objc_Foundation OpenPanel :: struct{ using _: SavePanel } @(objc_type=OpenPanel, objc_name="openPanel", objc_is_class_method=true) -OpenPanel_openPanel :: proc() -> ^OpenPanel { +OpenPanel_openPanel :: proc "c" () -> ^OpenPanel { return msgSend(^OpenPanel, OpenPanel, "openPanel") } @(objc_type=OpenPanel, objc_name="URLs") -OpenPanel_URLs :: proc(self: ^OpenPanel) -> ^Array { +OpenPanel_URLs :: proc "c" (self: ^OpenPanel) -> ^Array { return msgSend(^Array, self, "URLs") } @(objc_type=OpenPanel, objc_name="setCanChooseFiles") -OpenPanel_setCanChooseFiles :: proc(self: ^OpenPanel, setting: BOOL) { +OpenPanel_setCanChooseFiles :: proc "c" (self: ^OpenPanel, setting: BOOL) { msgSend(nil, self, "setCanChooseFiles:", setting) } @(objc_type=OpenPanel, objc_name="setCanChooseDirectories") -OpenPanel_setCanChooseDirectories :: proc(self: ^OpenPanel, setting: BOOL) { +OpenPanel_setCanChooseDirectories :: proc "c" (self: ^OpenPanel, setting: BOOL) { msgSend(nil, self, "setCanChooseDirectories:", setting) } @(objc_type=OpenPanel, objc_name="setResolvesAliases") -OpenPanel_setResolvesAliases :: proc(self: ^OpenPanel, setting: BOOL) { +OpenPanel_setResolvesAliases :: proc "c" (self: ^OpenPanel, setting: BOOL) { msgSend(nil, self, "setResolvesAliases:", setting) } @(objc_type=OpenPanel, objc_name="setAllowsMultipleSelection") -OpenPanel_setAllowsMultipleSelection :: proc(self: ^OpenPanel, setting: BOOL) { +OpenPanel_setAllowsMultipleSelection :: proc "c" (self: ^OpenPanel, setting: BOOL) { msgSend(nil, self, "setAllowsMultipleSelection:", setting) } diff --git a/vendor/darwin/Foundation/NSRange.odin b/vendor/darwin/Foundation/NSRange.odin index 74ce595a3..dcb100e91 100644 --- a/vendor/darwin/Foundation/NSRange.odin +++ b/vendor/darwin/Foundation/NSRange.odin @@ -5,18 +5,18 @@ Range :: struct { length: UInteger, } -Range_Make :: proc(loc, len: UInteger) -> Range { +Range_Make :: proc "c" (loc, len: UInteger) -> Range { return Range{loc, len} } -Range_Equal :: proc(a, b: Range) -> BOOL { +Range_Equal :: proc "c" (a, b: Range) -> BOOL { return a == b } -Range_LocationInRange :: proc(self: Range, loc: UInteger) -> BOOL { +Range_LocationInRange :: proc "c" (self: Range, loc: UInteger) -> BOOL { return !((loc < self.location) && ((loc - self.location) < self.length)) } -Range_Max :: proc(self: Range) -> UInteger { +Range_Max :: proc "c" (self: Range) -> UInteger { return self.location + self.length } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSSavePanel.odin b/vendor/darwin/Foundation/NSSavePanel.odin index e38620613..8e4d7a07b 100644 --- a/vendor/darwin/Foundation/NSSavePanel.odin +++ b/vendor/darwin/Foundation/NSSavePanel.odin @@ -4,6 +4,6 @@ package objc_Foundation SavePanel :: struct{ using _: Panel } @(objc_type=SavePanel, objc_name="runModal") -SavePanel_runModal :: proc(self: ^SavePanel) -> ModalResponse { +SavePanel_runModal :: proc "c" (self: ^SavePanel) -> ModalResponse { return msgSend(ModalResponse, self, "runModal") } diff --git a/vendor/darwin/Foundation/NSString.odin b/vendor/darwin/Foundation/NSString.odin index 18e392415..d3c6c454d 100644 --- a/vendor/darwin/Foundation/NSString.odin +++ b/vendor/darwin/Foundation/NSString.odin @@ -64,77 +64,77 @@ MakeConstantString :: proc "c" (#const c: cstring) -> ^String { @(objc_type=String, objc_name="alloc", objc_is_class_method=true) -String_alloc :: proc() -> ^String { +String_alloc :: proc "c" () -> ^String { return msgSend(^String, String, "alloc") } @(objc_type=String, objc_name="init") -String_init :: proc(self: ^String) -> ^String { +String_init :: proc "c" (self: ^String) -> ^String { return msgSend(^String, self, "init") } @(objc_type=String, objc_name="initWithString") -String_initWithString :: proc(self: ^String, other: ^String) -> ^String { +String_initWithString :: proc "c" (self: ^String, other: ^String) -> ^String { return msgSend(^String, self, "initWithString:", other) } @(objc_type=String, objc_name="initWithCString") -String_initWithCString :: proc(self: ^String, pString: cstring, encoding: StringEncoding) -> ^String { +String_initWithCString :: proc "c" (self: ^String, pString: cstring, encoding: StringEncoding) -> ^String { return msgSend(^String, self, "initWithCstring:encoding:", pString, encoding) } @(objc_type=String, objc_name="initWithBytesNoCopy") -String_initWithBytesNoCopy :: proc(self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String { +String_initWithBytesNoCopy :: proc "c" (self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String { return msgSend(^String, self, "initWithBytesNoCopy:length:encoding:freeWhenDone:", pBytes, length, encoding, freeWhenDone) } @(objc_type=String, objc_name="initWithOdinString") -String_initWithOdinString :: proc(self: ^String, str: string) -> ^String { +String_initWithOdinString :: proc "c" (self: ^String, str: string) -> ^String { return String_initWithBytesNoCopy(self, raw_data(str), UInteger(len(str)), .UTF8, false) } @(objc_type=String, objc_name="characterAtIndex") -String_characterAtIndex :: proc(self: ^String, index: UInteger) -> unichar { +String_characterAtIndex :: proc "c" (self: ^String, index: UInteger) -> unichar { return msgSend(unichar, self, "characterAtIndex:", index) } @(objc_type=String, objc_name="length") -String_length :: proc(self: ^String) -> UInteger { +String_length :: proc "c" (self: ^String) -> UInteger { return msgSend(UInteger, self, "length") } @(objc_type=String, objc_name="cstringUsingEncoding") -String_cstringUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> cstring { +String_cstringUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> cstring { return msgSend(cstring, self, "cStringUsingEncoding:", encoding) } @(objc_type=String, objc_name="UTF8String") -String_UTF8String :: proc(self: ^String) -> cstring { +String_UTF8String :: proc "c" (self: ^String) -> cstring { return msgSend(cstring, self, "UTF8String") } @(objc_type=String, objc_name="odinString") -String_odinString :: proc(self: ^String) -> string { +String_odinString :: proc "c" (self: ^String) -> string { return string(String_UTF8String(self)) } @(objc_type=String, objc_name="maximumLengthOfBytesUsingEncoding") -String_maximumLengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { +String_maximumLengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger { return msgSend(UInteger, self, "maximumLengthOfBytesUsingEncoding:", encoding) } @(objc_type=String, objc_name="lengthOfBytesUsingEncoding") -String_lengthOfBytesUsingEncoding :: proc(self: ^String, encoding: StringEncoding) -> UInteger { +String_lengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger { return msgSend(UInteger, self, "lengthOfBytesUsingEncoding:", encoding) } @(objc_type=String, objc_name="isEqualToString") -String_isEqualToString :: proc(self, other: ^String) -> BOOL { +String_isEqualToString :: proc "c" (self, other: ^String) -> BOOL { return msgSend(BOOL, self, "isEqualToString:", other) } @(objc_type=String, objc_name="rangeOfString") -String_rangeOfString :: proc(self, other: ^String, options: StringCompareOptions) -> Range { +String_rangeOfString :: proc "c" (self, other: ^String, options: StringCompareOptions) -> Range { return msgSend(Range, self, "rangeOfString:options:", other, options) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSURL.odin b/vendor/darwin/Foundation/NSURL.odin index 9e54302bf..9e9081219 100644 --- a/vendor/darwin/Foundation/NSURL.odin +++ b/vendor/darwin/Foundation/NSURL.odin @@ -5,26 +5,26 @@ URL :: struct{using _: Copying(URL)} @(objc_type=URL, objc_name="alloc", objc_is_class_method=true) -URL_alloc :: proc() -> ^URL { +URL_alloc :: proc "c" () -> ^URL { return msgSend(^URL, URL, "alloc") } @(objc_type=URL, objc_name="init") -URL_init :: proc(self: ^URL) -> ^URL { +URL_init :: proc "c" (self: ^URL) -> ^URL { return msgSend(^URL, self, "init") } @(objc_type=URL, objc_name="initWithString") -URL_initWithString :: proc(self: ^URL, value: ^String) -> ^URL { +URL_initWithString :: proc "c" (self: ^URL, value: ^String) -> ^URL { return msgSend(^URL, self, "initWithString:", value) } @(objc_type=URL, objc_name="initFileURLWithPath") -URL_initFileURLWithPath :: proc(self: ^URL, path: ^String) -> ^URL { +URL_initFileURLWithPath :: proc "c" (self: ^URL, path: ^String) -> ^URL { return msgSend(^URL, self, "initFileURLWithPath:", path) } @(objc_type=URL, objc_name="fileSystemRepresentation") -URL_fileSystemRepresentation :: proc(self: ^URL) -> cstring { +URL_fileSystemRepresentation :: proc "c" (self: ^URL) -> cstring { return msgSend(cstring, self, "fileSystemRepresentation") } diff --git a/vendor/darwin/Foundation/NSUserDefaults.odin b/vendor/darwin/Foundation/NSUserDefaults.odin index 75655cbaf..a8a6d7545 100644 --- a/vendor/darwin/Foundation/NSUserDefaults.odin +++ b/vendor/darwin/Foundation/NSUserDefaults.odin @@ -4,11 +4,11 @@ package objc_Foundation UserDefaults :: struct { using _: Object } @(objc_type=UserDefaults, objc_name="standardUserDefaults", objc_is_class_method=true) -UserDefaults_standardUserDefaults :: proc() -> ^UserDefaults { +UserDefaults_standardUserDefaults :: proc "c" () -> ^UserDefaults { return msgSend(^UserDefaults, UserDefaults, "standardUserDefaults") } @(objc_type=UserDefaults, objc_name="setBoolForKey") -UserDefaults_setBoolForKey :: proc(self: ^UserDefaults, value: BOOL, name: ^String) { +UserDefaults_setBoolForKey :: proc "c" (self: ^UserDefaults, value: BOOL, name: ^String) { msgSend(nil, self, "setBool:forKey:", value, name) } diff --git a/vendor/darwin/Foundation/NSWindow.odin b/vendor/darwin/Foundation/NSWindow.odin index 5594d60ea..0a7382921 100644 --- a/vendor/darwin/Foundation/NSWindow.odin +++ b/vendor/darwin/Foundation/NSWindow.odin @@ -53,75 +53,75 @@ BackingStoreType :: enum NS.UInteger { WindowDelegateTemplate :: struct { // Managing Sheets - windowWillPositionSheetUsingRect: proc(window: ^Window, sheet: ^Window, rect: Rect) -> Rect, - windowWillBeginSheet: proc(notification: ^Notification), - windowDidEndSheet: proc(notification: ^Notification), + windowWillPositionSheetUsingRect: proc(window: ^Window, sheet: ^Window, rect: Rect) -> Rect, + windowWillBeginSheet: proc(notification: ^Notification), + windowDidEndSheet: proc(notification: ^Notification), // Sizing Windows - windowWillResizeToSize: proc(sender: ^Window, frameSize: Size) -> Size, - windowDidResize: proc(notification: ^Notification), - windowWillStartLiveResize: proc(noitifcation: ^Notification), - windowDidEndLiveResize: proc(notification: ^Notification), + windowWillResizeToSize: proc(sender: ^Window, frameSize: Size) -> Size, + windowDidResize: proc(notification: ^Notification), + windowWillStartLiveResize: proc(noitifcation: ^Notification), + windowDidEndLiveResize: proc(notification: ^Notification), // Minimizing Windows - windowWillMiniaturize: proc(notification: ^Notification), - windowDidMiniaturize: proc(notification: ^Notification), - windowDidDeminiaturize: proc(notification: ^Notification), + windowWillMiniaturize: proc(notification: ^Notification), + windowDidMiniaturize: proc(notification: ^Notification), + windowDidDeminiaturize: proc(notification: ^Notification), // Zooming window - windowWillUseStandardFrameDefaultFrame: proc(window: ^Window, newFrame: Rect) -> Rect, - windowShouldZoomToFrame: proc(window: ^Window, newFrame: Rect) -> BOOL, + windowWillUseStandardFrameDefaultFrame: proc(window: ^Window, newFrame: Rect) -> Rect, + windowShouldZoomToFrame: proc(window: ^Window, newFrame: Rect) -> BOOL, // Managing Full-Screen Presentation - windowWillUseFullScreenContentSize: proc(window: ^Window, proposedSize: Size) -> Size, - windowWillUseFullScreenPresentationOptions: proc(window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions, - windowWillEnterFullScreen: proc(notification: ^Notification), - windowDidEnterFullScreen: proc(notification: ^Notification), - windowWillExitFullScreen: proc(notification: ^Notification), - windowDidExitFullScreen: proc(notification: ^Notification), + windowWillUseFullScreenContentSize: proc(window: ^Window, proposedSize: Size) -> Size, + windowWillUseFullScreenPresentationOptions: proc(window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions, + windowWillEnterFullScreen: proc(notification: ^Notification), + windowDidEnterFullScreen: proc(notification: ^Notification), + windowWillExitFullScreen: proc(notification: ^Notification), + windowDidExitFullScreen: proc(notification: ^Notification), // Custom Full-Screen Presentation Animations - customWindowsToEnterFullScreenForWindow: proc(window: ^Window) -> ^Array, - customWindowsToEnterFullScreenForWindowOnScreen: proc(window: ^Window, screen: ^Screen) -> ^Array, - windowStartCustomAnimationToEnterFullScreenWithDuration: proc(window: ^Window, duration: TimeInterval), - windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration: proc(window: ^Window, screen: ^Screen, duration: TimeInterval), - windowDidFailToEnterFullScreen: proc(window: ^Window), - customWindowsToExitFullScreenForWindow: proc(window: ^Window) -> ^Array, - windowStartCustomAnimationToExitFullScreenWithDuration: proc(window: ^Window, duration: TimeInterval), - windowDidFailToExitFullScreen: proc(window: ^Window), + customWindowsToEnterFullScreenForWindow: proc(window: ^Window) -> ^Array, + customWindowsToEnterFullScreenForWindowOnScreen: proc(window: ^Window, screen: ^Screen) -> ^Array, + windowStartCustomAnimationToEnterFullScreenWithDuration: proc(window: ^Window, duration: TimeInterval), + windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration: proc(window: ^Window, screen: ^Screen, duration: TimeInterval), + windowDidFailToEnterFullScreen: proc(window: ^Window), + customWindowsToExitFullScreenForWindow: proc(window: ^Window) -> ^Array, + windowStartCustomAnimationToExitFullScreenWithDuration: proc(window: ^Window, duration: TimeInterval), + windowDidFailToExitFullScreen: proc(window: ^Window), // Moving Windows - windowWillMove: proc(notification: ^Notification), - windowDidMove: proc(notification: ^Notification), - windowDidChangeScreen: proc(notification: ^Notification), - windowDidChangeScreenProfile: proc(notification: ^Notification), - windowDidChangeBackingProperties: proc(notification: ^Notification), + windowWillMove: proc(notification: ^Notification), + windowDidMove: proc(notification: ^Notification), + windowDidChangeScreen: proc(notification: ^Notification), + windowDidChangeScreenProfile: proc(notification: ^Notification), + windowDidChangeBackingProperties: proc(notification: ^Notification), // Closing Windows - windowShouldClose: proc(sender: ^Window) -> BOOL, - windowWillClose: proc(notification: ^Notification), + windowShouldClose: proc(sender: ^Window) -> BOOL, + windowWillClose: proc(notification: ^Notification), // Managing Key Status - windowDidBecomeKey: proc(notification: ^Notification), - windowDidResignKey: proc(notification: ^Notification), + windowDidBecomeKey: proc(notification: ^Notification), + windowDidResignKey: proc(notification: ^Notification), // Managing Main Status - windowDidBecomeMain: proc(notification: ^Notification), - windowDidResignMain: proc(notification: ^Notification), + windowDidBecomeMain: proc(notification: ^Notification), + windowDidResignMain: proc(notification: ^Notification), // Managing Field Editors - windowWillReturnFieldEditorToObject: proc(sender: ^Window, client: id) -> id, + windowWillReturnFieldEditorToObject: proc(sender: ^Window, client: id) -> id, // Updating Windows - windowDidUpdate: proc (notification: ^Notification), + windowDidUpdate: proc (notification: ^Notification), // Exposing Windows - windowDidExpose: proc (notification: ^Notification), + windowDidExpose: proc (notification: ^Notification), // Managing Occlusion State - windowDidChangeOcclusionState: proc(notification: ^Notification), + windowDidChangeOcclusionState: proc(notification: ^Notification), // Dragging Windows - windowShouldDragDocumentWithEventFromWithPasteboard: proc(window: ^Window, event: ^Event, dragImageLocation: Point, pasteboard: ^Pasteboard) -> BOOL, + windowShouldDragDocumentWithEventFromWithPasteboard: proc(window: ^Window, event: ^Event, dragImageLocation: Point, pasteboard: ^Pasteboard) -> BOOL, // Getting the Undo Manager - windowWillReturnUndoManager: proc(window: ^Window) -> ^UndoManager, + windowWillReturnUndoManager: proc(window: ^Window) -> ^UndoManager, // Managing Titles - windowShouldPopUpDocumentPathMenu: proc(window: ^Window, menu: ^Menu) -> BOOL, + windowShouldPopUpDocumentPathMenu: proc(window: ^Window, menu: ^Menu) -> BOOL, // Managing Restorable State - windowWillEncodeRestorableState: proc(window: ^Window, state: ^Coder), - windowDidEncodeRestorableState: proc(window: ^Window, state: ^Coder), + windowWillEncodeRestorableState: proc(window: ^Window, state: ^Coder), + windowDidEncodeRestorableState: proc(window: ^Window, state: ^Coder), // Managing Presentation in Version Browsers windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize: proc(window: ^Window, maxPreferredFrameSize: Size, maxAllowedFrameSize: Size) -> Size, - windowWillEnterVersionBrowser: proc(notification: ^Notification), - windowDidEnterVersionBrowser: proc(notification: ^Notification), - windowWillExitVersionBrowser: proc(notification: ^Notification), - windowDidExitVersionBrowser: proc(notification: ^Notification), + windowWillEnterVersionBrowser: proc(notification: ^Notification), + windowDidEnterVersionBrowser: proc(notification: ^Notification), + windowWillExitVersionBrowser: proc(notification: ^Notification), + windowDidExitVersionBrowser: proc(notification: ^Notification), } WindowDelegate :: struct { using _: Object } @@ -562,19 +562,19 @@ Color :: struct {using _: Object} Layer :: struct { using _: NS.Object } @(objc_type=Layer, objc_name="contentsScale") -Layer_contentsScale :: proc(self: ^Layer) -> Float { +Layer_contentsScale :: proc "c" (self: ^Layer) -> Float { return msgSend(Float, self, "contentsScale") } @(objc_type=Layer, objc_name="setContentsScale") -Layer_setContentsScale :: proc(self: ^Layer, scale: Float) { +Layer_setContentsScale :: proc "c" (self: ^Layer, scale: Float) { msgSend(nil, self, "setContentsScale:", scale) } @(objc_type=Layer, objc_name="frame") -Layer_frame :: proc(self: ^Layer) -> Rect { +Layer_frame :: proc "c" (self: ^Layer) -> Rect { return msgSend(Rect, self, "frame") } @(objc_type=Layer, objc_name="addSublayer") -Layer_addSublayer :: proc(self: ^Layer, layer: ^Layer) { +Layer_addSublayer :: proc "c" (self: ^Layer, layer: ^Layer) { msgSend(nil, self, "addSublayer:", layer) } @@ -586,23 +586,23 @@ View :: struct {using _: Responder} @(objc_type=View, objc_name="initWithFrame") -View_initWithFrame :: proc(self: ^View, frame: Rect) -> ^View { +View_initWithFrame :: proc "c" (self: ^View, frame: Rect) -> ^View { return msgSend(^View, self, "initWithFrame:", frame) } @(objc_type=View, objc_name="layer") -View_layer :: proc(self: ^View) -> ^Layer { +View_layer :: proc "c" (self: ^View) -> ^Layer { return msgSend(^Layer, self, "layer") } @(objc_type=View, objc_name="setLayer") -View_setLayer :: proc(self: ^View, layer: ^Layer) { +View_setLayer :: proc "c" (self: ^View, layer: ^Layer) { msgSend(nil, self, "setLayer:", layer) } @(objc_type=View, objc_name="wantsLayer") -View_wantsLayer :: proc(self: ^View) -> BOOL { +View_wantsLayer :: proc "c" (self: ^View) -> BOOL { return msgSend(BOOL, self, "wantsLayer") } @(objc_type=View, objc_name="setWantsLayer") -View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { +View_setWantsLayer :: proc "c" (self: ^View, wantsLayer: BOOL) { msgSend(nil, self, "setWantsLayer:", wantsLayer) } @@ -610,7 +610,7 @@ View_setWantsLayer :: proc(self: ^View, wantsLayer: BOOL) { Window :: struct {using _: Responder} @(objc_type=Window, objc_name="alloc", objc_is_class_method=true) -Window_alloc :: proc() -> ^Window { +Window_alloc :: proc "c" () -> ^Window { return msgSend(^Window, Window, "alloc") } @@ -630,70 +630,70 @@ Window_initWithContentRect :: proc (self: ^Window, contentRect: Rect, styleMask: return self } @(objc_type=Window, objc_name="contentView") -Window_contentView :: proc(self: ^Window) -> ^View { +Window_contentView :: proc "c" (self: ^Window) -> ^View { return msgSend(^View, self, "contentView") } @(objc_type=Window, objc_name="setContentView") -Window_setContentView :: proc(self: ^Window, content_view: ^View) { +Window_setContentView :: proc "c" (self: ^Window, content_view: ^View) { msgSend(nil, self, "setContentView:", content_view) } @(objc_type=Window, objc_name="contentLayoutRect") -Window_contentLayoutRect :: proc(self: ^Window) -> Rect { +Window_contentLayoutRect :: proc "c" (self: ^Window) -> Rect { return msgSend(Rect, self, "contentLayoutRect") } @(objc_type=Window, objc_name="frame") -Window_frame :: proc(self: ^Window) -> Rect { +Window_frame :: proc "c" (self: ^Window) -> Rect { return msgSend(Rect, self, "frame") } @(objc_type=Window, objc_name="setFrame") -Window_setFrame :: proc(self: ^Window, frame: Rect) { +Window_setFrame :: proc "c" (self: ^Window, frame: Rect) { msgSend(nil, self, "setFrame:", frame) } @(objc_type=Window, objc_name="opaque") -Window_opaque :: proc(self: ^Window) -> NS.BOOL { +Window_opaque :: proc "c" (self: ^Window) -> NS.BOOL { return msgSend(NS.BOOL, self, "opaque") } @(objc_type=Window, objc_name="setOpaque") -Window_setOpaque :: proc(self: ^Window, ok: NS.BOOL) { +Window_setOpaque :: proc "c" (self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setOpaque:", ok) } @(objc_type=Window, objc_name="backgroundColor") -Window_backgroundColor :: proc(self: ^Window) -> ^NS.Color { +Window_backgroundColor :: proc "c" (self: ^Window) -> ^NS.Color { return msgSend(^NS.Color, self, "backgroundColor") } @(objc_type=Window, objc_name="setBackgroundColor") -Window_setBackgroundColor :: proc(self: ^Window, color: ^NS.Color) { +Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^NS.Color) { msgSend(nil, self, "setBackgroundColor:", color) } @(objc_type=Window, objc_name="makeKeyAndOrderFront") -Window_makeKeyAndOrderFront :: proc(self: ^Window, key: ^NS.Object) { +Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^NS.Object) { msgSend(nil, self, "makeKeyAndOrderFront:", key) } @(objc_type=Window, objc_name="setTitle") -Window_setTitle :: proc(self: ^Window, title: ^NS.String) { +Window_setTitle :: proc "c" (self: ^Window, title: ^NS.String) { msgSend(nil, self, "setTitle:", title) } @(objc_type=Window, objc_name="setTitlebarAppearsTransparent") -Window_setTitlebarAppearsTransparent :: proc(self: ^Window, ok: NS.BOOL) { +Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setTitlebarAppearsTransparent:", ok) } @(objc_type=Window, objc_name="setMovable") -Window_setMovable :: proc(self: ^Window, ok: NS.BOOL) { +Window_setMovable :: proc "c" (self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setMovable:", ok) } @(objc_type=Window, objc_name="setMovableByWindowBackground") -Window_setMovableByWindowBackground :: proc(self: ^Window, ok: NS.BOOL) { +Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: NS.BOOL) { msgSend(nil, self, "setMovableByWindowBackground:", ok) } @(objc_type=Window, objc_name="setStyleMask") -Window_setStyleMask :: proc(self: ^Window, style_mask: WindowStyleMask) { +Window_setStyleMask :: proc "c" (self: ^Window, style_mask: WindowStyleMask) { msgSend(nil, self, "setStyleMask:", style_mask) } @(objc_type=Window, objc_name="close") -Window_close :: proc(self: ^Window) { +Window_close :: proc "c" (self: ^Window) { msgSend(nil, self, "close") } @(objc_type=Window, objc_name="setDelegate") -Window_setDelegate :: proc(self: ^Window, delegate: ^WindowDelegate) { +Window_setDelegate :: proc "c" (self: ^Window, delegate: ^WindowDelegate) { msgSend(nil, self, "setDelegate:", delegate) } \ No newline at end of file diff --git a/vendor/darwin/Foundation/objc.odin b/vendor/darwin/Foundation/objc.odin index d8f93b465..ac3aeb6ef 100644 --- a/vendor/darwin/Foundation/objc.odin +++ b/vendor/darwin/Foundation/objc.odin @@ -13,12 +13,12 @@ foreign Foundation { objc_allocateClassPair :: proc "c" (superclass : Class, name : cstring, extraBytes : c.size_t) -> Class --- objc_registerClassPair :: proc "c" (cls : Class) --- - class_addMethod :: proc "c" (cls: Class, name: SEL, imp: IMP, types: cstring) -> BOOL --- + class_addMethod :: proc "c" (cls: Class, name: SEL, imp: IMP, types: cstring) -> BOOL --- class_getInstanceMethod :: proc "c" (cls: Class, name: SEL) -> Method --- - class_createInstance :: proc "c" (cls: Class, extraBytes: c.size_t) -> id --- + class_createInstance :: proc "c" (cls: Class, extraBytes: c.size_t) -> id --- method_setImplementation :: proc "c" (method: Method, imp: IMP) --- - object_getIndexedIvars :: proc(obj: id) -> rawptr --- + object_getIndexedIvars :: proc(obj: id) -> rawptr --- } From 9fc9981a9e94db9819bb6a7e6f94fc7c72c5e5b8 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 15:04:33 +0100 Subject: [PATCH 057/108] Update calling convention to the most appropriate - "odin" if the `context` is needed for `assert` - "contextless" if multiple return values are needed (better for optimizations) - "c" otherwise --- vendor/darwin/Metal/MetalClasses.odin | 3112 +++++++++++----------- vendor/darwin/MetalKit/MetalKit.odin | 94 +- vendor/darwin/QuartzCore/QuartzCore.odin | 34 +- 3 files changed, 1620 insertions(+), 1620 deletions(-) diff --git a/vendor/darwin/Metal/MetalClasses.odin b/vendor/darwin/Metal/MetalClasses.odin index 93e772e5c..b10959c2b 100644 --- a/vendor/darwin/Metal/MetalClasses.odin +++ b/vendor/darwin/Metal/MetalClasses.odin @@ -27,47 +27,47 @@ Methods: AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="init") -AccelerationStructureBoundingBoxGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^Buffer { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "boundingBoxBuffer") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxBufferOffset") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxCount") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { +AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxStride") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) -AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor { +AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc "c" () -> ^AccelerationStructureBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBuffer") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^Buffer) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^Buffer) { msgSend(nil, self, "setBoundingBoxBuffer:", boundingBoxBuffer) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBufferOffset") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.UInteger) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.UInteger) { msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.UInteger) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.UInteger) { msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount) } @(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") -AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.UInteger) { +AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.UInteger) { msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride) } @@ -91,31 +91,31 @@ Methods: MotionKeyframeData :: struct { using _: NS.Object } @(objc_type=MotionKeyframeData, objc_name="alloc", objc_is_class_method=true) -MotionKeyframeData_alloc :: #force_inline proc() -> ^MotionKeyframeData { +MotionKeyframeData_alloc :: #force_inline proc "c" () -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, MotionKeyframeData, "alloc") } @(objc_type=MotionKeyframeData, objc_name="data", objc_is_class_method=true) -MotionKeyframeData_data :: #force_inline proc() -> ^MotionKeyframeData { +MotionKeyframeData_data :: #force_inline proc "c" () -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, MotionKeyframeData, "data") } @(objc_type=MotionKeyframeData, objc_name="init", objc_is_class_method=true) -MotionKeyframeData_init :: #force_inline proc(self: ^MotionKeyframeData) -> ^MotionKeyframeData { +MotionKeyframeData_init :: #force_inline proc "c" (self: ^MotionKeyframeData) -> ^MotionKeyframeData { return msgSend(^MotionKeyframeData, self, "init") } @(objc_type=MotionKeyframeData, objc_name="buffer", objc_is_class_method=true) -MotionKeyframeData_buffer :: #force_inline proc(self: ^MotionKeyframeData) -> ^Buffer { +MotionKeyframeData_buffer :: #force_inline proc "c" (self: ^MotionKeyframeData) -> ^Buffer { return msgSend(^Buffer, self, "buffer") } @(objc_type=MotionKeyframeData, objc_name="setBuffer", objc_is_class_method=true) -MotionKeyframeData_setBuffer :: #force_inline proc(self: ^MotionKeyframeData, buffer: ^Buffer) { +MotionKeyframeData_setBuffer :: #force_inline proc "c" (self: ^MotionKeyframeData, buffer: ^Buffer) { msgSend(nil, self, "setBuffer:", buffer) } @(objc_type=MotionKeyframeData, objc_name="offset", objc_is_class_method=true) -MotionKeyframeData_offset :: #force_inline proc(self: ^MotionKeyframeData) -> NS.UInteger { +MotionKeyframeData_offset :: #force_inline proc "c" (self: ^MotionKeyframeData) -> NS.UInteger { return msgSend(NS.UInteger, self, "offset") } @(objc_type=MotionKeyframeData, objc_name="setOffset", objc_is_class_method=true) -MotionKeyframeData_setOffset :: #force_inline proc(self: ^MotionKeyframeData, offset: NS.UInteger) { +MotionKeyframeData_setOffset :: #force_inline proc "c" (self: ^MotionKeyframeData, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -130,93 +130,93 @@ Class: AccelerationStructureMotionTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionTriangleGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureMotionTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionTriangleGeometryDescriptor { +AccelerationStructureMotionTriangleGeometryDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureMotionTriangleGeometryDescriptor { return msgSend(^AccelerationStructureMotionTriangleGeometryDescriptor, AccelerationStructureMotionTriangleGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="init") -AccelerationStructureMotionTriangleGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^AccelerationStructureMotionTriangleGeometryDescriptor { +AccelerationStructureMotionTriangleGeometryDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^AccelerationStructureMotionTriangleGeometryDescriptor { return msgSend(^AccelerationStructureMotionTriangleGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="vertexBuffers") -AccelerationStructureMotionTriangleGeometryDescriptor_vertexBuffers :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^NS.Array { +AccelerationStructureMotionTriangleGeometryDescriptor_vertexBuffers :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexBuffers") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setVertexBuffers") -AccelerationStructureMotionTriangleGeometryDescriptor_setVertexBuffers :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffers: ^NS.Array) { +AccelerationStructureMotionTriangleGeometryDescriptor_setVertexBuffers :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffers: ^NS.Array) { msgSend(nil, self, "setVertexBuffers:", buffers) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="vertexStride") -AccelerationStructureMotionTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionTriangleGeometryDescriptor_vertexStride :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "vertexStride") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setVertexStride") -AccelerationStructureMotionTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, stride: NS.UInteger) { +AccelerationStructureMotionTriangleGeometryDescriptor_setVertexStride :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setVertexStride:", stride) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexBuffer") -AccelerationStructureMotionTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer { +AccelerationStructureMotionTriangleGeometryDescriptor_indexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "indexBuffer") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexBuffer") -AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffer: ^Buffer) { +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, buffer: ^Buffer) { msgSend(nil, self, "setIndexBuffer:", buffer) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexBufferOffset") -AccelerationStructureMotionTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "indexBufferOffset") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") -AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, offset: NS.UInteger) { +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setIndexBufferOffset:", offset) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="indexType") -AccelerationStructureMotionTriangleGeometryDescriptor_indexType :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> IndexType { +AccelerationStructureMotionTriangleGeometryDescriptor_indexType :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setIndexType") -AccelerationStructureMotionTriangleGeometryDescriptor_setIndexType :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, indexType: IndexType) { +AccelerationStructureMotionTriangleGeometryDescriptor_setIndexType :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="triangleCount") -AccelerationStructureMotionTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionTriangleGeometryDescriptor_triangleCount :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "triangleCount") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setTriangleCount") -AccelerationStructureMotionTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, count: NS.UInteger) { +AccelerationStructureMotionTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, count: NS.UInteger) { msgSend(nil, self, "setTriangleCount:", count) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="vertexFormat") -AccelerationStructureMotionTriangleGeometryDescriptor_vertexFormat :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> AttributeFormat { +AccelerationStructureMotionTriangleGeometryDescriptor_vertexFormat :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> AttributeFormat { return msgSend(AttributeFormat, self, "vertexFormat") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setVertexFormat") -AccelerationStructureMotionTriangleGeometryDescriptor_setVertexFormat :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, vertexFormat: AttributeFormat) { +AccelerationStructureMotionTriangleGeometryDescriptor_setVertexFormat :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, vertexFormat: AttributeFormat) { msgSend(nil, self, "setVertexFormat:", vertexFormat) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="transformationMatrixBuffer") -AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer { +AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBuffer :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "transformationMatrixBuffer") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setTransformationMatrixBuffer") -AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBuffer :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) { +AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBuffer :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) { msgSend(nil, self, "setTransformationMatrixBuffer:", transformationMatrixBuffer) } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="transformationMatrixBufferOffset") -AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "transformationMatrixBufferOffset") } @(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor, objc_name="setTransformationMatrixBufferOffset") -AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: #force_inline proc(self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBufferOffset: NS.UInteger) { +AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBufferOffset: NS.UInteger) { msgSend(nil, self, "setTransformationMatrixBufferOffset:", transformationMatrixBufferOffset) } @@ -231,43 +231,43 @@ Class: AccelerationStructureMotionBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureMotionBoundingBoxGeometryDescriptor), using _: AccelerationStructureGeometryDescriptor } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureMotionBoundingBoxGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="init") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) -AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor :: #force_inline proc "c" () -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor { return msgSend(^AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureMotionBoundingBoxGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffers") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxBuffers :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^NS.Array { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxBuffers :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "boundingBoxBuffers") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundBoxBuffers") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundBoxBuffers :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, buffers: ^NS.Array) { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundBoxBuffers :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, buffers: ^NS.Array) { msgSend(nil, self, "setBoundBoxBuffers:", buffers) } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxStride :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxStride") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, stride: NS.UInteger) { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxStride :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setBoundingBoxStride:", stride) } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_boundingBoxCount :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "boundingBoxCount") } @(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount") -AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc(self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, offset: NS.UInteger) { +AccelerationStructureMotionBoundingBoxGeometryDescriptor_setBoundingBoxCount :: #force_inline proc "c" (self: ^AccelerationStructureMotionBoundingBoxGeometryDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setBoundingBoxCount:", offset) } @@ -293,19 +293,19 @@ Methods: AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) } @(objc_type=AccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureDescriptor { +AccelerationStructureDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureDescriptor { return msgSend(^AccelerationStructureDescriptor, AccelerationStructureDescriptor, "alloc") } @(objc_type=AccelerationStructureDescriptor, objc_name="init") -AccelerationStructureDescriptor_init :: #force_inline proc(self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor { +AccelerationStructureDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor { return msgSend(^AccelerationStructureDescriptor, self, "init") } @(objc_type=AccelerationStructureDescriptor, objc_name="setUsage") -AccelerationStructureDescriptor_setUsage :: #force_inline proc(self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) { +AccelerationStructureDescriptor_setUsage :: #force_inline proc "c" (self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) { msgSend(nil, self, "setUsage:", usage) } @(objc_type=AccelerationStructureDescriptor, objc_name="usage") -AccelerationStructureDescriptor_usage :: #force_inline proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { +AccelerationStructureDescriptor_usage :: #force_inline proc "c" (self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage { return msgSend(AccelerationStructureUsage, self, "usage") } @@ -337,67 +337,67 @@ Methods: AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureGeometryDescriptor { +AccelerationStructureGeometryDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureGeometryDescriptor { return msgSend(^AccelerationStructureGeometryDescriptor, AccelerationStructureGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="init") -AccelerationStructureGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor { +AccelerationStructureGeometryDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor { return msgSend(^AccelerationStructureGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="allowDuplicateIntersectionFunctionInvocation") -AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { +AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> BOOL { return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="intersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { +AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "intersectionFunctionTableOffset") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="opaque") -AccelerationStructureGeometryDescriptor_opaque :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL { +AccelerationStructureGeometryDescriptor_opaque :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> BOOL { return msgSend(BOOL, self, "opaque") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setAllowDuplicateIntersectionFunctionInvocation") -AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { +AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) { msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setIntersectionFunctionTableOffset") -AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.UInteger) { +AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setOpaque") -AccelerationStructureGeometryDescriptor_setOpaque :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { +AccelerationStructureGeometryDescriptor_setOpaque :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) { msgSend(nil, self, "setOpaque:", opaque) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="primitiveDataBuffer") -AccelerationStructureGeometryDescriptor_primitiveDataBuffer :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> ^Buffer { +AccelerationStructureGeometryDescriptor_primitiveDataBuffer :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "primitiveDataBuffer") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setPrimitiveDataBuffer") -AccelerationStructureGeometryDescriptor_setPrimitiveDataBuffer :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, primitiveDataBuffer: ^Buffer) { +AccelerationStructureGeometryDescriptor_setPrimitiveDataBuffer :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, primitiveDataBuffer: ^Buffer) { msgSend(nil, self, "setPrimitiveDataBuffer:", primitiveDataBuffer) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="primitiveDataBufferOffset") -AccelerationStructureGeometryDescriptor_primitiveDataBufferOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { +AccelerationStructureGeometryDescriptor_primitiveDataBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "primitiveDataBufferOffset") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setPrimitiveDataBufferOffset") -AccelerationStructureGeometryDescriptor_setPrimitiveDataBufferOffset :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, offset: NS.UInteger) { +AccelerationStructureGeometryDescriptor_setPrimitiveDataBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setPrimitiveDataBufferOffset:", offset) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="primitiveDataStride") -AccelerationStructureGeometryDescriptor_primitiveDataStride :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { +AccelerationStructureGeometryDescriptor_primitiveDataStride :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "primitiveDataStride") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setPrimitiveDataStride") -AccelerationStructureGeometryDescriptor_setPrimitiveDataStride :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, stride: NS.UInteger) { +AccelerationStructureGeometryDescriptor_setPrimitiveDataStride :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setPrimitiveDataStride:", stride) } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="primitiveDataElementSize") -AccelerationStructureGeometryDescriptor_primitiveDataElementSize :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { +AccelerationStructureGeometryDescriptor_primitiveDataElementSize :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "primitiveDataElementSize") } @(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setPrimitiveDataElementSize") -AccelerationStructureGeometryDescriptor_setPrimitiveDataElementSize :: #force_inline proc(self: ^AccelerationStructureGeometryDescriptor, elementSize: NS.UInteger) { +AccelerationStructureGeometryDescriptor_setPrimitiveDataElementSize :: #force_inline proc "c" (self: ^AccelerationStructureGeometryDescriptor, elementSize: NS.UInteger) { msgSend(nil, self, "setPrimitiveDataElementSize:", elementSize) } @@ -438,97 +438,97 @@ Methods: AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "alloc") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="init") -AccelerationStructureTriangleGeometryDescriptor_init :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "init") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="descriptor", objc_is_class_method=true) -AccelerationStructureTriangleGeometryDescriptor_descriptor :: #force_inline proc() -> ^AccelerationStructureTriangleGeometryDescriptor { +AccelerationStructureTriangleGeometryDescriptor_descriptor :: #force_inline proc "c" () -> ^AccelerationStructureTriangleGeometryDescriptor { return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBuffer") -AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { +AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "indexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "indexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexType") -AccelerationStructureTriangleGeometryDescriptor_indexType :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { +AccelerationStructureTriangleGeometryDescriptor_indexType :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^Buffer) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^Buffer) { msgSend(nil, self, "setIndexBuffer:", indexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.UInteger) { +AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.UInteger) { msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexType") -AccelerationStructureTriangleGeometryDescriptor_setIndexType :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) { +AccelerationStructureTriangleGeometryDescriptor_setIndexType :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTriangleCount") -AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.UInteger) { +AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.UInteger) { msgSend(nil, self, "setTriangleCount:", triangleCount) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^Buffer) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^Buffer) { msgSend(nil, self, "setVertexBuffer:", vertexBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.UInteger) { +AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.UInteger) { msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexStride") -AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.UInteger) { +AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.UInteger) { msgSend(nil, self, "setVertexStride:", vertexStride) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="triangleCount") -AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureTriangleGeometryDescriptor_triangleCount :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "triangleCount") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer") -AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { +AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "vertexBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "vertexBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexStride") -AccelerationStructureTriangleGeometryDescriptor_vertexStride :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureTriangleGeometryDescriptor_vertexStride :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "vertexStride") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexFormat") -AccelerationStructureTriangleGeometryDescriptor_vertexFormat :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> AttributeFormat { +AccelerationStructureTriangleGeometryDescriptor_vertexFormat :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> AttributeFormat { return msgSend(AttributeFormat, self, "vertexFormat") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexFormat") -AccelerationStructureTriangleGeometryDescriptor_setVertexFormat :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexFormat: AttributeFormat) { +AccelerationStructureTriangleGeometryDescriptor_setVertexFormat :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, vertexFormat: AttributeFormat) { msgSend(nil, self, "setVertexFormat:", vertexFormat) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="transformationMatrixBuffer") -AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { +AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "transformationMatrixBuffer") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTransformationMatrixBuffer") -AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBuffer :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) { +AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBuffer :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) { msgSend(nil, self, "setTransformationMatrixBuffer:", transformationMatrixBuffer) } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="transformationMatrixBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { +AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "transformationMatrixBufferOffset") } @(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTransformationMatrixBufferOffset") -AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: #force_inline proc(self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBufferOffset: NS.UInteger) { +AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: #force_inline proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBufferOffset: NS.UInteger) { msgSend(nil, self, "setTransformationMatrixBufferOffset:", transformationMatrixBufferOffset) } @@ -562,75 +562,75 @@ Methods: Argument :: struct { using _: NS.Object } @(objc_type=Argument, objc_name="alloc", objc_is_class_method=true) -Argument_alloc :: #force_inline proc() -> ^Argument { +Argument_alloc :: #force_inline proc "c" () -> ^Argument { return msgSend(^Argument, Argument, "alloc") } @(objc_type=Argument, objc_name="init") -Argument_init :: #force_inline proc(self: ^Argument) -> ^Argument { +Argument_init :: #force_inline proc "c" (self: ^Argument) -> ^Argument { return msgSend(^Argument, self, "init") } @(objc_type=Argument, objc_name="access") -Argument_access :: #force_inline proc(self: ^Argument) -> ArgumentAccess { +Argument_access :: #force_inline proc "c" (self: ^Argument) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=Argument, objc_name="arrayLength") -Argument_arrayLength :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_arrayLength :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=Argument, objc_name="bufferAlignment") -Argument_bufferAlignment :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_bufferAlignment :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferAlignment") } @(objc_type=Argument, objc_name="bufferDataSize") -Argument_bufferDataSize :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_bufferDataSize :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferDataSize") } @(objc_type=Argument, objc_name="bufferDataType") -Argument_bufferDataType :: #force_inline proc(self: ^Argument) -> DataType { +Argument_bufferDataType :: #force_inline proc "c" (self: ^Argument) -> DataType { return msgSend(DataType, self, "bufferDataType") } @(objc_type=Argument, objc_name="bufferPointerType") -Argument_bufferPointerType :: #force_inline proc(self: ^Argument) -> ^PointerType { +Argument_bufferPointerType :: #force_inline proc "c" (self: ^Argument) -> ^PointerType { return msgSend(^PointerType, self, "bufferPointerType") } @(objc_type=Argument, objc_name="bufferStructType") -Argument_bufferStructType :: #force_inline proc(self: ^Argument) -> ^StructType { +Argument_bufferStructType :: #force_inline proc "c" (self: ^Argument) -> ^StructType { return msgSend(^StructType, self, "bufferStructType") } @(objc_type=Argument, objc_name="index") -Argument_index :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_index :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "index") } @(objc_type=Argument, objc_name="isActive") -Argument_isActive :: #force_inline proc(self: ^Argument) -> BOOL { +Argument_isActive :: #force_inline proc "c" (self: ^Argument) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=Argument, objc_name="isDepthTexture") -Argument_isDepthTexture :: #force_inline proc(self: ^Argument) -> BOOL { +Argument_isDepthTexture :: #force_inline proc "c" (self: ^Argument) -> BOOL { return msgSend(BOOL, self, "isDepthTexture") } @(objc_type=Argument, objc_name="name") -Argument_name :: #force_inline proc(self: ^Argument) -> ^NS.String { +Argument_name :: #force_inline proc "c" (self: ^Argument) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Argument, objc_name="textureDataType") -Argument_textureDataType :: #force_inline proc(self: ^Argument) -> DataType { +Argument_textureDataType :: #force_inline proc "c" (self: ^Argument) -> DataType { return msgSend(DataType, self, "textureDataType") } @(objc_type=Argument, objc_name="textureType") -Argument_textureType :: #force_inline proc(self: ^Argument) -> TextureType { +Argument_textureType :: #force_inline proc "c" (self: ^Argument) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=Argument, objc_name="threadgroupMemoryAlignment") -Argument_threadgroupMemoryAlignment :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_threadgroupMemoryAlignment :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadgroupMemoryAlignment") } @(objc_type=Argument, objc_name="threadgroupMemoryDataSize") -Argument_threadgroupMemoryDataSize :: #force_inline proc(self: ^Argument) -> NS.UInteger { +Argument_threadgroupMemoryDataSize :: #force_inline proc "c" (self: ^Argument) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadgroupMemoryDataSize") } @(objc_type=Argument, objc_name="type") -Argument_type :: #force_inline proc(self: ^Argument) -> ArgumentType { +Argument_type :: #force_inline proc "c" (self: ^Argument) -> ArgumentType { return msgSend(ArgumentType, self, "type") } @@ -661,63 +661,63 @@ Methods: ArgumentDescriptor :: struct { using _: NS.Copying(ArgumentDescriptor) } @(objc_type=ArgumentDescriptor, objc_name="alloc", objc_is_class_method=true) -ArgumentDescriptor_alloc :: #force_inline proc() -> ^ArgumentDescriptor { +ArgumentDescriptor_alloc :: #force_inline proc "c" () -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "alloc") } @(objc_type=ArgumentDescriptor, objc_name="init") -ArgumentDescriptor_init :: #force_inline proc(self: ^ArgumentDescriptor) -> ^ArgumentDescriptor { +ArgumentDescriptor_init :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, self, "init") } @(objc_type=ArgumentDescriptor, objc_name="access") -ArgumentDescriptor_access :: #force_inline proc(self: ^ArgumentDescriptor) -> ArgumentAccess { +ArgumentDescriptor_access :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=ArgumentDescriptor, objc_name="argumentDescriptor", objc_is_class_method=true) -ArgumentDescriptor_argumentDescriptor :: #force_inline proc() -> ^ArgumentDescriptor { +ArgumentDescriptor_argumentDescriptor :: #force_inline proc "c" () -> ^ArgumentDescriptor { return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor") } @(objc_type=ArgumentDescriptor, objc_name="arrayLength") -ArgumentDescriptor_arrayLength :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { +ArgumentDescriptor_arrayLength :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=ArgumentDescriptor, objc_name="constantBlockAlignment") -ArgumentDescriptor_constantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { +ArgumentDescriptor_constantBlockAlignment :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "constantBlockAlignment") } @(objc_type=ArgumentDescriptor, objc_name="dataType") -ArgumentDescriptor_dataType :: #force_inline proc(self: ^ArgumentDescriptor) -> DataType { +ArgumentDescriptor_dataType :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> DataType { return msgSend(DataType, self, "dataType") } @(objc_type=ArgumentDescriptor, objc_name="index") -ArgumentDescriptor_index :: #force_inline proc(self: ^ArgumentDescriptor) -> NS.UInteger { +ArgumentDescriptor_index :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "index") } @(objc_type=ArgumentDescriptor, objc_name="setAccess") -ArgumentDescriptor_setAccess :: #force_inline proc(self: ^ArgumentDescriptor, access: ArgumentAccess) { +ArgumentDescriptor_setAccess :: #force_inline proc "c" (self: ^ArgumentDescriptor, access: ArgumentAccess) { msgSend(nil, self, "setAccess:", access) } @(objc_type=ArgumentDescriptor, objc_name="setArrayLength") -ArgumentDescriptor_setArrayLength :: #force_inline proc(self: ^ArgumentDescriptor, arrayLength: NS.UInteger) { +ArgumentDescriptor_setArrayLength :: #force_inline proc "c" (self: ^ArgumentDescriptor, arrayLength: NS.UInteger) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=ArgumentDescriptor, objc_name="setConstantBlockAlignment") -ArgumentDescriptor_setConstantBlockAlignment :: #force_inline proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.UInteger) { +ArgumentDescriptor_setConstantBlockAlignment :: #force_inline proc "c" (self: ^ArgumentDescriptor, constantBlockAlignment: NS.UInteger) { msgSend(nil, self, "setConstantBlockAlignment:", constantBlockAlignment) } @(objc_type=ArgumentDescriptor, objc_name="setDataType") -ArgumentDescriptor_setDataType :: #force_inline proc(self: ^ArgumentDescriptor, dataType: DataType) { +ArgumentDescriptor_setDataType :: #force_inline proc "c" (self: ^ArgumentDescriptor, dataType: DataType) { msgSend(nil, self, "setDataType:", dataType) } @(objc_type=ArgumentDescriptor, objc_name="setIndex") -ArgumentDescriptor_setIndex :: #force_inline proc(self: ^ArgumentDescriptor, index: NS.UInteger) { +ArgumentDescriptor_setIndex :: #force_inline proc "c" (self: ^ArgumentDescriptor, index: NS.UInteger) { msgSend(nil, self, "setIndex:", index) } @(objc_type=ArgumentDescriptor, objc_name="setTextureType") -ArgumentDescriptor_setTextureType :: #force_inline proc(self: ^ArgumentDescriptor, textureType: TextureType) { +ArgumentDescriptor_setTextureType :: #force_inline proc "c" (self: ^ArgumentDescriptor, textureType: TextureType) { msgSend(nil, self, "setTextureType:", textureType) } @(objc_type=ArgumentDescriptor, objc_name="textureType") -ArgumentDescriptor_textureType :: #force_inline proc(self: ^ArgumentDescriptor) -> TextureType { +ArgumentDescriptor_textureType :: #force_inline proc "c" (self: ^ArgumentDescriptor) -> TextureType { return msgSend(TextureType, self, "textureType") } @@ -743,43 +743,43 @@ Methods: ArrayType :: struct { using _: Type } @(objc_type=ArrayType, objc_name="alloc", objc_is_class_method=true) -ArrayType_alloc :: #force_inline proc() -> ^ArrayType { +ArrayType_alloc :: #force_inline proc "c" () -> ^ArrayType { return msgSend(^ArrayType, ArrayType, "alloc") } @(objc_type=ArrayType, objc_name="init") -ArrayType_init :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { +ArrayType_init :: #force_inline proc "c" (self: ^ArrayType) -> ^ArrayType { return msgSend(^ArrayType, self, "init") } @(objc_type=ArrayType, objc_name="argumentIndexStride") -ArrayType_argumentIndexStride :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { +ArrayType_argumentIndexStride :: #force_inline proc "c" (self: ^ArrayType) -> NS.UInteger { return msgSend(NS.UInteger, self, "argumentIndexStride") } @(objc_type=ArrayType, objc_name="arrayLength") -ArrayType_arrayLength :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { +ArrayType_arrayLength :: #force_inline proc "c" (self: ^ArrayType) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=ArrayType, objc_name="elementArrayType") -ArrayType_elementArrayType :: #force_inline proc(self: ^ArrayType) -> ^ArrayType { +ArrayType_elementArrayType :: #force_inline proc "c" (self: ^ArrayType) -> ^ArrayType { return msgSend(^ArrayType, self, "elementArrayType") } @(objc_type=ArrayType, objc_name="elementPointerType") -ArrayType_elementPointerType :: #force_inline proc(self: ^ArrayType) -> ^PointerType { +ArrayType_elementPointerType :: #force_inline proc "c" (self: ^ArrayType) -> ^PointerType { return msgSend(^PointerType, self, "elementPointerType") } @(objc_type=ArrayType, objc_name="elementStructType") -ArrayType_elementStructType :: #force_inline proc(self: ^ArrayType) -> ^StructType { +ArrayType_elementStructType :: #force_inline proc "c" (self: ^ArrayType) -> ^StructType { return msgSend(^StructType, self, "elementStructType") } @(objc_type=ArrayType, objc_name="elementTextureReferenceType") -ArrayType_elementTextureReferenceType :: #force_inline proc(self: ^ArrayType) -> ^TextureReferenceType { +ArrayType_elementTextureReferenceType :: #force_inline proc "c" (self: ^ArrayType) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "elementTextureReferenceType") } @(objc_type=ArrayType, objc_name="elementType") -ArrayType_elementType :: #force_inline proc(self: ^ArrayType) -> DataType { +ArrayType_elementType :: #force_inline proc "c" (self: ^ArrayType) -> DataType { return msgSend(DataType, self, "elementType") } @(objc_type=ArrayType, objc_name="stride") -ArrayType_stride :: #force_inline proc(self: ^ArrayType) -> NS.UInteger { +ArrayType_stride :: #force_inline proc "c" (self: ^ArrayType) -> NS.UInteger { return msgSend(NS.UInteger, self, "stride") } @@ -803,35 +803,35 @@ Methods: Attribute :: struct { using _: NS.Object } @(objc_type=Attribute, objc_name="alloc", objc_is_class_method=true) -Attribute_alloc :: #force_inline proc() -> ^Attribute { +Attribute_alloc :: #force_inline proc "c" () -> ^Attribute { return msgSend(^Attribute, Attribute, "alloc") } @(objc_type=Attribute, objc_name="init") -Attribute_init :: #force_inline proc(self: ^Attribute) -> ^Attribute { +Attribute_init :: #force_inline proc "c" (self: ^Attribute) -> ^Attribute { return msgSend(^Attribute, self, "init") } @(objc_type=Attribute, objc_name="attributeIndex") -Attribute_attributeIndex :: #force_inline proc(self: ^Attribute) -> NS.UInteger { +Attribute_attributeIndex :: #force_inline proc "c" (self: ^Attribute) -> NS.UInteger { return msgSend(NS.UInteger, self, "attributeIndex") } @(objc_type=Attribute, objc_name="attributeType") -Attribute_attributeType :: #force_inline proc(self: ^Attribute) -> DataType { +Attribute_attributeType :: #force_inline proc "c" (self: ^Attribute) -> DataType { return msgSend(DataType, self, "attributeType") } @(objc_type=Attribute, objc_name="isActive") -Attribute_isActive :: #force_inline proc(self: ^Attribute) -> BOOL { +Attribute_isActive :: #force_inline proc "c" (self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=Attribute, objc_name="isPatchControlPointData") -Attribute_isPatchControlPointData :: #force_inline proc(self: ^Attribute) -> BOOL { +Attribute_isPatchControlPointData :: #force_inline proc "c" (self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isPatchControlPointData") } @(objc_type=Attribute, objc_name="isPatchData") -Attribute_isPatchData :: #force_inline proc(self: ^Attribute) -> BOOL { +Attribute_isPatchData :: #force_inline proc "c" (self: ^Attribute) -> BOOL { return msgSend(BOOL, self, "isPatchData") } @(objc_type=Attribute, objc_name="name") -Attribute_name :: #force_inline proc(self: ^Attribute) -> ^NS.String { +Attribute_name :: #force_inline proc "c" (self: ^Attribute) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -855,35 +855,35 @@ Methods: AttributeDescriptor :: struct { using _: NS.Copying(AttributeDescriptor) } @(objc_type=AttributeDescriptor, objc_name="alloc", objc_is_class_method=true) -AttributeDescriptor_alloc :: #force_inline proc() -> ^AttributeDescriptor { +AttributeDescriptor_alloc :: #force_inline proc "c" () -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, AttributeDescriptor, "alloc") } @(objc_type=AttributeDescriptor, objc_name="init") -AttributeDescriptor_init :: #force_inline proc(self: ^AttributeDescriptor) -> ^AttributeDescriptor { +AttributeDescriptor_init :: #force_inline proc "c" (self: ^AttributeDescriptor) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "init") } @(objc_type=AttributeDescriptor, objc_name="bufferIndex") -AttributeDescriptor_bufferIndex :: #force_inline proc(self: ^AttributeDescriptor) -> NS.UInteger { +AttributeDescriptor_bufferIndex :: #force_inline proc "c" (self: ^AttributeDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferIndex") } @(objc_type=AttributeDescriptor, objc_name="format") -AttributeDescriptor_format :: #force_inline proc(self: ^AttributeDescriptor) -> AttributeFormat { +AttributeDescriptor_format :: #force_inline proc "c" (self: ^AttributeDescriptor) -> AttributeFormat { return msgSend(AttributeFormat, self, "format") } @(objc_type=AttributeDescriptor, objc_name="offset") -AttributeDescriptor_offset :: #force_inline proc(self: ^AttributeDescriptor) -> NS.UInteger { +AttributeDescriptor_offset :: #force_inline proc "c" (self: ^AttributeDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "offset") } @(objc_type=AttributeDescriptor, objc_name="setBufferIndex") -AttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^AttributeDescriptor, bufferIndex: NS.UInteger) { +AttributeDescriptor_setBufferIndex :: #force_inline proc "c" (self: ^AttributeDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=AttributeDescriptor, objc_name="setFormat") -AttributeDescriptor_setFormat :: #force_inline proc(self: ^AttributeDescriptor, format: AttributeFormat) { +AttributeDescriptor_setFormat :: #force_inline proc "c" (self: ^AttributeDescriptor, format: AttributeFormat) { msgSend(nil, self, "setFormat:", format) } @(objc_type=AttributeDescriptor, objc_name="setOffset") -AttributeDescriptor_setOffset :: #force_inline proc(self: ^AttributeDescriptor, offset: NS.UInteger) { +AttributeDescriptor_setOffset :: #force_inline proc "c" (self: ^AttributeDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -903,19 +903,19 @@ Methods: AttributeDescriptorArray :: struct { using _: NS.Object } @(objc_type=AttributeDescriptorArray, objc_name="alloc", objc_is_class_method=true) -AttributeDescriptorArray_alloc :: #force_inline proc() -> ^AttributeDescriptorArray { +AttributeDescriptorArray_alloc :: #force_inline proc "c" () -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, AttributeDescriptorArray, "alloc") } @(objc_type=AttributeDescriptorArray, objc_name="init") -AttributeDescriptorArray_init :: #force_inline proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { +AttributeDescriptorArray_init :: #force_inline proc "c" (self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, self, "init") } @(objc_type=AttributeDescriptorArray, objc_name="object") -AttributeDescriptorArray_object :: #force_inline proc(self: ^AttributeDescriptorArray, index: NS.UInteger) -> ^AttributeDescriptor { +AttributeDescriptorArray_object :: #force_inline proc "c" (self: ^AttributeDescriptorArray, index: NS.UInteger) -> ^AttributeDescriptor { return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=AttributeDescriptorArray, objc_name="setObject") -AttributeDescriptorArray_setObject :: #force_inline proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: NS.UInteger) { +AttributeDescriptorArray_setObject :: #force_inline proc "c" (self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -935,19 +935,19 @@ Methods: BinaryArchiveDescriptor :: struct { using _: NS.Copying(BinaryArchiveDescriptor) } @(objc_type=BinaryArchiveDescriptor, objc_name="alloc", objc_is_class_method=true) -BinaryArchiveDescriptor_alloc :: #force_inline proc() -> ^BinaryArchiveDescriptor { +BinaryArchiveDescriptor_alloc :: #force_inline proc "c" () -> ^BinaryArchiveDescriptor { return msgSend(^BinaryArchiveDescriptor, BinaryArchiveDescriptor, "alloc") } @(objc_type=BinaryArchiveDescriptor, objc_name="init") -BinaryArchiveDescriptor_init :: #force_inline proc(self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor { +BinaryArchiveDescriptor_init :: #force_inline proc "c" (self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor { return msgSend(^BinaryArchiveDescriptor, self, "init") } @(objc_type=BinaryArchiveDescriptor, objc_name="setUrl") -BinaryArchiveDescriptor_setUrl :: #force_inline proc(self: ^BinaryArchiveDescriptor, url: ^NS.URL) { +BinaryArchiveDescriptor_setUrl :: #force_inline proc "c" (self: ^BinaryArchiveDescriptor, url: ^NS.URL) { msgSend(nil, self, "setUrl:", url) } @(objc_type=BinaryArchiveDescriptor, objc_name="url") -BinaryArchiveDescriptor_url :: #force_inline proc(self: ^BinaryArchiveDescriptor) -> ^NS.URL { +BinaryArchiveDescriptor_url :: #force_inline proc "c" (self: ^BinaryArchiveDescriptor) -> ^NS.URL { return msgSend(^NS.URL, self, "url") } @@ -967,19 +967,19 @@ Methods: BlitPassDescriptor :: struct { using _: NS.Copying(BlitPassDescriptor) } @(objc_type=BlitPassDescriptor, objc_name="alloc", objc_is_class_method=true) -BlitPassDescriptor_alloc :: #force_inline proc() -> ^BlitPassDescriptor { +BlitPassDescriptor_alloc :: #force_inline proc "c" () -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "alloc") } @(objc_type=BlitPassDescriptor, objc_name="init") -BlitPassDescriptor_init :: #force_inline proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { +BlitPassDescriptor_init :: #force_inline proc "c" (self: ^BlitPassDescriptor) -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, self, "init") } @(objc_type=BlitPassDescriptor, objc_name="blitPassDescriptor", objc_is_class_method=true) -BlitPassDescriptor_blitPassDescriptor :: #force_inline proc() -> ^BlitPassDescriptor { +BlitPassDescriptor_blitPassDescriptor :: #force_inline proc "c" () -> ^BlitPassDescriptor { return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "blitPassDescriptor") } @(objc_type=BlitPassDescriptor, objc_name="sampleBufferAttachments") -BlitPassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassDescriptor_sampleBufferAttachments :: #force_inline proc "c" (self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @@ -1003,35 +1003,35 @@ Methods: BlitPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(BlitPassSampleBufferAttachmentDescriptor) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -BlitPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, BlitPassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="init") -BlitPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptor_init :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { +BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { +BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { +BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { +BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } @@ -1051,19 +1051,19 @@ Methods: BlitPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -BlitPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, BlitPassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="init") -BlitPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { +BlitPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray { return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="object") -BlitPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^BlitPassSampleBufferAttachmentDescriptor { +BlitPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^BlitPassSampleBufferAttachmentDescriptor { return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -BlitPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { +BlitPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -1087,35 +1087,35 @@ Methods: BufferLayoutDescriptor :: struct { using _: NS.Copying(BufferLayoutDescriptor) } @(objc_type=BufferLayoutDescriptor, objc_name="alloc", objc_is_class_method=true) -BufferLayoutDescriptor_alloc :: #force_inline proc() -> ^BufferLayoutDescriptor { +BufferLayoutDescriptor_alloc :: #force_inline proc "c" () -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, BufferLayoutDescriptor, "alloc") } @(objc_type=BufferLayoutDescriptor, objc_name="init") -BufferLayoutDescriptor_init :: #force_inline proc(self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor { +BufferLayoutDescriptor_init :: #force_inline proc "c" (self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "init") } @(objc_type=BufferLayoutDescriptor, objc_name="setStepFunction") -BufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^BufferLayoutDescriptor, stepFunction: StepFunction) { +BufferLayoutDescriptor_setStepFunction :: #force_inline proc "c" (self: ^BufferLayoutDescriptor, stepFunction: StepFunction) { msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=BufferLayoutDescriptor, objc_name="setStepRate") -BufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^BufferLayoutDescriptor, stepRate: NS.UInteger) { +BufferLayoutDescriptor_setStepRate :: #force_inline proc "c" (self: ^BufferLayoutDescriptor, stepRate: NS.UInteger) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=BufferLayoutDescriptor, objc_name="setStride") -BufferLayoutDescriptor_setStride :: #force_inline proc(self: ^BufferLayoutDescriptor, stride: NS.UInteger) { +BufferLayoutDescriptor_setStride :: #force_inline proc "c" (self: ^BufferLayoutDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setStride:", stride) } @(objc_type=BufferLayoutDescriptor, objc_name="stepFunction") -BufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^BufferLayoutDescriptor) -> StepFunction { +BufferLayoutDescriptor_stepFunction :: #force_inline proc "c" (self: ^BufferLayoutDescriptor) -> StepFunction { return msgSend(StepFunction, self, "stepFunction") } @(objc_type=BufferLayoutDescriptor, objc_name="stepRate") -BufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.UInteger { +BufferLayoutDescriptor_stepRate :: #force_inline proc "c" (self: ^BufferLayoutDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "stepRate") } @(objc_type=BufferLayoutDescriptor, objc_name="stride") -BufferLayoutDescriptor_stride :: #force_inline proc(self: ^BufferLayoutDescriptor) -> NS.UInteger { +BufferLayoutDescriptor_stride :: #force_inline proc "c" (self: ^BufferLayoutDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "stride") } @@ -1135,19 +1135,19 @@ Methods: BufferLayoutDescriptorArray :: struct { using _: NS.Object } @(objc_type=BufferLayoutDescriptorArray, objc_name="alloc", objc_is_class_method=true) -BufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^BufferLayoutDescriptorArray { +BufferLayoutDescriptorArray_alloc :: #force_inline proc "c" () -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, BufferLayoutDescriptorArray, "alloc") } @(objc_type=BufferLayoutDescriptorArray, objc_name="init") -BufferLayoutDescriptorArray_init :: #force_inline proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { +BufferLayoutDescriptorArray_init :: #force_inline proc "c" (self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, self, "init") } @(objc_type=BufferLayoutDescriptorArray, objc_name="object") -BufferLayoutDescriptorArray_object :: #force_inline proc(self: ^BufferLayoutDescriptorArray, index: NS.UInteger) -> ^BufferLayoutDescriptor { +BufferLayoutDescriptorArray_object :: #force_inline proc "c" (self: ^BufferLayoutDescriptorArray, index: NS.UInteger) -> ^BufferLayoutDescriptor { return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=BufferLayoutDescriptorArray, objc_name="setObject") -BufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: NS.UInteger) { +BufferLayoutDescriptorArray_setObject :: #force_inline proc "c" (self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -1171,35 +1171,35 @@ Methods: CaptureDescriptor :: struct { using _: NS.Copying(CaptureDescriptor) } @(objc_type=CaptureDescriptor, objc_name="alloc", objc_is_class_method=true) -CaptureDescriptor_alloc :: #force_inline proc() -> ^CaptureDescriptor { +CaptureDescriptor_alloc :: #force_inline proc "c" () -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, CaptureDescriptor, "alloc") } @(objc_type=CaptureDescriptor, objc_name="init") -CaptureDescriptor_init :: #force_inline proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor { +CaptureDescriptor_init :: #force_inline proc "c" (self: ^CaptureDescriptor) -> ^CaptureDescriptor { return msgSend(^CaptureDescriptor, self, "init") } @(objc_type=CaptureDescriptor, objc_name="captureObject") -CaptureDescriptor_captureObject :: #force_inline proc(self: ^CaptureDescriptor) -> id { +CaptureDescriptor_captureObject :: #force_inline proc "c" (self: ^CaptureDescriptor) -> id { return msgSend(id, self, "captureObject") } @(objc_type=CaptureDescriptor, objc_name="destination") -CaptureDescriptor_destination :: #force_inline proc(self: ^CaptureDescriptor) -> CaptureDestination { +CaptureDescriptor_destination :: #force_inline proc "c" (self: ^CaptureDescriptor) -> CaptureDestination { return msgSend(CaptureDestination, self, "destination") } @(objc_type=CaptureDescriptor, objc_name="outputURL") -CaptureDescriptor_outputURL :: #force_inline proc(self: ^CaptureDescriptor) -> ^NS.URL { +CaptureDescriptor_outputURL :: #force_inline proc "c" (self: ^CaptureDescriptor) -> ^NS.URL { return msgSend(^NS.URL, self, "outputURL") } @(objc_type=CaptureDescriptor, objc_name="setCaptureObject") -CaptureDescriptor_setCaptureObject :: #force_inline proc(self: ^CaptureDescriptor, captureObject: id) { +CaptureDescriptor_setCaptureObject :: #force_inline proc "c" (self: ^CaptureDescriptor, captureObject: id) { msgSend(nil, self, "setCaptureObject:", captureObject) } @(objc_type=CaptureDescriptor, objc_name="setDestination") -CaptureDescriptor_setDestination :: #force_inline proc(self: ^CaptureDescriptor, destination: CaptureDestination) { +CaptureDescriptor_setDestination :: #force_inline proc "c" (self: ^CaptureDescriptor, destination: CaptureDestination) { msgSend(nil, self, "setDestination:", destination) } @(objc_type=CaptureDescriptor, objc_name="setOutputURL") -CaptureDescriptor_setOutputURL :: #force_inline proc(self: ^CaptureDescriptor, outputURL: ^NS.URL) { +CaptureDescriptor_setOutputURL :: #force_inline proc "c" (self: ^CaptureDescriptor, outputURL: ^NS.URL) { msgSend(nil, self, "setOutputURL:", outputURL) } @@ -1229,27 +1229,27 @@ Methods: CaptureManager :: struct { using _: NS.Object } @(objc_type=CaptureManager, objc_name="alloc", objc_is_class_method=true) -CaptureManager_alloc :: #force_inline proc() -> ^CaptureManager { +CaptureManager_alloc :: #force_inline proc "c" () -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "alloc") } @(objc_type=CaptureManager, objc_name="defaultCaptureScope") -CaptureManager_defaultCaptureScope :: #force_inline proc(self: ^CaptureManager) -> ^CaptureManager { +CaptureManager_defaultCaptureScope :: #force_inline proc "c" (self: ^CaptureManager) -> ^CaptureManager { return msgSend(^CaptureManager, self, "defaultCaptureScope") } @(objc_type=CaptureManager, objc_name="init") -CaptureManager_init :: #force_inline proc(self: ^CaptureManager) -> ^CaptureManager { +CaptureManager_init :: #force_inline proc "c" (self: ^CaptureManager) -> ^CaptureManager { return msgSend(^CaptureManager, self, "init") } @(objc_type=CaptureManager, objc_name="isCapturing") -CaptureManager_isCapturing :: #force_inline proc(self: ^CaptureManager) -> BOOL { +CaptureManager_isCapturing :: #force_inline proc "c" (self: ^CaptureManager) -> BOOL { return msgSend(BOOL, self, "isCapturing") } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue") -CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureScope { +CaptureManager_newCaptureScopeWithCommandQueue :: #force_inline proc "c" (self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureScope { return msgSend(^CaptureScope, self, "newCaptureScopeWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice") -CaptureManager_newCaptureScopeWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) -> ^CaptureScope { +CaptureManager_newCaptureScopeWithDevice :: #force_inline proc "c" (self: ^CaptureManager, device: ^Device) -> ^CaptureScope { return msgSend(^CaptureScope, self, "newCaptureScopeWithDevice:", device) } @(objc_type=CaptureManager, objc_name="newCaptureScope") @@ -1259,36 +1259,36 @@ CaptureManager_newCaptureScope :: proc{ } @(objc_type=CaptureManager, objc_name="setDefaultCaptureScope") -CaptureManager_setDefaultCaptureScope :: #force_inline proc(self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) { +CaptureManager_setDefaultCaptureScope :: #force_inline proc "c" (self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) { msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope) } @(objc_type=CaptureManager, objc_name="sharedCaptureManager", objc_is_class_method=true) -CaptureManager_sharedCaptureManager :: #force_inline proc() -> ^CaptureManager { +CaptureManager_sharedCaptureManager :: #force_inline proc "c" () -> ^CaptureManager { return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager") } @(objc_type=CaptureManager, objc_name="startCaptureWithCommandQueue") -CaptureManager_startCaptureWithCommandQueue :: #force_inline proc(self: ^CaptureManager, commandQueue: ^CommandQueue) { +CaptureManager_startCaptureWithCommandQueue :: #force_inline proc "c" (self: ^CaptureManager, commandQueue: ^CommandQueue) { msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue) } @(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor") -CaptureManager_startCaptureWithDescriptor :: #force_inline proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: BOOL, error: ^NS.Error) { +CaptureManager_startCaptureWithDescriptor :: #force_inline proc "contextless" (self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, &error) return } @(objc_type=CaptureManager, objc_name="startCaptureWithDevice") -CaptureManager_startCaptureWithDevice :: #force_inline proc(self: ^CaptureManager, device: ^Device) { +CaptureManager_startCaptureWithDevice :: #force_inline proc "c" (self: ^CaptureManager, device: ^Device) { msgSend(nil, self, "startCaptureWithDevice:", device) } @(objc_type=CaptureManager, objc_name="startCaptureWithScope") -CaptureManager_startCaptureWithScope :: #force_inline proc(self: ^CaptureManager, captureScope: ^CaptureScope) { +CaptureManager_startCaptureWithScope :: #force_inline proc "c" (self: ^CaptureManager, captureScope: ^CaptureScope) { msgSend(nil, self, "startCaptureWithScope:", captureScope) } @(objc_type=CaptureManager, objc_name="stopCapture") -CaptureManager_stopCapture :: #force_inline proc(self: ^CaptureManager) { +CaptureManager_stopCapture :: #force_inline proc "c" (self: ^CaptureManager) { msgSend(nil, self, "stopCapture") } @(objc_type=CaptureManager, objc_name="supportsDestination") -CaptureManager_supportsDestination :: #force_inline proc(self: ^CaptureManager, destination: CaptureDestination) -> BOOL { +CaptureManager_supportsDestination :: #force_inline proc "c" (self: ^CaptureManager, destination: CaptureDestination) -> BOOL { return msgSend(BOOL, self, "supportsDestination:", destination) } @@ -1310,27 +1310,27 @@ Methods: CommandBufferDescriptor :: struct { using _: NS.Copying(CommandBufferDescriptor) } @(objc_type=CommandBufferDescriptor, objc_name="alloc", objc_is_class_method=true) -CommandBufferDescriptor_alloc :: #force_inline proc() -> ^CommandBufferDescriptor { +CommandBufferDescriptor_alloc :: #force_inline proc "c" () -> ^CommandBufferDescriptor { return msgSend(^CommandBufferDescriptor, CommandBufferDescriptor, "alloc") } @(objc_type=CommandBufferDescriptor, objc_name="init") -CommandBufferDescriptor_init :: #force_inline proc(self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor { +CommandBufferDescriptor_init :: #force_inline proc "c" (self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor { return msgSend(^CommandBufferDescriptor, self, "init") } @(objc_type=CommandBufferDescriptor, objc_name="errorOptions") -CommandBufferDescriptor_errorOptions :: #force_inline proc(self: ^CommandBufferDescriptor) -> CommandBufferErrorOption { +CommandBufferDescriptor_errorOptions :: #force_inline proc "c" (self: ^CommandBufferDescriptor) -> CommandBufferErrorOption { return msgSend(CommandBufferErrorOption, self, "errorOptions") } @(objc_type=CommandBufferDescriptor, objc_name="retainedReferences") -CommandBufferDescriptor_retainedReferences :: #force_inline proc(self: ^CommandBufferDescriptor) -> BOOL { +CommandBufferDescriptor_retainedReferences :: #force_inline proc "c" (self: ^CommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "retainedReferences") } @(objc_type=CommandBufferDescriptor, objc_name="setErrorOptions") -CommandBufferDescriptor_setErrorOptions :: #force_inline proc(self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) { +CommandBufferDescriptor_setErrorOptions :: #force_inline proc "c" (self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) { msgSend(nil, self, "setErrorOptions:", errorOptions) } @(objc_type=CommandBufferDescriptor, objc_name="setRetainedReferences") -CommandBufferDescriptor_setRetainedReferences :: #force_inline proc(self: ^CommandBufferDescriptor, retainedReferences: BOOL) { +CommandBufferDescriptor_setRetainedReferences :: #force_inline proc "c" (self: ^CommandBufferDescriptor, retainedReferences: BOOL) { msgSend(nil, self, "setRetainedReferences:", retainedReferences) } @@ -1362,75 +1362,75 @@ Methods: CompileOptions :: struct { using _: NS.Copying(CompileOptions) } @(objc_type=CompileOptions, objc_name="alloc", objc_is_class_method=true) -CompileOptions_alloc :: #force_inline proc() -> ^CompileOptions { +CompileOptions_alloc :: #force_inline proc "c" () -> ^CompileOptions { return msgSend(^CompileOptions, CompileOptions, "alloc") } @(objc_type=CompileOptions, objc_name="init") -CompileOptions_init :: #force_inline proc(self: ^CompileOptions) -> ^CompileOptions { +CompileOptions_init :: #force_inline proc "c" (self: ^CompileOptions) -> ^CompileOptions { return msgSend(^CompileOptions, self, "init") } @(objc_type=CompileOptions, objc_name="fastMathEnabled") -CompileOptions_fastMathEnabled :: #force_inline proc(self: ^CompileOptions) -> BOOL { +CompileOptions_fastMathEnabled :: #force_inline proc "c" (self: ^CompileOptions) -> BOOL { return msgSend(BOOL, self, "fastMathEnabled") } @(objc_type=CompileOptions, objc_name="installName") -CompileOptions_installName :: #force_inline proc(self: ^CompileOptions) -> ^NS.String { +CompileOptions_installName :: #force_inline proc "c" (self: ^CompileOptions) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=CompileOptions, objc_name="languageVersion") -CompileOptions_languageVersion :: #force_inline proc(self: ^CompileOptions) -> LanguageVersion { +CompileOptions_languageVersion :: #force_inline proc "c" (self: ^CompileOptions) -> LanguageVersion { return msgSend(LanguageVersion, self, "languageVersion") } @(objc_type=CompileOptions, objc_name="libraries") -CompileOptions_libraries :: #force_inline proc(self: ^CompileOptions) -> ^NS.Array { +CompileOptions_libraries :: #force_inline proc "c" (self: ^CompileOptions) -> ^NS.Array { return msgSend(^NS.Array, self, "libraries") } @(objc_type=CompileOptions, objc_name="libraryType") -CompileOptions_libraryType :: #force_inline proc(self: ^CompileOptions) -> LibraryType { +CompileOptions_libraryType :: #force_inline proc "c" (self: ^CompileOptions) -> LibraryType { return msgSend(LibraryType, self, "libraryType") } @(objc_type=CompileOptions, objc_name="preprocessorMacros") -CompileOptions_preprocessorMacros :: #force_inline proc(self: ^CompileOptions) -> ^NS.Dictionary { +CompileOptions_preprocessorMacros :: #force_inline proc "c" (self: ^CompileOptions) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "preprocessorMacros") } @(objc_type=CompileOptions, objc_name="preserveInvariance") -CompileOptions_preserveInvariance :: #force_inline proc(self: ^CompileOptions) -> BOOL { +CompileOptions_preserveInvariance :: #force_inline proc "c" (self: ^CompileOptions) -> BOOL { return msgSend(BOOL, self, "preserveInvariance") } @(objc_type=CompileOptions, objc_name="setFastMathEnabled") -CompileOptions_setFastMathEnabled :: #force_inline proc(self: ^CompileOptions, fastMathEnabled: BOOL) { +CompileOptions_setFastMathEnabled :: #force_inline proc "c" (self: ^CompileOptions, fastMathEnabled: BOOL) { msgSend(nil, self, "setFastMathEnabled:", fastMathEnabled) } @(objc_type=CompileOptions, objc_name="setInstallName") -CompileOptions_setInstallName :: #force_inline proc(self: ^CompileOptions, installName: ^NS.String) { +CompileOptions_setInstallName :: #force_inline proc "c" (self: ^CompileOptions, installName: ^NS.String) { msgSend(nil, self, "setInstallName:", installName) } @(objc_type=CompileOptions, objc_name="setLanguageVersion") -CompileOptions_setLanguageVersion :: #force_inline proc(self: ^CompileOptions, languageVersion: LanguageVersion) { +CompileOptions_setLanguageVersion :: #force_inline proc "c" (self: ^CompileOptions, languageVersion: LanguageVersion) { msgSend(nil, self, "setLanguageVersion:", languageVersion) } @(objc_type=CompileOptions, objc_name="setLibraries") -CompileOptions_setLibraries :: #force_inline proc(self: ^CompileOptions, libraries: ^NS.Array) { +CompileOptions_setLibraries :: #force_inline proc "c" (self: ^CompileOptions, libraries: ^NS.Array) { msgSend(nil, self, "setLibraries:", libraries) } @(objc_type=CompileOptions, objc_name="setLibraryType") -CompileOptions_setLibraryType :: #force_inline proc(self: ^CompileOptions, libraryType: LibraryType) { +CompileOptions_setLibraryType :: #force_inline proc "c" (self: ^CompileOptions, libraryType: LibraryType) { msgSend(nil, self, "setLibraryType:", libraryType) } @(objc_type=CompileOptions, objc_name="setPreprocessorMacros") -CompileOptions_setPreprocessorMacros :: #force_inline proc(self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) { +CompileOptions_setPreprocessorMacros :: #force_inline proc "c" (self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) { msgSend(nil, self, "setPreprocessorMacros:", preprocessorMacros) } @(objc_type=CompileOptions, objc_name="setPreserveInvariance") -CompileOptions_setPreserveInvariance :: #force_inline proc(self: ^CompileOptions, preserveInvariance: BOOL) { +CompileOptions_setPreserveInvariance :: #force_inline proc "c" (self: ^CompileOptions, preserveInvariance: BOOL) { msgSend(nil, self, "setPreserveInvariance:", preserveInvariance) } @(objc_type=CompileOptions, objc_name="optimizationLevel") -CompileOptions_optimizationLevel :: #force_inline proc(self: ^CompileOptions) -> LibraryOptimizationLevel { +CompileOptions_optimizationLevel :: #force_inline proc "c" (self: ^CompileOptions) -> LibraryOptimizationLevel { return msgSend(LibraryOptimizationLevel, self, "optimizationLevel") } @(objc_type=CompileOptions, objc_name="setOptimizationLevel") -CompileOptions_setOptimizationLevel :: #force_inline proc(self: ^CompileOptions, optimizationLevel: LibraryOptimizationLevel) { +CompileOptions_setOptimizationLevel :: #force_inline proc "c" (self: ^CompileOptions, optimizationLevel: LibraryOptimizationLevel) { msgSend(nil, self, "setOptimizationLevel:", optimizationLevel) } @@ -1453,27 +1453,27 @@ Methods: ComputePassDescriptor :: struct { using _: NS.Copying(ComputePassDescriptor) } @(objc_type=ComputePassDescriptor, objc_name="alloc", objc_is_class_method=true) -ComputePassDescriptor_alloc :: #force_inline proc() -> ^ComputePassDescriptor { +ComputePassDescriptor_alloc :: #force_inline proc "c" () -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "alloc") } @(objc_type=ComputePassDescriptor, objc_name="init") -ComputePassDescriptor_init :: #force_inline proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { +ComputePassDescriptor_init :: #force_inline proc "c" (self: ^ComputePassDescriptor) -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, self, "init") } @(objc_type=ComputePassDescriptor, objc_name="computePassDescriptor", objc_is_class_method=true) -ComputePassDescriptor_computePassDescriptor :: #force_inline proc() -> ^ComputePassDescriptor { +ComputePassDescriptor_computePassDescriptor :: #force_inline proc "c" () -> ^ComputePassDescriptor { return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "computePassDescriptor") } @(objc_type=ComputePassDescriptor, objc_name="dispatchType") -ComputePassDescriptor_dispatchType :: #force_inline proc(self: ^ComputePassDescriptor) -> DispatchType { +ComputePassDescriptor_dispatchType :: #force_inline proc "c" (self: ^ComputePassDescriptor) -> DispatchType { return msgSend(DispatchType, self, "dispatchType") } @(objc_type=ComputePassDescriptor, objc_name="sampleBufferAttachments") -ComputePassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassDescriptor_sampleBufferAttachments :: #force_inline proc "c" (self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @(objc_type=ComputePassDescriptor, objc_name="setDispatchType") -ComputePassDescriptor_setDispatchType :: #force_inline proc(self: ^ComputePassDescriptor, dispatchType: DispatchType) { +ComputePassDescriptor_setDispatchType :: #force_inline proc "c" (self: ^ComputePassDescriptor, dispatchType: DispatchType) { msgSend(nil, self, "setDispatchType:", dispatchType) } @@ -1497,35 +1497,35 @@ Methods: ComputePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ComputePassSampleBufferAttachmentDescriptor) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -ComputePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, ComputePassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="init") -ComputePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptor_init :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { +ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { +ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { +ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^Buffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { +ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } @@ -1545,19 +1545,19 @@ Methods: ComputePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -ComputePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, ComputePassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="init") -ComputePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { +ComputePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray { return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="object") -ComputePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ComputePassSampleBufferAttachmentDescriptor { +ComputePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ComputePassSampleBufferAttachmentDescriptor { return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ComputePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { +ComputePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -1599,111 +1599,111 @@ Methods: ComputePipelineDescriptor :: struct { using _: NS.Copying(ComputePipelineDescriptor) } @(objc_type=ComputePipelineDescriptor, objc_name="alloc", objc_is_class_method=true) -ComputePipelineDescriptor_alloc :: #force_inline proc() -> ^ComputePipelineDescriptor { +ComputePipelineDescriptor_alloc :: #force_inline proc "c" () -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, ComputePipelineDescriptor, "alloc") } @(objc_type=ComputePipelineDescriptor, objc_name="init") -ComputePipelineDescriptor_init :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { +ComputePipelineDescriptor_init :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor { return msgSend(^ComputePipelineDescriptor, self, "init") } @(objc_type=ComputePipelineDescriptor, objc_name="binaryArchives") -ComputePipelineDescriptor_binaryArchives :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { +ComputePipelineDescriptor_binaryArchives :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=ComputePipelineDescriptor, objc_name="buffers") -ComputePipelineDescriptor_buffers :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray { +ComputePipelineDescriptor_buffers :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "buffers") } @(objc_type=ComputePipelineDescriptor, objc_name="computeFunction") -ComputePipelineDescriptor_computeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^Function { +ComputePipelineDescriptor_computeFunction :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^Function { return msgSend(^Function, self, "computeFunction") } @(objc_type=ComputePipelineDescriptor, objc_name="insertLibraries") -ComputePipelineDescriptor_insertLibraries :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.Array { +ComputePipelineDescriptor_insertLibraries :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "insertLibraries") } @(objc_type=ComputePipelineDescriptor, objc_name="label") -ComputePipelineDescriptor_label :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^NS.String { +ComputePipelineDescriptor_label :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ComputePipelineDescriptor, objc_name="linkedFunctions") -ComputePipelineDescriptor_linkedFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^LinkedFunctions { +ComputePipelineDescriptor_linkedFunctions :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^LinkedFunctions { return msgSend(^LinkedFunctions, self, "linkedFunctions") } @(objc_type=ComputePipelineDescriptor, objc_name="maxCallStackDepth") -ComputePipelineDescriptor_maxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.UInteger { +ComputePipelineDescriptor_maxCallStackDepth :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxCallStackDepth") } @(objc_type=ComputePipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor) -> NS.UInteger { +ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineDescriptor, objc_name="reset") -ComputePipelineDescriptor_reset :: #force_inline proc(self: ^ComputePipelineDescriptor) { +ComputePipelineDescriptor_reset :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=ComputePipelineDescriptor, objc_name="setBinaryArchives") -ComputePipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) { +ComputePipelineDescriptor_setBinaryArchives :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=ComputePipelineDescriptor, objc_name="setComputeFunction") -ComputePipelineDescriptor_setComputeFunction :: #force_inline proc(self: ^ComputePipelineDescriptor, computeFunction: ^Function) { +ComputePipelineDescriptor_setComputeFunction :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, computeFunction: ^Function) { msgSend(nil, self, "setComputeFunction:", computeFunction) } @(objc_type=ComputePipelineDescriptor, objc_name="setInsertLibraries") -ComputePipelineDescriptor_setInsertLibraries :: #force_inline proc(self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) { +ComputePipelineDescriptor_setInsertLibraries :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) { msgSend(nil, self, "setInsertLibraries:", insertLibraries) } @(objc_type=ComputePipelineDescriptor, objc_name="setLabel") -ComputePipelineDescriptor_setLabel :: #force_inline proc(self: ^ComputePipelineDescriptor, label: ^NS.String) { +ComputePipelineDescriptor_setLabel :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=ComputePipelineDescriptor, objc_name="setLinkedFunctions") -ComputePipelineDescriptor_setLinkedFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) { +ComputePipelineDescriptor_setLinkedFunctions :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) { msgSend(nil, self, "setLinkedFunctions:", linkedFunctions) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxCallStackDepth") -ComputePipelineDescriptor_setMaxCallStackDepth :: #force_inline proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.UInteger) { +ComputePipelineDescriptor_setMaxCallStackDepth :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.UInteger) { msgSend(nil, self, "setMaxCallStackDepth:", maxCallStackDepth) } @(objc_type=ComputePipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { +ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=ComputePipelineDescriptor, objc_name="setStageInputDescriptor") -ComputePipelineDescriptor_setStageInputDescriptor :: #force_inline proc(self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) { +ComputePipelineDescriptor_setStageInputDescriptor :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) { msgSend(nil, self, "setStageInputDescriptor:", stageInputDescriptor) } @(objc_type=ComputePipelineDescriptor, objc_name="setSupportAddingBinaryFunctions") -ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) { +ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) { msgSend(nil, self, "setSupportAddingBinaryFunctions:", supportAddingBinaryFunctions) } @(objc_type=ComputePipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") -ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) { +ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) { msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) } @(objc_type=ComputePipelineDescriptor, objc_name="setThreadGroupSizeIsMultipleOfThreadExecutionWidth") -ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { +ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { msgSend(nil, self, "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:", threadGroupSizeIsMultipleOfThreadExecutionWidth) } @(objc_type=ComputePipelineDescriptor, objc_name="stageInputDescriptor") -ComputePipelineDescriptor_stageInputDescriptor :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor { +ComputePipelineDescriptor_stageInputDescriptor :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, self, "stageInputDescriptor") } @(objc_type=ComputePipelineDescriptor, objc_name="supportAddingBinaryFunctions") -ComputePipelineDescriptor_supportAddingBinaryFunctions :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_supportAddingBinaryFunctions :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportAddingBinaryFunctions") } @(objc_type=ComputePipelineDescriptor, objc_name="supportIndirectCommandBuffers") -ComputePipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=ComputePipelineDescriptor, objc_name="threadGroupSizeIsMultipleOfThreadExecutionWidth") -ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^ComputePipelineDescriptor) -> BOOL { +ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "threadGroupSizeIsMultipleOfThreadExecutionWidth") } @(objc_type=ComputePipelineDescriptor, objc_name="gpuResourceID") -ComputePipelineDescriptor_gpuResourceID :: #force_inline proc(self: ^ComputePipelineDescriptor) -> ResourceID { +ComputePipelineDescriptor_gpuResourceID :: #force_inline proc "c" (self: ^ComputePipelineDescriptor) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } @@ -1723,19 +1723,19 @@ Methods: ComputePipelineReflection :: struct { using _: NS.Object } @(objc_type=ComputePipelineReflection, objc_name="alloc", objc_is_class_method=true) -ComputePipelineReflection_alloc :: #force_inline proc() -> ^ComputePipelineReflection { +ComputePipelineReflection_alloc :: #force_inline proc "c" () -> ^ComputePipelineReflection { return msgSend(^ComputePipelineReflection, ComputePipelineReflection, "alloc") } @(objc_type=ComputePipelineReflection, objc_name="init") -ComputePipelineReflection_init :: #force_inline proc(self: ^ComputePipelineReflection) -> ^ComputePipelineReflection { +ComputePipelineReflection_init :: #force_inline proc "c" (self: ^ComputePipelineReflection) -> ^ComputePipelineReflection { return msgSend(^ComputePipelineReflection, self, "init") } @(objc_type=ComputePipelineReflection, objc_name="bindings") -ComputePipelineReflection_bindings :: #force_inline proc(self: ^ComputePipelineReflection) -> ^NS.Array { +ComputePipelineReflection_bindings :: #force_inline proc "c" (self: ^ComputePipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "bindings") } @(objc_type=ComputePipelineReflection, objc_name="arguments") -ComputePipelineReflection_arguments :: #force_inline proc(self: ^ComputePipelineReflection) -> ^NS.Array { +ComputePipelineReflection_arguments :: #force_inline proc "c" (self: ^ComputePipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "arguments") } @@ -1761,43 +1761,43 @@ Methods: CounterSampleBufferDescriptor :: struct { using _: NS.Copying(CounterSampleBufferDescriptor) } @(objc_type=CounterSampleBufferDescriptor, objc_name="alloc", objc_is_class_method=true) -CounterSampleBufferDescriptor_alloc :: #force_inline proc() -> ^CounterSampleBufferDescriptor { +CounterSampleBufferDescriptor_alloc :: #force_inline proc "c" () -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, CounterSampleBufferDescriptor, "alloc") } @(objc_type=CounterSampleBufferDescriptor, objc_name="init") -CounterSampleBufferDescriptor_init :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { +CounterSampleBufferDescriptor_init :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor { return msgSend(^CounterSampleBufferDescriptor, self, "init") } @(objc_type=CounterSampleBufferDescriptor, objc_name="counterSet") -CounterSampleBufferDescriptor_counterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSet { +CounterSampleBufferDescriptor_counterSet :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor) -> ^CounterSet { return msgSend(^CounterSet, self, "counterSet") } @(objc_type=CounterSampleBufferDescriptor, objc_name="label") -CounterSampleBufferDescriptor_label :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String { +CounterSampleBufferDescriptor_label :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CounterSampleBufferDescriptor, objc_name="sampleCount") -CounterSampleBufferDescriptor_sampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> NS.UInteger { +CounterSampleBufferDescriptor_sampleCount :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=CounterSampleBufferDescriptor, objc_name="setCounterSet") -CounterSampleBufferDescriptor_setCounterSet :: #force_inline proc(self: ^CounterSampleBufferDescriptor, counterSet: ^CounterSet) { +CounterSampleBufferDescriptor_setCounterSet :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor, counterSet: ^CounterSet) { msgSend(nil, self, "setCounterSet:", counterSet) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setLabel") -CounterSampleBufferDescriptor_setLabel :: #force_inline proc(self: ^CounterSampleBufferDescriptor, label: ^NS.String) { +CounterSampleBufferDescriptor_setLabel :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setSampleCount") -CounterSampleBufferDescriptor_setSampleCount :: #force_inline proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.UInteger) { +CounterSampleBufferDescriptor_setSampleCount :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=CounterSampleBufferDescriptor, objc_name="setStorageMode") -CounterSampleBufferDescriptor_setStorageMode :: #force_inline proc(self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) { +CounterSampleBufferDescriptor_setStorageMode :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=CounterSampleBufferDescriptor, objc_name="storageMode") -CounterSampleBufferDescriptor_storageMode :: #force_inline proc(self: ^CounterSampleBufferDescriptor) -> StorageMode { +CounterSampleBufferDescriptor_storageMode :: #force_inline proc "c" (self: ^CounterSampleBufferDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @@ -1825,51 +1825,51 @@ Methods: DepthStencilDescriptor :: struct { using _: NS.Copying(DepthStencilDescriptor) } @(objc_type=DepthStencilDescriptor, objc_name="alloc", objc_is_class_method=true) -DepthStencilDescriptor_alloc :: #force_inline proc() -> ^DepthStencilDescriptor { +DepthStencilDescriptor_alloc :: #force_inline proc "c" () -> ^DepthStencilDescriptor { return msgSend(^DepthStencilDescriptor, DepthStencilDescriptor, "alloc") } @(objc_type=DepthStencilDescriptor, objc_name="init") -DepthStencilDescriptor_init :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor { +DepthStencilDescriptor_init :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor { return msgSend(^DepthStencilDescriptor, self, "init") } @(objc_type=DepthStencilDescriptor, objc_name="backFaceStencil") -DepthStencilDescriptor_backFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { +DepthStencilDescriptor_backFaceStencil :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "backFaceStencil") } @(objc_type=DepthStencilDescriptor, objc_name="depthCompareFunction") -DepthStencilDescriptor_depthCompareFunction :: #force_inline proc(self: ^DepthStencilDescriptor) -> CompareFunction { +DepthStencilDescriptor_depthCompareFunction :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "depthCompareFunction") } @(objc_type=DepthStencilDescriptor, objc_name="frontFaceStencil") -DepthStencilDescriptor_frontFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor { +DepthStencilDescriptor_frontFaceStencil :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "frontFaceStencil") } @(objc_type=DepthStencilDescriptor, objc_name="isDepthWriteEnabled") -DepthStencilDescriptor_isDepthWriteEnabled :: #force_inline proc(self: ^DepthStencilDescriptor) -> BOOL { +DepthStencilDescriptor_isDepthWriteEnabled :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> BOOL { return msgSend(BOOL, self, "isDepthWriteEnabled") } @(objc_type=DepthStencilDescriptor, objc_name="label") -DepthStencilDescriptor_label :: #force_inline proc(self: ^DepthStencilDescriptor) -> ^NS.String { +DepthStencilDescriptor_label :: #force_inline proc "c" (self: ^DepthStencilDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=DepthStencilDescriptor, objc_name="setBackFaceStencil") -DepthStencilDescriptor_setBackFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) { +DepthStencilDescriptor_setBackFaceStencil :: #force_inline proc "c" (self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) { msgSend(nil, self, "setBackFaceStencil:", backFaceStencil) } @(objc_type=DepthStencilDescriptor, objc_name="setDepthCompareFunction") -DepthStencilDescriptor_setDepthCompareFunction :: #force_inline proc(self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) { +DepthStencilDescriptor_setDepthCompareFunction :: #force_inline proc "c" (self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) { msgSend(nil, self, "setDepthCompareFunction:", depthCompareFunction) } @(objc_type=DepthStencilDescriptor, objc_name="setDepthWriteEnabled") -DepthStencilDescriptor_setDepthWriteEnabled :: #force_inline proc(self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) { +DepthStencilDescriptor_setDepthWriteEnabled :: #force_inline proc "c" (self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) { msgSend(nil, self, "setDepthWriteEnabled:", depthWriteEnabled) } @(objc_type=DepthStencilDescriptor, objc_name="setFrontFaceStencil") -DepthStencilDescriptor_setFrontFaceStencil :: #force_inline proc(self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) { +DepthStencilDescriptor_setFrontFaceStencil :: #force_inline proc "c" (self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) { msgSend(nil, self, "setFrontFaceStencil:", frontFaceStencil) } @(objc_type=DepthStencilDescriptor, objc_name="setLabel") -DepthStencilDescriptor_setLabel :: #force_inline proc(self: ^DepthStencilDescriptor, label: ^NS.String) { +DepthStencilDescriptor_setLabel :: #force_inline proc "c" (self: ^DepthStencilDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -1891,27 +1891,27 @@ Methods: FunctionConstant :: struct { using _: NS.Copying(FunctionConstant) } @(objc_type=FunctionConstant, objc_name="alloc", objc_is_class_method=true) -FunctionConstant_alloc :: #force_inline proc() -> ^FunctionConstant { +FunctionConstant_alloc :: #force_inline proc "c" () -> ^FunctionConstant { return msgSend(^FunctionConstant, FunctionConstant, "alloc") } @(objc_type=FunctionConstant, objc_name="init") -FunctionConstant_init :: #force_inline proc(self: ^FunctionConstant) -> ^FunctionConstant { +FunctionConstant_init :: #force_inline proc "c" (self: ^FunctionConstant) -> ^FunctionConstant { return msgSend(^FunctionConstant, self, "init") } @(objc_type=FunctionConstant, objc_name="index") -FunctionConstant_index :: #force_inline proc(self: ^FunctionConstant) -> NS.UInteger { +FunctionConstant_index :: #force_inline proc "c" (self: ^FunctionConstant) -> NS.UInteger { return msgSend(NS.UInteger, self, "index") } @(objc_type=FunctionConstant, objc_name="name") -FunctionConstant_name :: #force_inline proc(self: ^FunctionConstant) -> ^NS.String { +FunctionConstant_name :: #force_inline proc "c" (self: ^FunctionConstant) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=FunctionConstant, objc_name="required") -FunctionConstant_required :: #force_inline proc(self: ^FunctionConstant) -> BOOL { +FunctionConstant_required :: #force_inline proc "c" (self: ^FunctionConstant) -> BOOL { return msgSend(BOOL, self, "required") } @(objc_type=FunctionConstant, objc_name="type") -FunctionConstant_type :: #force_inline proc(self: ^FunctionConstant) -> DataType { +FunctionConstant_type :: #force_inline proc "c" (self: ^FunctionConstant) -> DataType { return msgSend(DataType, self, "type") } @@ -1933,27 +1933,27 @@ Methods: FunctionConstantValues :: struct { using _: NS.Copying(FunctionConstantValues) } @(objc_type=FunctionConstantValues, objc_name="alloc", objc_is_class_method=true) -FunctionConstantValues_alloc :: #force_inline proc() -> ^FunctionConstantValues { +FunctionConstantValues_alloc :: #force_inline proc "c" () -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, FunctionConstantValues, "alloc") } @(objc_type=FunctionConstantValues, objc_name="init") -FunctionConstantValues_init :: #force_inline proc(self: ^FunctionConstantValues) -> ^FunctionConstantValues { +FunctionConstantValues_init :: #force_inline proc "c" (self: ^FunctionConstantValues) -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, self, "init") } @(objc_type=FunctionConstantValues, objc_name="reset") -FunctionConstantValues_reset :: #force_inline proc(self: ^FunctionConstantValues) { +FunctionConstantValues_reset :: #force_inline proc "c" (self: ^FunctionConstantValues) { msgSend(nil, self, "reset") } @(objc_type=FunctionConstantValues, objc_name="setConstantValue") -FunctionConstantValues_setConstantValue :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: NS.UInteger) { +FunctionConstantValues_setConstantValue :: #force_inline proc "c" (self: ^FunctionConstantValues, value: rawptr, type: DataType, index: NS.UInteger) { msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index) } @(objc_type=FunctionConstantValues, objc_name="setConstantValueWithName") -FunctionConstantValues_setConstantValueWithName :: #force_inline proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { +FunctionConstantValues_setConstantValueWithName :: #force_inline proc "c" (self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) { msgSend(nil, self, "setConstantValue:type:withName:", value, type, name) } @(objc_type=FunctionConstantValues, objc_name="setConstantValues") -FunctionConstantValues_setConstantValues :: #force_inline proc(self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) { +FunctionConstantValues_setConstantValues :: #force_inline proc "c" (self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) { msgSend(nil, self, "setConstantValues:type:withRange:", values, type, range) } @@ -1980,47 +1980,47 @@ Methods: FunctionDescriptor :: struct { using _: NS.Copying(FunctionDescriptor) } @(objc_type=FunctionDescriptor, objc_name="alloc", objc_is_class_method=true) -FunctionDescriptor_alloc :: #force_inline proc() -> ^FunctionDescriptor { +FunctionDescriptor_alloc :: #force_inline proc "c" () -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "alloc") } @(objc_type=FunctionDescriptor, objc_name="init") -FunctionDescriptor_init :: #force_inline proc(self: ^FunctionDescriptor) -> ^FunctionDescriptor { +FunctionDescriptor_init :: #force_inline proc "c" (self: ^FunctionDescriptor) -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, self, "init") } @(objc_type=FunctionDescriptor, objc_name="constantValues") -FunctionDescriptor_constantValues :: #force_inline proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues { +FunctionDescriptor_constantValues :: #force_inline proc "c" (self: ^FunctionDescriptor) -> ^FunctionConstantValues { return msgSend(^FunctionConstantValues, self, "constantValues") } @(objc_type=FunctionDescriptor, objc_name="functionDescriptor", objc_is_class_method=true) -FunctionDescriptor_functionDescriptor :: #force_inline proc() -> ^FunctionDescriptor { +FunctionDescriptor_functionDescriptor :: #force_inline proc "c" () -> ^FunctionDescriptor { return msgSend(^FunctionDescriptor, FunctionDescriptor, "functionDescriptor") } @(objc_type=FunctionDescriptor, objc_name="name") -FunctionDescriptor_name :: #force_inline proc(self: ^FunctionDescriptor) -> ^NS.String { +FunctionDescriptor_name :: #force_inline proc "c" (self: ^FunctionDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=FunctionDescriptor, objc_name="options") -FunctionDescriptor_options :: #force_inline proc(self: ^FunctionDescriptor) -> FunctionOptions { +FunctionDescriptor_options :: #force_inline proc "c" (self: ^FunctionDescriptor) -> FunctionOptions { return msgSend(FunctionOptions, self, "options") } @(objc_type=FunctionDescriptor, objc_name="setConstantValues") -FunctionDescriptor_setConstantValues :: #force_inline proc(self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) { +FunctionDescriptor_setConstantValues :: #force_inline proc "c" (self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) { msgSend(nil, self, "setConstantValues:", constantValues) } @(objc_type=FunctionDescriptor, objc_name="setName") -FunctionDescriptor_setName :: #force_inline proc(self: ^FunctionDescriptor, name: ^NS.String) { +FunctionDescriptor_setName :: #force_inline proc "c" (self: ^FunctionDescriptor, name: ^NS.String) { msgSend(nil, self, "setName:", name) } @(objc_type=FunctionDescriptor, objc_name="setOptions") -FunctionDescriptor_setOptions :: #force_inline proc(self: ^FunctionDescriptor, options: FunctionOptions) { +FunctionDescriptor_setOptions :: #force_inline proc "c" (self: ^FunctionDescriptor, options: FunctionOptions) { msgSend(nil, self, "setOptions:", options) } @(objc_type=FunctionDescriptor, objc_name="setSpecializedName") -FunctionDescriptor_setSpecializedName :: #force_inline proc(self: ^FunctionDescriptor, specializedName: ^NS.String) { +FunctionDescriptor_setSpecializedName :: #force_inline proc "c" (self: ^FunctionDescriptor, specializedName: ^NS.String) { msgSend(nil, self, "setSpecializedName:", specializedName) } @(objc_type=FunctionDescriptor, objc_name="specializedName") -FunctionDescriptor_specializedName :: #force_inline proc(self: ^FunctionDescriptor) -> ^NS.String { +FunctionDescriptor_specializedName :: #force_inline proc "c" (self: ^FunctionDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "specializedName") } @@ -2038,11 +2038,11 @@ Methods: IntersectionFunctionDescriptor :: struct { using _: NS.Copying(IntersectionFunctionDescriptor) } @(objc_type=IntersectionFunctionDescriptor, objc_name="alloc", objc_is_class_method=true) -IntersectionFunctionDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionDescriptor { +IntersectionFunctionDescriptor_alloc :: #force_inline proc "c" () -> ^IntersectionFunctionDescriptor { return msgSend(^IntersectionFunctionDescriptor, IntersectionFunctionDescriptor, "alloc") } @(objc_type=IntersectionFunctionDescriptor, objc_name="init") -IntersectionFunctionDescriptor_init :: #force_inline proc(self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor { +IntersectionFunctionDescriptor_init :: #force_inline proc "c" (self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor { return msgSend(^IntersectionFunctionDescriptor, self, "init") } @@ -2072,69 +2072,69 @@ Methods: HeapDescriptor :: struct { using _: NS.Copying(HeapDescriptor) } @(objc_type=HeapDescriptor, objc_name="alloc", objc_is_class_method=true) -HeapDescriptor_alloc :: #force_inline proc() -> ^HeapDescriptor { +HeapDescriptor_alloc :: #force_inline proc "c" () -> ^HeapDescriptor { return msgSend(^HeapDescriptor, HeapDescriptor, "alloc") } @(objc_type=HeapDescriptor, objc_name="init") -HeapDescriptor_init :: #force_inline proc(self: ^HeapDescriptor) -> ^HeapDescriptor { +HeapDescriptor_init :: #force_inline proc "c" (self: ^HeapDescriptor) -> ^HeapDescriptor { return msgSend(^HeapDescriptor, self, "init") } @(objc_type=HeapDescriptor, objc_name="cpuCacheMode") -HeapDescriptor_cpuCacheMode :: #force_inline proc(self: ^HeapDescriptor) -> CPUCacheMode { +HeapDescriptor_cpuCacheMode :: #force_inline proc "c" (self: ^HeapDescriptor) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=HeapDescriptor, objc_name="hazardTrackingMode") -HeapDescriptor_hazardTrackingMode :: #force_inline proc(self: ^HeapDescriptor) -> HazardTrackingMode { +HeapDescriptor_hazardTrackingMode :: #force_inline proc "c" (self: ^HeapDescriptor) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=HeapDescriptor, objc_name="resourceOptions") -HeapDescriptor_resourceOptions :: #force_inline proc(self: ^HeapDescriptor) -> ResourceOptions { +HeapDescriptor_resourceOptions :: #force_inline proc "c" (self: ^HeapDescriptor) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=HeapDescriptor, objc_name="setCpuCacheMode") -HeapDescriptor_setCpuCacheMode :: #force_inline proc(self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) { +HeapDescriptor_setCpuCacheMode :: #force_inline proc "c" (self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) { msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) } @(objc_type=HeapDescriptor, objc_name="sparsePageSize") -HeapDescriptor_sparsePageSize :: #force_inline proc(self: ^HeapDescriptor) -> SparsePageSize { +HeapDescriptor_sparsePageSize :: #force_inline proc "c" (self: ^HeapDescriptor) -> SparsePageSize { return msgSend(SparsePageSize, self, "sparsePageSize") } @(objc_type=HeapDescriptor, objc_name="setSparsePageSize") -HeapDescriptor_setSparsePageSize :: #force_inline proc(self: ^HeapDescriptor, sparsePageSize: SparsePageSize) { +HeapDescriptor_setSparsePageSize :: #force_inline proc "c" (self: ^HeapDescriptor, sparsePageSize: SparsePageSize) { msgSend(nil, self, "setSparsePageSize:", sparsePageSize) } @(objc_type=HeapDescriptor, objc_name="setHazardTrackingMode") -HeapDescriptor_setHazardTrackingMode :: #force_inline proc(self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) { +HeapDescriptor_setHazardTrackingMode :: #force_inline proc "c" (self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) { msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) } @(objc_type=HeapDescriptor, objc_name="setResourceOptions") -HeapDescriptor_setResourceOptions :: #force_inline proc(self: ^HeapDescriptor, resourceOptions: ResourceOptions) { +HeapDescriptor_setResourceOptions :: #force_inline proc "c" (self: ^HeapDescriptor, resourceOptions: ResourceOptions) { msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=HeapDescriptor, objc_name="setSize") -HeapDescriptor_setSize :: #force_inline proc(self: ^HeapDescriptor, size: NS.UInteger) { +HeapDescriptor_setSize :: #force_inline proc "c" (self: ^HeapDescriptor, size: NS.UInteger) { msgSend(nil, self, "setSize:", size) } @(objc_type=HeapDescriptor, objc_name="setStorageMode") -HeapDescriptor_setStorageMode :: #force_inline proc(self: ^HeapDescriptor, storageMode: StorageMode) { +HeapDescriptor_setStorageMode :: #force_inline proc "c" (self: ^HeapDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=HeapDescriptor, objc_name="setType") -HeapDescriptor_setType :: #force_inline proc(self: ^HeapDescriptor, type: HeapType) { +HeapDescriptor_setType :: #force_inline proc "c" (self: ^HeapDescriptor, type: HeapType) { msgSend(nil, self, "setType:", type) } @(objc_type=HeapDescriptor, objc_name="size") -HeapDescriptor_size :: #force_inline proc(self: ^HeapDescriptor) -> NS.UInteger { +HeapDescriptor_size :: #force_inline proc "c" (self: ^HeapDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "size") } @(objc_type=HeapDescriptor, objc_name="storageMode") -HeapDescriptor_storageMode :: #force_inline proc(self: ^HeapDescriptor) -> StorageMode { +HeapDescriptor_storageMode :: #force_inline proc "c" (self: ^HeapDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=HeapDescriptor, objc_name="type") -HeapDescriptor_type :: #force_inline proc(self: ^HeapDescriptor) -> HeapType { +HeapDescriptor_type :: #force_inline proc "c" (self: ^HeapDescriptor) -> HeapType { return msgSend(HeapType, self, "type") } @@ -2164,59 +2164,59 @@ Methods: IndirectCommandBufferDescriptor :: struct { using _: NS.Copying(IndirectCommandBufferDescriptor) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="alloc", objc_is_class_method=true) -IndirectCommandBufferDescriptor_alloc :: #force_inline proc() -> ^IndirectCommandBufferDescriptor { +IndirectCommandBufferDescriptor_alloc :: #force_inline proc "c" () -> ^IndirectCommandBufferDescriptor { return msgSend(^IndirectCommandBufferDescriptor, IndirectCommandBufferDescriptor, "alloc") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="init") -IndirectCommandBufferDescriptor_init :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor { +IndirectCommandBufferDescriptor_init :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor { return msgSend(^IndirectCommandBufferDescriptor, self, "init") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="commandTypes") -IndirectCommandBufferDescriptor_commandTypes :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType { +IndirectCommandBufferDescriptor_commandTypes :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType { return msgSend(IndirectCommandType, self, "commandTypes") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritBuffers") -IndirectCommandBufferDescriptor_inheritBuffers :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { +IndirectCommandBufferDescriptor_inheritBuffers :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "inheritBuffers") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritPipelineState") -IndirectCommandBufferDescriptor_inheritPipelineState :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> BOOL { +IndirectCommandBufferDescriptor_inheritPipelineState :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> BOOL { return msgSend(BOOL, self, "inheritPipelineState") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { +IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxFragmentBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxKernelBufferBindCount") -IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { +IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxKernelBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="maxVertexBufferBindCount") -IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { +IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxVertexBufferBindCount") } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setCommandTypes") -IndirectCommandBufferDescriptor_setCommandTypes :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { +IndirectCommandBufferDescriptor_setCommandTypes :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) { msgSend(nil, self, "setCommandTypes:", commandTypes) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritBuffers") -IndirectCommandBufferDescriptor_setInheritBuffers :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) { +IndirectCommandBufferDescriptor_setInheritBuffers :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) { msgSend(nil, self, "setInheritBuffers:", inheritBuffers) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritPipelineState") -IndirectCommandBufferDescriptor_setInheritPipelineState :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) { +IndirectCommandBufferDescriptor_setInheritPipelineState :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) { msgSend(nil, self, "setInheritPipelineState:", inheritPipelineState) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxFragmentBufferBindCount") -IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.UInteger) { +IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxFragmentBufferBindCount:", maxFragmentBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxKernelBufferBindCount") -IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.UInteger) { +IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxKernelBufferBindCount:", maxKernelBufferBindCount) } @(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxVertexBufferBindCount") -IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: #force_inline proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.UInteger) { +IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: #force_inline proc "c" (self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.UInteger) { msgSend(nil, self, "setMaxVertexBufferBindCount:", maxVertexBufferBindCount) } @@ -2245,93 +2245,93 @@ Methods: InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) -InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_alloc :: #force_inline proc "c" () -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "alloc") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="init") -InstanceAccelerationStructureDescriptor_init :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_init :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, self, "init") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="descriptor", objc_is_class_method=true) -InstanceAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^InstanceAccelerationStructureDescriptor { +InstanceAccelerationStructureDescriptor_descriptor :: #force_inline proc "c" () -> ^InstanceAccelerationStructureDescriptor { return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceCount") -InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { +InstanceAccelerationStructureDescriptor_instanceCount :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "instanceCount") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { +InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "instanceDescriptorBuffer") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { +InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "instanceDescriptorBufferOffset") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorStride") -InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { +InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "instanceDescriptorStride") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instancedAccelerationStructures") -InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { +InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "instancedAccelerationStructures") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceCount") -InstanceAccelerationStructureDescriptor_setInstanceCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.UInteger) { +InstanceAccelerationStructureDescriptor_setInstanceCount :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.UInteger) { msgSend(nil, self, "setInstanceCount:", instanceCount) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBuffer") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^Buffer) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^Buffer) { msgSend(nil, self, "setInstanceDescriptorBuffer:", instanceDescriptorBuffer) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBufferOffset") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.UInteger) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.UInteger) { msgSend(nil, self, "setInstanceDescriptorBufferOffset:", instanceDescriptorBufferOffset) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorStride") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.UInteger) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.UInteger) { msgSend(nil, self, "setInstanceDescriptorStride:", instanceDescriptorStride) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstancedAccelerationStructures") -InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) { +InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) { msgSend(nil, self, "setInstancedAccelerationStructures:", instancedAccelerationStructures) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorType") -InstanceAccelerationStructureDescriptor_instanceDescriptorType :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> AccelerationStructureInstanceDescriptorType { +InstanceAccelerationStructureDescriptor_instanceDescriptorType :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> AccelerationStructureInstanceDescriptorType { return msgSend(AccelerationStructureInstanceDescriptorType, self, "instanceDescriptorType") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorType") -InstanceAccelerationStructureDescriptor_setInstanceDescriptorType :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, buffer: AccelerationStructureInstanceDescriptorType) { +InstanceAccelerationStructureDescriptor_setInstanceDescriptorType :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, buffer: AccelerationStructureInstanceDescriptorType) { msgSend(nil, self, "setInstanceDescriptorType:", buffer) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformBuffer") -InstanceAccelerationStructureDescriptor_motionTransformBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { +InstanceAccelerationStructureDescriptor_motionTransformBuffer :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "motionTransformBuffer") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformBuffer") -InstanceAccelerationStructureDescriptor_setMotionTransformBuffer :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, buffer: ^Buffer) { +InstanceAccelerationStructureDescriptor_setMotionTransformBuffer :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, buffer: ^Buffer) { msgSend(nil, self, "setMotionTransformBuffer:", buffer) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformBufferOffset") -InstanceAccelerationStructureDescriptor_motionTransformBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { +InstanceAccelerationStructureDescriptor_motionTransformBufferOffset :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "motionTransformBufferOffset") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformBufferOffset") -InstanceAccelerationStructureDescriptor_setMotionTransformBufferOffset :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { +InstanceAccelerationStructureDescriptor_setMotionTransformBufferOffset :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setMotionTransformBufferOffset:", offset) } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="motionTransformCount") -InstanceAccelerationStructureDescriptor_motionTransformCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { +InstanceAccelerationStructureDescriptor_motionTransformCount :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "motionTransformCount") } @(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setMotionTransformCount") -InstanceAccelerationStructureDescriptor_setMotionTransformCount :: #force_inline proc(self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { +InstanceAccelerationStructureDescriptor_setMotionTransformCount :: #force_inline proc "c" (self: ^InstanceAccelerationStructureDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setMotionTransformCount:", offset) } @@ -2354,23 +2354,23 @@ Methods: IntersectionFunctionTableDescriptor :: struct { using _: NS.Copying(IntersectionFunctionTableDescriptor) } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="alloc", objc_is_class_method=true) -IntersectionFunctionTableDescriptor_alloc :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_alloc :: #force_inline proc "c" () -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "alloc") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="init") -IntersectionFunctionTableDescriptor_init :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_init :: #force_inline proc "c" (self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, self, "init") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="functionCount") -IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor) -> NS.UInteger { +IntersectionFunctionTableDescriptor_functionCount :: #force_inline proc "c" (self: ^IntersectionFunctionTableDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "functionCount") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="intersectionFunctionTableDescriptor", objc_is_class_method=true) -IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: #force_inline proc() -> ^IntersectionFunctionTableDescriptor { +IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: #force_inline proc "c" () -> ^IntersectionFunctionTableDescriptor { return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor") } @(objc_type=IntersectionFunctionTableDescriptor, objc_name="setFunctionCount") -IntersectionFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.UInteger) { +IntersectionFunctionTableDescriptor_setFunctionCount :: #force_inline proc "c" (self: ^IntersectionFunctionTableDescriptor, functionCount: NS.UInteger) { msgSend(nil, self, "setFunctionCount:", functionCount) } @@ -2395,39 +2395,39 @@ Methods: LinkedFunctions :: struct { using _: NS.Copying(LinkedFunctions) } @(objc_type=LinkedFunctions, objc_name="alloc", objc_is_class_method=true) -LinkedFunctions_alloc :: #force_inline proc() -> ^LinkedFunctions { +LinkedFunctions_alloc :: #force_inline proc "c" () -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "alloc") } @(objc_type=LinkedFunctions, objc_name="init") -LinkedFunctions_init :: #force_inline proc(self: ^LinkedFunctions) -> ^LinkedFunctions { +LinkedFunctions_init :: #force_inline proc "c" (self: ^LinkedFunctions) -> ^LinkedFunctions { return msgSend(^LinkedFunctions, self, "init") } @(objc_type=LinkedFunctions, objc_name="binaryFunctions") -LinkedFunctions_binaryFunctions :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Array { +LinkedFunctions_binaryFunctions :: #force_inline proc "c" (self: ^LinkedFunctions) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryFunctions") } @(objc_type=LinkedFunctions, objc_name="functions") -LinkedFunctions_functions :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Array { +LinkedFunctions_functions :: #force_inline proc "c" (self: ^LinkedFunctions) -> ^NS.Array { return msgSend(^NS.Array, self, "functions") } @(objc_type=LinkedFunctions, objc_name="groups") -LinkedFunctions_groups :: #force_inline proc(self: ^LinkedFunctions) -> ^NS.Dictionary { +LinkedFunctions_groups :: #force_inline proc "c" (self: ^LinkedFunctions) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "groups") } @(objc_type=LinkedFunctions, objc_name="linkedFunctions", objc_is_class_method=true) -LinkedFunctions_linkedFunctions :: #force_inline proc() -> ^LinkedFunctions { +LinkedFunctions_linkedFunctions :: #force_inline proc "c" () -> ^LinkedFunctions { return msgSend(^LinkedFunctions, LinkedFunctions, "linkedFunctions") } @(objc_type=LinkedFunctions, objc_name="setBinaryFunctions") -LinkedFunctions_setBinaryFunctions :: #force_inline proc(self: ^LinkedFunctions, binaryFunctions: ^NS.Array) { +LinkedFunctions_setBinaryFunctions :: #force_inline proc "c" (self: ^LinkedFunctions, binaryFunctions: ^NS.Array) { msgSend(nil, self, "setBinaryFunctions:", binaryFunctions) } @(objc_type=LinkedFunctions, objc_name="setFunctions") -LinkedFunctions_setFunctions :: #force_inline proc(self: ^LinkedFunctions, functions: ^NS.Array) { +LinkedFunctions_setFunctions :: #force_inline proc "c" (self: ^LinkedFunctions, functions: ^NS.Array) { msgSend(nil, self, "setFunctions:", functions) } @(objc_type=LinkedFunctions, objc_name="setGroups") -LinkedFunctions_setGroups :: #force_inline proc(self: ^LinkedFunctions, groups: ^NS.Dictionary) { +LinkedFunctions_setGroups :: #force_inline proc "c" (self: ^LinkedFunctions, groups: ^NS.Dictionary) { msgSend(nil, self, "setGroups:", groups) } @@ -2447,19 +2447,19 @@ Methods: PipelineBufferDescriptor :: struct { using _: NS.Copying(PipelineBufferDescriptor) } @(objc_type=PipelineBufferDescriptor, objc_name="alloc", objc_is_class_method=true) -PipelineBufferDescriptor_alloc :: #force_inline proc() -> ^PipelineBufferDescriptor { +PipelineBufferDescriptor_alloc :: #force_inline proc "c" () -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, PipelineBufferDescriptor, "alloc") } @(objc_type=PipelineBufferDescriptor, objc_name="init") -PipelineBufferDescriptor_init :: #force_inline proc(self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor { +PipelineBufferDescriptor_init :: #force_inline proc "c" (self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "init") } @(objc_type=PipelineBufferDescriptor, objc_name="mutability") -PipelineBufferDescriptor_mutability :: #force_inline proc(self: ^PipelineBufferDescriptor) -> Mutability { +PipelineBufferDescriptor_mutability :: #force_inline proc "c" (self: ^PipelineBufferDescriptor) -> Mutability { return msgSend(Mutability, self, "mutability") } @(objc_type=PipelineBufferDescriptor, objc_name="setMutability") -PipelineBufferDescriptor_setMutability :: #force_inline proc(self: ^PipelineBufferDescriptor, mutability: Mutability) { +PipelineBufferDescriptor_setMutability :: #force_inline proc "c" (self: ^PipelineBufferDescriptor, mutability: Mutability) { msgSend(nil, self, "setMutability:", mutability) } @@ -2479,19 +2479,19 @@ Methods: PipelineBufferDescriptorArray :: struct { using _: NS.Object } @(objc_type=PipelineBufferDescriptorArray, objc_name="alloc", objc_is_class_method=true) -PipelineBufferDescriptorArray_alloc :: #force_inline proc() -> ^PipelineBufferDescriptorArray { +PipelineBufferDescriptorArray_alloc :: #force_inline proc "c" () -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, PipelineBufferDescriptorArray, "alloc") } @(objc_type=PipelineBufferDescriptorArray, objc_name="init") -PipelineBufferDescriptorArray_init :: #force_inline proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { +PipelineBufferDescriptorArray_init :: #force_inline proc "c" (self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "init") } @(objc_type=PipelineBufferDescriptorArray, objc_name="object") -PipelineBufferDescriptorArray_object :: #force_inline proc(self: ^PipelineBufferDescriptorArray, bufferIndex: NS.UInteger) -> ^PipelineBufferDescriptor { +PipelineBufferDescriptorArray_object :: #force_inline proc "c" (self: ^PipelineBufferDescriptorArray, bufferIndex: NS.UInteger) -> ^PipelineBufferDescriptor { return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex) } @(objc_type=PipelineBufferDescriptorArray, objc_name="setObject") -PipelineBufferDescriptorArray_setObject :: #force_inline proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: NS.UInteger) { +PipelineBufferDescriptorArray_setObject :: #force_inline proc "c" (self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", buffer, bufferIndex) } @@ -2516,39 +2516,39 @@ Methods: PointerType :: struct { using _: Type } @(objc_type=PointerType, objc_name="alloc", objc_is_class_method=true) -PointerType_alloc :: #force_inline proc() -> ^PointerType { +PointerType_alloc :: #force_inline proc "c" () -> ^PointerType { return msgSend(^PointerType, PointerType, "alloc") } @(objc_type=PointerType, objc_name="init") -PointerType_init :: #force_inline proc(self: ^PointerType) -> ^PointerType { +PointerType_init :: #force_inline proc "c" (self: ^PointerType) -> ^PointerType { return msgSend(^PointerType, self, "init") } @(objc_type=PointerType, objc_name="access") -PointerType_access :: #force_inline proc(self: ^PointerType) -> ArgumentAccess { +PointerType_access :: #force_inline proc "c" (self: ^PointerType) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=PointerType, objc_name="alignment") -PointerType_alignment :: #force_inline proc(self: ^PointerType) -> NS.UInteger { +PointerType_alignment :: #force_inline proc "c" (self: ^PointerType) -> NS.UInteger { return msgSend(NS.UInteger, self, "alignment") } @(objc_type=PointerType, objc_name="dataSize") -PointerType_dataSize :: #force_inline proc(self: ^PointerType) -> NS.UInteger { +PointerType_dataSize :: #force_inline proc "c" (self: ^PointerType) -> NS.UInteger { return msgSend(NS.UInteger, self, "dataSize") } @(objc_type=PointerType, objc_name="elementArrayType") -PointerType_elementArrayType :: #force_inline proc(self: ^PointerType) -> ^ArrayType { +PointerType_elementArrayType :: #force_inline proc "c" (self: ^PointerType) -> ^ArrayType { return msgSend(^ArrayType, self, "elementArrayType") } @(objc_type=PointerType, objc_name="elementIsArgumentBuffer") -PointerType_elementIsArgumentBuffer :: #force_inline proc(self: ^PointerType) -> BOOL { +PointerType_elementIsArgumentBuffer :: #force_inline proc "c" (self: ^PointerType) -> BOOL { return msgSend(BOOL, self, "elementIsArgumentBuffer") } @(objc_type=PointerType, objc_name="elementStructType") -PointerType_elementStructType :: #force_inline proc(self: ^PointerType) -> ^StructType { +PointerType_elementStructType :: #force_inline proc "c" (self: ^PointerType) -> ^StructType { return msgSend(^StructType, self, "elementStructType") } @(objc_type=PointerType, objc_name="elementType") -PointerType_elementType :: #force_inline proc(self: ^PointerType) -> DataType { +PointerType_elementType :: #force_inline proc "c" (self: ^PointerType) -> DataType { return msgSend(DataType, self, "elementType") } @@ -2569,69 +2569,69 @@ Methods: PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="alloc", objc_is_class_method=true) -PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_alloc :: #force_inline proc "c" () -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "alloc") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="init") -PrimitiveAccelerationStructureDescriptor_init :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_init :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, self, "init") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="descriptor", objc_is_class_method=true) -PrimitiveAccelerationStructureDescriptor_descriptor :: #force_inline proc() -> ^PrimitiveAccelerationStructureDescriptor { +PrimitiveAccelerationStructureDescriptor_descriptor :: #force_inline proc "c" () -> ^PrimitiveAccelerationStructureDescriptor { return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="geometryDescriptors") -PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array { +PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "geometryDescriptors") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setGeometryDescriptors") -PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) { +PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) { msgSend(nil, self, "setGeometryDescriptors:", geometryDescriptors) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionStartBorderMode") -PrimitiveAccelerationStructureDescriptor_motionStartBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { +PrimitiveAccelerationStructureDescriptor_motionStartBorderMode :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { return msgSend(MotionBorderMode, self, "motionStartBorderMode") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionStartBorderMode") -PrimitiveAccelerationStructureDescriptor_setMotionStartBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartBorderMode: MotionBorderMode) { +PrimitiveAccelerationStructureDescriptor_setMotionStartBorderMode :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionStartBorderMode: MotionBorderMode) { msgSend(nil, self, "setMotionStartBorderMode:", motionStartBorderMode) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionEndBorderMode") -PrimitiveAccelerationStructureDescriptor_motionEndBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { +PrimitiveAccelerationStructureDescriptor_motionEndBorderMode :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> MotionBorderMode { return msgSend(MotionBorderMode, self, "motionEndBorderMode") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionEndBorderMode") -PrimitiveAccelerationStructureDescriptor_setMotionEndBorderMode :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndBorderMode: MotionBorderMode) { +PrimitiveAccelerationStructureDescriptor_setMotionEndBorderMode :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionEndBorderMode: MotionBorderMode) { msgSend(nil, self, "setMotionEndBorderMode:", motionEndBorderMode) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionStartTime") -PrimitiveAccelerationStructureDescriptor_motionStartTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { +PrimitiveAccelerationStructureDescriptor_motionStartTime :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { return msgSend(f32, self, "motionStartTime") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionStartTime") -PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) { +PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) { msgSend(nil, self, "setMotionStartTime:", motionStartTime) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionEndTime") -PrimitiveAccelerationStructureDescriptor_motionEndTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { +PrimitiveAccelerationStructureDescriptor_motionEndTime :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> f32 { return msgSend(f32, self, "motionEndTime") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionEndTime") -PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) { +PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) { msgSend(nil, self, "setMotionEndTime:", motionEndTime) } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="motionKeyframeCount") -PrimitiveAccelerationStructureDescriptor_motionKeyframeCount :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor) -> NS.UInteger { +PrimitiveAccelerationStructureDescriptor_motionKeyframeCount :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "motionKeyframeCount") } @(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setMotionKeyframeCount") -PrimitiveAccelerationStructureDescriptor_setMotionKeyframeCount :: #force_inline proc(self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: NS.UInteger) { +PrimitiveAccelerationStructureDescriptor_setMotionKeyframeCount :: #force_inline proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: NS.UInteger) { msgSend(nil, self, "setMotionKeyframeCount:", motionKeyframeCount) } @@ -2653,19 +2653,19 @@ Methods: RasterizationRateLayerArray :: struct { using _: NS.Object } @(objc_type=RasterizationRateLayerArray, objc_name="alloc", objc_is_class_method=true) -RasterizationRateLayerArray_alloc :: #force_inline proc() -> ^RasterizationRateLayerArray { +RasterizationRateLayerArray_alloc :: #force_inline proc "c" () -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, RasterizationRateLayerArray, "alloc") } @(objc_type=RasterizationRateLayerArray, objc_name="init") -RasterizationRateLayerArray_init :: #force_inline proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { +RasterizationRateLayerArray_init :: #force_inline proc "c" (self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "init") } @(objc_type=RasterizationRateLayerArray, objc_name="object") -RasterizationRateLayerArray_object :: #force_inline proc(self: ^RasterizationRateLayerArray, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerArray_object :: #force_inline proc "c" (self: ^RasterizationRateLayerArray, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex) } @(objc_type=RasterizationRateLayerArray, objc_name="setObject") -RasterizationRateLayerArray_setObject :: #force_inline proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { +RasterizationRateLayerArray_setObject :: #force_inline proc "c" (self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", layer, layerIndex) } @@ -2690,39 +2690,39 @@ Methods: RasterizationRateLayerDescriptor :: struct { using _: NS.Copying(RasterizationRateLayerDescriptor) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="alloc", objc_is_class_method=true) -RasterizationRateLayerDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_alloc :: #force_inline proc "c" () -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, RasterizationRateLayerDescriptor, "alloc") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontal") -RasterizationRateLayerDescriptor_horizontal :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { +RasterizationRateLayerDescriptor_horizontal :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "horizontal") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontalSampleStorage") -RasterizationRateLayerDescriptor_horizontalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? +RasterizationRateLayerDescriptor_horizontalSampleStorage :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? return msgSend([^]f32, self, "horizontalSampleStorage") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="init") -RasterizationRateLayerDescriptor_init :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_init :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "init") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCount") -RasterizationRateLayerDescriptor_initWithSampleCount :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_initWithSampleCount :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:", sampleCount) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCountWithDimensions") -RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: #force_inline proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: []f32, vertical: []f32) -> ^RasterizationRateLayerDescriptor { +RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: []f32, vertical: []f32) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, raw_data(horizontal), raw_data(vertical)) } @(objc_type=RasterizationRateLayerDescriptor, objc_name="sampleCount") -RasterizationRateLayerDescriptor_sampleCount :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> Size { +RasterizationRateLayerDescriptor_sampleCount :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> Size { return msgSend(Size, self, "sampleCount") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="vertical") -RasterizationRateLayerDescriptor_vertical :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { +RasterizationRateLayerDescriptor_vertical :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "vertical") } @(objc_type=RasterizationRateLayerDescriptor, objc_name="verticalSampleStorage") -RasterizationRateLayerDescriptor_verticalSampleStorage :: #force_inline proc(self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? +RasterizationRateLayerDescriptor_verticalSampleStorage :: #force_inline proc "c" (self: ^RasterizationRateLayerDescriptor) -> [^]f32 { // TODO: how could this be made into a slice? return msgSend([^]f32, self, "verticalSampleStorage") } @@ -2751,55 +2751,55 @@ Methods: RasterizationRateMapDescriptor :: struct { using _: NS.Copying(RasterizationRateMapDescriptor) } @(objc_type=RasterizationRateMapDescriptor, objc_name="alloc", objc_is_class_method=true) -RasterizationRateMapDescriptor_alloc :: #force_inline proc() -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_alloc :: #force_inline proc "c" () -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "alloc") } @(objc_type=RasterizationRateMapDescriptor, objc_name="init") -RasterizationRateMapDescriptor_init :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_init :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, self, "init") } @(objc_type=RasterizationRateMapDescriptor, objc_name="label") -RasterizationRateMapDescriptor_label :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String { +RasterizationRateMapDescriptor_label :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layer") -RasterizationRateMapDescriptor_layer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { +RasterizationRateMapDescriptor_layer :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor, layerIndex: NS.UInteger) -> ^RasterizationRateLayerDescriptor { return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount") -RasterizationRateMapDescriptor_layerCount :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> NS.UInteger { +RasterizationRateMapDescriptor_layerCount :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "layerCount") } @(objc_type=RasterizationRateMapDescriptor, objc_name="layers") -RasterizationRateMapDescriptor_layers :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { +RasterizationRateMapDescriptor_layers :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray { return msgSend(^RasterizationRateLayerArray, self, "layers") } @(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSize", objc_is_class_method=true) -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: #force_inline proc(screenSize: Size) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: #force_inline proc "c" (screenSize: Size) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize) } @(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayer", objc_is_class_method=true) -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer :: #force_inline proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer :: #force_inline proc "c" (screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer) } @(objc_type=RasterizationRateMapDescriptor, objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers", objc_is_class_method=true) -RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc(screenSize: Size, layers: []^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { +RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: #force_inline proc "c" (screenSize: Size, layers: []^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor { return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, NS.UInteger(len(layers)), layers) } @(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize") -RasterizationRateMapDescriptor_screenSize :: #force_inline proc(self: ^RasterizationRateMapDescriptor) -> Size { +RasterizationRateMapDescriptor_screenSize :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor) -> Size { return msgSend(Size, self, "screenSize") } @(objc_type=RasterizationRateMapDescriptor, objc_name="setLabel") -RasterizationRateMapDescriptor_setLabel :: #force_inline proc(self: ^RasterizationRateMapDescriptor, label: ^NS.String) { +RasterizationRateMapDescriptor_setLabel :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setLayer") -RasterizationRateMapDescriptor_setLayer :: #force_inline proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { +RasterizationRateMapDescriptor_setLayer :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: NS.UInteger) { msgSend(nil, self, "setLayer:atIndex:", layer, layerIndex) } @(objc_type=RasterizationRateMapDescriptor, objc_name="setScreenSize") -RasterizationRateMapDescriptor_setScreenSize :: #force_inline proc(self: ^RasterizationRateMapDescriptor, screenSize: Size) { +RasterizationRateMapDescriptor_setScreenSize :: #force_inline proc "c" (self: ^RasterizationRateMapDescriptor, screenSize: Size) { msgSend(nil, self, "setScreenSize:", screenSize) } @@ -2819,19 +2819,19 @@ Methods: RasterizationRateSampleArray :: struct { using _: NS.Object } @(objc_type=RasterizationRateSampleArray, objc_name="alloc", objc_is_class_method=true) -RasterizationRateSampleArray_alloc :: #force_inline proc() -> ^RasterizationRateSampleArray { +RasterizationRateSampleArray_alloc :: #force_inline proc "c" () -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, RasterizationRateSampleArray, "alloc") } @(objc_type=RasterizationRateSampleArray, objc_name="init") -RasterizationRateSampleArray_init :: #force_inline proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { +RasterizationRateSampleArray_init :: #force_inline proc "c" (self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray { return msgSend(^RasterizationRateSampleArray, self, "init") } @(objc_type=RasterizationRateSampleArray, objc_name="object") -RasterizationRateSampleArray_object :: #force_inline proc(self: ^RasterizationRateSampleArray, index: NS.UInteger) -> ^NS.Number { +RasterizationRateSampleArray_object :: #force_inline proc "c" (self: ^RasterizationRateSampleArray, index: NS.UInteger) -> ^NS.Number { return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index) } @(objc_type=RasterizationRateSampleArray, objc_name="setObject") -RasterizationRateSampleArray_setObject :: #force_inline proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: NS.UInteger) { +RasterizationRateSampleArray_setObject :: #force_inline proc "c" (self: ^RasterizationRateSampleArray, value: ^NS.Number, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", value, index) } @@ -2871,99 +2871,99 @@ Methods: RenderPassAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassAttachmentDescriptor) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, RenderPassAttachmentDescriptor, "alloc") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="init") -RenderPassAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { +RenderPassAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor { return msgSend(^RenderPassAttachmentDescriptor, self, "init") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="depthPlane") -RenderPassAttachmentDescriptor_depthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_depthPlane :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "depthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="level") -RenderPassAttachmentDescriptor_level :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_level :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "level") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="loadAction") -RenderPassAttachmentDescriptor_loadAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction { +RenderPassAttachmentDescriptor_loadAction :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> LoadAction { return msgSend(LoadAction, self, "loadAction") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveDepthPlane") -RenderPassAttachmentDescriptor_resolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_resolveDepthPlane :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "resolveDepthPlane") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveLevel") -RenderPassAttachmentDescriptor_resolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_resolveLevel :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "resolveLevel") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveSlice") -RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_resolveSlice :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "resolveSlice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture") -RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^Texture { +RenderPassAttachmentDescriptor_resolveTexture :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> ^Texture { return msgSend(^Texture, self, "resolveTexture") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane") -RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.UInteger) { +RenderPassAttachmentDescriptor_setDepthPlane :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, depthPlane: NS.UInteger) { msgSend(nil, self, "setDepthPlane:", depthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLevel") -RenderPassAttachmentDescriptor_setLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, level: NS.UInteger) { +RenderPassAttachmentDescriptor_setLevel :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, level: NS.UInteger) { msgSend(nil, self, "setLevel:", level) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setLoadAction") -RenderPassAttachmentDescriptor_setLoadAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) { +RenderPassAttachmentDescriptor_setLoadAction :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) { msgSend(nil, self, "setLoadAction:", loadAction) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveDepthPlane") -RenderPassAttachmentDescriptor_setResolveDepthPlane :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.UInteger) { +RenderPassAttachmentDescriptor_setResolveDepthPlane :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.UInteger) { msgSend(nil, self, "setResolveDepthPlane:", resolveDepthPlane) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveLevel") -RenderPassAttachmentDescriptor_setResolveLevel :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.UInteger) { +RenderPassAttachmentDescriptor_setResolveLevel :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.UInteger) { msgSend(nil, self, "setResolveLevel:", resolveLevel) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveSlice") -RenderPassAttachmentDescriptor_setResolveSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.UInteger) { +RenderPassAttachmentDescriptor_setResolveSlice :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.UInteger) { msgSend(nil, self, "setResolveSlice:", resolveSlice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveTexture") -RenderPassAttachmentDescriptor_setResolveTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^Texture) { +RenderPassAttachmentDescriptor_setResolveTexture :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, resolveTexture: ^Texture) { msgSend(nil, self, "setResolveTexture:", resolveTexture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setSlice") -RenderPassAttachmentDescriptor_setSlice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, slice: NS.UInteger) { +RenderPassAttachmentDescriptor_setSlice :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, slice: NS.UInteger) { msgSend(nil, self, "setSlice:", slice) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreAction") -RenderPassAttachmentDescriptor_setStoreAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) { +RenderPassAttachmentDescriptor_setStoreAction :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) { msgSend(nil, self, "setStoreAction:", storeAction) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreActionOptions") -RenderPassAttachmentDescriptor_setStoreActionOptions :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) { +RenderPassAttachmentDescriptor_setStoreActionOptions :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStoreActionOptions:", storeActionOptions) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="setTexture") -RenderPassAttachmentDescriptor_setTexture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor, texture: ^Texture) { +RenderPassAttachmentDescriptor_setTexture :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor, texture: ^Texture) { msgSend(nil, self, "setTexture:", texture) } @(objc_type=RenderPassAttachmentDescriptor, objc_name="slice") -RenderPassAttachmentDescriptor_slice :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { +RenderPassAttachmentDescriptor_slice :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "slice") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="storeAction") -RenderPassAttachmentDescriptor_storeAction :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction { +RenderPassAttachmentDescriptor_storeAction :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> StoreAction { return msgSend(StoreAction, self, "storeAction") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="storeActionOptions") -RenderPassAttachmentDescriptor_storeActionOptions :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions { +RenderPassAttachmentDescriptor_storeActionOptions :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions { return msgSend(StoreActionOptions, self, "storeActionOptions") } @(objc_type=RenderPassAttachmentDescriptor, objc_name="texture") -RenderPassAttachmentDescriptor_texture :: #force_inline proc(self: ^RenderPassAttachmentDescriptor) -> ^Texture { +RenderPassAttachmentDescriptor_texture :: #force_inline proc "c" (self: ^RenderPassAttachmentDescriptor) -> ^Texture { return msgSend(^Texture, self, "texture") } @@ -2983,19 +2983,19 @@ Methods: RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, RenderPassColorAttachmentDescriptor, "alloc") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="init") -RenderPassColorAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "init") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="clearColor") -RenderPassColorAttachmentDescriptor_clearColor :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor) -> ClearColor { +RenderPassColorAttachmentDescriptor_clearColor :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptor) -> ClearColor { return msgSend(ClearColor, self, "clearColor") } @(objc_type=RenderPassColorAttachmentDescriptor, objc_name="setClearColor") -RenderPassColorAttachmentDescriptor_setClearColor :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) { +RenderPassColorAttachmentDescriptor_setClearColor :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) { msgSend(nil, self, "setClearColor:", clearColor) } @@ -3015,19 +3015,19 @@ Methods: RenderPassColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -RenderPassColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassColorAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, RenderPassColorAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="init") -RenderPassColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassColorAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="object") -RenderPassColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassColorAttachmentDescriptor { +RenderPassColorAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassColorAttachmentDescriptor { return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject") -RenderPassColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { +RenderPassColorAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3049,27 +3049,27 @@ Methods: RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassDepthAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDepthAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, RenderPassDepthAttachmentDescriptor, "alloc") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="init") -RenderPassDepthAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDepthAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, self, "init") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="clearDepth") -RenderPassDepthAttachmentDescriptor_clearDepth :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> f64 { +RenderPassDepthAttachmentDescriptor_clearDepth :: #force_inline proc "c" (self: ^RenderPassDepthAttachmentDescriptor) -> f64 { return msgSend(f64, self, "clearDepth") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="depthResolveFilter") -RenderPassDepthAttachmentDescriptor_depthResolveFilter :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter { +RenderPassDepthAttachmentDescriptor_depthResolveFilter :: #force_inline proc "c" (self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter { return msgSend(MultisampleDepthResolveFilter, self, "depthResolveFilter") } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setClearDepth") -RenderPassDepthAttachmentDescriptor_setClearDepth :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) { +RenderPassDepthAttachmentDescriptor_setClearDepth :: #force_inline proc "c" (self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) { msgSend(nil, self, "setClearDepth:", clearDepth) } @(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setDepthResolveFilter") -RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: #force_inline proc(self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) { +RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: #force_inline proc "c" (self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) { msgSend(nil, self, "setDepthResolveFilter:", depthResolveFilter) } @@ -3116,127 +3116,127 @@ Methods: RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor), using _: AccelerationStructureDescriptor } @(objc_type=RenderPassDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassDescriptor_alloc :: #force_inline proc() -> ^RenderPassDescriptor { +RenderPassDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "alloc") } @(objc_type=RenderPassDescriptor, objc_name="init") -RenderPassDescriptor_init :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { +RenderPassDescriptor_init :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, self, "init") } @(objc_type=RenderPassDescriptor, objc_name="colorAttachments") -RenderPassDescriptor_colorAttachments :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray { +RenderPassDescriptor_colorAttachments :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray { return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=RenderPassDescriptor, objc_name="defaultRasterSampleCount") -RenderPassDescriptor_defaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_defaultRasterSampleCount :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "defaultRasterSampleCount") } @(objc_type=RenderPassDescriptor, objc_name="depthAttachment") -RenderPassDescriptor_depthAttachment :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { +RenderPassDescriptor_depthAttachment :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor { return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment") } @(objc_type=RenderPassDescriptor, objc_name="getSamplePositions") -RenderPassDescriptor_getSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) -> NS.UInteger { +RenderPassDescriptor_getSamplePositions :: #force_inline proc "c" (self: ^RenderPassDescriptor, positions: []SamplePosition) -> NS.UInteger { return msgSend(NS.UInteger, self, "getSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength") -RenderPassDescriptor_imageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_imageblockSampleLength :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "imageblockSampleLength") } @(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap") -RenderPassDescriptor_rasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RasterizationRateMap { +RenderPassDescriptor_rasterizationRateMap :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RasterizationRateMap { return msgSend(^RasterizationRateMap, self, "rasterizationRateMap") } @(objc_type=RenderPassDescriptor, objc_name="renderPassDescriptor", objc_is_class_method=true) -RenderPassDescriptor_renderPassDescriptor :: #force_inline proc() -> ^RenderPassDescriptor { +RenderPassDescriptor_renderPassDescriptor :: #force_inline proc "c" () -> ^RenderPassDescriptor { return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetArrayLength") -RenderPassDescriptor_renderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_renderTargetArrayLength :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "renderTargetArrayLength") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetHeight") -RenderPassDescriptor_renderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_renderTargetHeight :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "renderTargetHeight") } @(objc_type=RenderPassDescriptor, objc_name="renderTargetWidth") -RenderPassDescriptor_renderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_renderTargetWidth :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "renderTargetWidth") } @(objc_type=RenderPassDescriptor, objc_name="sampleBufferAttachments") -RenderPassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassDescriptor_sampleBufferAttachments :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @(objc_type=RenderPassDescriptor, objc_name="setDefaultRasterSampleCount") -RenderPassDescriptor_setDefaultRasterSampleCount :: #force_inline proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.UInteger) { +RenderPassDescriptor_setDefaultRasterSampleCount :: #force_inline proc "c" (self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.UInteger) { msgSend(nil, self, "setDefaultRasterSampleCount:", defaultRasterSampleCount) } @(objc_type=RenderPassDescriptor, objc_name="setDepthAttachment") -RenderPassDescriptor_setDepthAttachment :: #force_inline proc(self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) { +RenderPassDescriptor_setDepthAttachment :: #force_inline proc "c" (self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) { msgSend(nil, self, "setDepthAttachment:", depthAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setImageblockSampleLength") -RenderPassDescriptor_setImageblockSampleLength :: #force_inline proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.UInteger) { +RenderPassDescriptor_setImageblockSampleLength :: #force_inline proc "c" (self: ^RenderPassDescriptor, imageblockSampleLength: NS.UInteger) { msgSend(nil, self, "setImageblockSampleLength:", imageblockSampleLength) } @(objc_type=RenderPassDescriptor, objc_name="setRasterizationRateMap") -RenderPassDescriptor_setRasterizationRateMap :: #force_inline proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^RasterizationRateMap) { +RenderPassDescriptor_setRasterizationRateMap :: #force_inline proc "c" (self: ^RenderPassDescriptor, rasterizationRateMap: ^RasterizationRateMap) { msgSend(nil, self, "setRasterizationRateMap:", rasterizationRateMap) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetArrayLength") -RenderPassDescriptor_setRenderTargetArrayLength :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.UInteger) { +RenderPassDescriptor_setRenderTargetArrayLength :: #force_inline proc "c" (self: ^RenderPassDescriptor, renderTargetArrayLength: NS.UInteger) { msgSend(nil, self, "setRenderTargetArrayLength:", renderTargetArrayLength) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetHeight") -RenderPassDescriptor_setRenderTargetHeight :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.UInteger) { +RenderPassDescriptor_setRenderTargetHeight :: #force_inline proc "c" (self: ^RenderPassDescriptor, renderTargetHeight: NS.UInteger) { msgSend(nil, self, "setRenderTargetHeight:", renderTargetHeight) } @(objc_type=RenderPassDescriptor, objc_name="setRenderTargetWidth") -RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.UInteger) { +RenderPassDescriptor_setRenderTargetWidth :: #force_inline proc "c" (self: ^RenderPassDescriptor, renderTargetWidth: NS.UInteger) { msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth) } @(objc_type=RenderPassDescriptor, objc_name="setSamplePositions") -RenderPassDescriptor_setSamplePositions :: #force_inline proc(self: ^RenderPassDescriptor, positions: []SamplePosition) { +RenderPassDescriptor_setSamplePositions :: #force_inline proc "c" (self: ^RenderPassDescriptor, positions: []SamplePosition) { msgSend(nil, self, "setSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment") -RenderPassDescriptor_setStencilAttachment :: #force_inline proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { +RenderPassDescriptor_setStencilAttachment :: #force_inline proc "c" (self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) { msgSend(nil, self, "setStencilAttachment:", stencilAttachment) } @(objc_type=RenderPassDescriptor, objc_name="setThreadgroupMemoryLength") -RenderPassDescriptor_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.UInteger) { +RenderPassDescriptor_setThreadgroupMemoryLength :: #force_inline proc "c" (self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:", threadgroupMemoryLength) } @(objc_type=RenderPassDescriptor, objc_name="setTileHeight") -RenderPassDescriptor_setTileHeight :: #force_inline proc(self: ^RenderPassDescriptor, tileHeight: NS.UInteger) { +RenderPassDescriptor_setTileHeight :: #force_inline proc "c" (self: ^RenderPassDescriptor, tileHeight: NS.UInteger) { msgSend(nil, self, "setTileHeight:", tileHeight) } @(objc_type=RenderPassDescriptor, objc_name="setTileWidth") -RenderPassDescriptor_setTileWidth :: #force_inline proc(self: ^RenderPassDescriptor, tileWidth: NS.UInteger) { +RenderPassDescriptor_setTileWidth :: #force_inline proc "c" (self: ^RenderPassDescriptor, tileWidth: NS.UInteger) { msgSend(nil, self, "setTileWidth:", tileWidth) } @(objc_type=RenderPassDescriptor, objc_name="setVisibilityResultBuffer") -RenderPassDescriptor_setVisibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^Buffer) { +RenderPassDescriptor_setVisibilityResultBuffer :: #force_inline proc "c" (self: ^RenderPassDescriptor, visibilityResultBuffer: ^Buffer) { msgSend(nil, self, "setVisibilityResultBuffer:", visibilityResultBuffer) } @(objc_type=RenderPassDescriptor, objc_name="stencilAttachment") -RenderPassDescriptor_stencilAttachment :: #force_inline proc(self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor { +RenderPassDescriptor_stencilAttachment :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, self, "stencilAttachment") } @(objc_type=RenderPassDescriptor, objc_name="threadgroupMemoryLength") -RenderPassDescriptor_threadgroupMemoryLength :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_threadgroupMemoryLength :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadgroupMemoryLength") } @(objc_type=RenderPassDescriptor, objc_name="tileHeight") -RenderPassDescriptor_tileHeight :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_tileHeight :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "tileHeight") } @(objc_type=RenderPassDescriptor, objc_name="tileWidth") -RenderPassDescriptor_tileWidth :: #force_inline proc(self: ^RenderPassDescriptor) -> NS.UInteger { +RenderPassDescriptor_tileWidth :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "tileWidth") } @(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer") -RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc(self: ^RenderPassDescriptor) -> ^Buffer { +RenderPassDescriptor_visibilityResultBuffer :: #force_inline proc "c" (self: ^RenderPassDescriptor) -> ^Buffer { return msgSend(^Buffer, self, "visibilityResultBuffer") } @@ -3264,51 +3264,51 @@ Methods: RenderPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassSampleBufferAttachmentDescriptor) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, RenderPassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="init") -RenderPassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfVertexSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { +RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.UInteger) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfFragmentSampleIndex:", endOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.UInteger) { +RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { +RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.UInteger) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfFragmentSampleIndex:", startOfFragmentSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.UInteger) { +RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfVertexSampleIndex:", startOfVertexSampleIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfFragmentSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfFragmentSampleIndex") } @(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfVertexSampleIndex") -RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { +RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfVertexSampleIndex") } @@ -3328,19 +3328,19 @@ Methods: RenderPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -RenderPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, RenderPassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="init") -RenderPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { +RenderPassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray { return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="object") -RenderPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassSampleBufferAttachmentDescriptor { +RenderPassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPassSampleBufferAttachmentDescriptor { return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -RenderPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { +RenderPassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3362,27 +3362,27 @@ Methods: RenderPassStencilAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassStencilAttachmentDescriptor) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPassStencilAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPassStencilAttachmentDescriptor { +RenderPassStencilAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, RenderPassStencilAttachmentDescriptor, "alloc") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="init") -RenderPassStencilAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor { +RenderPassStencilAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor { return msgSend(^RenderPassStencilAttachmentDescriptor, self, "init") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="clearStencil") -RenderPassStencilAttachmentDescriptor_clearStencil :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> u32 { +RenderPassStencilAttachmentDescriptor_clearStencil :: #force_inline proc "c" (self: ^RenderPassStencilAttachmentDescriptor) -> u32 { return msgSend(u32, self, "clearStencil") } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setClearStencil") -RenderPassStencilAttachmentDescriptor_setClearStencil :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) { +RenderPassStencilAttachmentDescriptor_setClearStencil :: #force_inline proc "c" (self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) { msgSend(nil, self, "setClearStencil:", clearStencil) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setStencilResolveFilter") -RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) { +RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: #force_inline proc "c" (self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) { msgSend(nil, self, "setStencilResolveFilter:", stencilResolveFilter) } @(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="stencilResolveFilter") -RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: #force_inline proc(self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter { +RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: #force_inline proc "c" (self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter { return msgSend(MultisampleStencilResolveFilter, self, "stencilResolveFilter") } @@ -3418,83 +3418,83 @@ Methods: RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor), using _: RenderPassAttachmentDescriptor } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, RenderPipelineColorAttachmentDescriptor, "alloc") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="init") -RenderPipelineColorAttachmentDescriptor_init :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptor_init :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "init") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alphaBlendOperation") -RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { +RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { return msgSend(BlendOperation, self, "alphaBlendOperation") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "destinationAlphaBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "destinationRGBBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="isBlendingEnabled") -RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL { +RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL { return msgSend(BOOL, self, "isBlendingEnabled") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") -RenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat { +RenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="rgbBlendOperation") -RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { +RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation { return msgSend(BlendOperation, self, "rgbBlendOperation") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setAlphaBlendOperation") -RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) { +RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) { msgSend(nil, self, "setAlphaBlendOperation:", alphaBlendOperation) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setBlendingEnabled") -RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) { +RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) { msgSend(nil, self, "setBlendingEnabled:", blendingEnabled) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) { msgSend(nil, self, "setDestinationAlphaBlendFactor:", destinationAlphaBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) { msgSend(nil, self, "setDestinationRGBBlendFactor:", destinationRGBBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") -RenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { +RenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setRgbBlendOperation") -RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) { +RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) { msgSend(nil, self, "setRgbBlendOperation:", rgbBlendOperation) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) { msgSend(nil, self, "setSourceAlphaBlendFactor:", sourceAlphaBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) { +RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) { msgSend(nil, self, "setSourceRGBBlendFactor:", sourceRGBBlendFactor) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setWriteMask") -RenderPipelineColorAttachmentDescriptor_setWriteMask :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) { +RenderPipelineColorAttachmentDescriptor_setWriteMask :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) { msgSend(nil, self, "setWriteMask:", writeMask) } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceAlphaBlendFactor") -RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "sourceAlphaBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceRGBBlendFactor") -RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { +RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor { return msgSend(BlendFactor, self, "sourceRGBBlendFactor") } @(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="writeMask") -RenderPipelineColorAttachmentDescriptor_writeMask :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask { +RenderPipelineColorAttachmentDescriptor_writeMask :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask { return msgSend(ColorWriteMask, self, "writeMask") } @@ -3514,19 +3514,19 @@ Methods: RenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -RenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, RenderPipelineColorAttachmentDescriptorArray, "alloc") } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="init") -RenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="object") -RenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPipelineColorAttachmentDescriptor { +RenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^RenderPipelineColorAttachmentDescriptor { return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -RenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { +RenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -3592,297 +3592,297 @@ Methods: RenderPipelineDescriptor :: struct { using _: NS.Copying(RenderPipelineDescriptor) } @(objc_type=RenderPipelineDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPipelineDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, RenderPipelineDescriptor, "alloc") } @(objc_type=RenderPipelineDescriptor, objc_name="init") -RenderPipelineDescriptor_init :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { +RenderPipelineDescriptor_init :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor { return msgSend(^RenderPipelineDescriptor, self, "init") } @(objc_type=RenderPipelineDescriptor, objc_name="binaryArchives") -RenderPipelineDescriptor_binaryArchives :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^NS.Array { +RenderPipelineDescriptor_binaryArchives :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=RenderPipelineDescriptor, objc_name="colorAttachments") -RenderPipelineDescriptor_colorAttachments :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray { +RenderPipelineDescriptor_colorAttachments :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray { return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=RenderPipelineDescriptor, objc_name="depthAttachmentPixelFormat") -RenderPipelineDescriptor_depthAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PixelFormat { +RenderPipelineDescriptor_depthAttachmentPixelFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "depthAttachmentPixelFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="fragmentBuffers") -RenderPipelineDescriptor_fragmentBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_fragmentBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "fragmentBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="fragmentFunction") -RenderPipelineDescriptor_fragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { +RenderPipelineDescriptor_fragmentFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^Function { return msgSend(^Function, self, "fragmentFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="inputPrimitiveTopology") -RenderPipelineDescriptor_inputPrimitiveTopology :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { +RenderPipelineDescriptor_inputPrimitiveTopology :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass { return msgSend(PrimitiveTopologyClass, self, "inputPrimitiveTopology") } @(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToCoverageEnabled") -RenderPipelineDescriptor_isAlphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isAlphaToCoverageEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isAlphaToCoverageEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToOneEnabled") -RenderPipelineDescriptor_isAlphaToOneEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isAlphaToOneEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isAlphaToOneEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isRasterizationEnabled") -RenderPipelineDescriptor_isRasterizationEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isRasterizationEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isRasterizationEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="isTessellationFactorScaleEnabled") -RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "isTessellationFactorScaleEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="label") -RenderPipelineDescriptor_label :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^NS.String { +RenderPipelineDescriptor_label :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineDescriptor, objc_name="maxTessellationFactor") -RenderPipelineDescriptor_maxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_maxTessellationFactor :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTessellationFactor") } @(objc_type=RenderPipelineDescriptor, objc_name="maxVertexAmplificationCount") -RenderPipelineDescriptor_maxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_maxVertexAmplificationCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxVertexAmplificationCount") } @(objc_type=RenderPipelineDescriptor, objc_name="rasterSampleCount") -RenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_rasterSampleCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "rasterSampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="reset") -RenderPipelineDescriptor_reset :: #force_inline proc(self: ^RenderPipelineDescriptor) { +RenderPipelineDescriptor_reset :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=RenderPipelineDescriptor, objc_name="sampleCount") -RenderPipelineDescriptor_sampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_sampleCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToCoverageEnabled") -RenderPipelineDescriptor_setAlphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { +RenderPipelineDescriptor_setAlphaToCoverageEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) { msgSend(nil, self, "setAlphaToCoverageEnabled:", alphaToCoverageEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToOneEnabled") -RenderPipelineDescriptor_setAlphaToOneEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) { +RenderPipelineDescriptor_setAlphaToOneEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) { msgSend(nil, self, "setAlphaToOneEnabled:", alphaToOneEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setBinaryArchives") -RenderPipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) { +RenderPipelineDescriptor_setBinaryArchives :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=RenderPipelineDescriptor, objc_name="setDepthAttachmentPixelFormat") -RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) { +RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) { msgSend(nil, self, "setDepthAttachmentPixelFormat:", depthAttachmentPixelFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setFragmentFunction") -RenderPipelineDescriptor_setFragmentFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^Function) { +RenderPipelineDescriptor_setFragmentFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, fragmentFunction: ^Function) { msgSend(nil, self, "setFragmentFunction:", fragmentFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="setInputPrimitiveTopology") -RenderPipelineDescriptor_setInputPrimitiveTopology :: #force_inline proc(self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) { +RenderPipelineDescriptor_setInputPrimitiveTopology :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) { msgSend(nil, self, "setInputPrimitiveTopology:", inputPrimitiveTopology) } @(objc_type=RenderPipelineDescriptor, objc_name="setLabel") -RenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^RenderPipelineDescriptor, label: ^NS.String) { +RenderPipelineDescriptor_setLabel :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTessellationFactor") -RenderPipelineDescriptor_setMaxTessellationFactor :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.UInteger) { +RenderPipelineDescriptor_setMaxTessellationFactor :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.UInteger) { msgSend(nil, self, "setMaxTessellationFactor:", maxTessellationFactor) } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxVertexAmplificationCount") -RenderPipelineDescriptor_setMaxVertexAmplificationCount :: #force_inline proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.UInteger) { +RenderPipelineDescriptor_setMaxVertexAmplificationCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.UInteger) { msgSend(nil, self, "setMaxVertexAmplificationCount:", maxVertexAmplificationCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterSampleCount") -RenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { +RenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setRasterizationEnabled") -RenderPipelineDescriptor_setRasterizationEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) { +RenderPipelineDescriptor_setRasterizationEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) { msgSend(nil, self, "setRasterizationEnabled:", rasterizationEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setSampleCount") -RenderPipelineDescriptor_setSampleCount :: #force_inline proc(self: ^RenderPipelineDescriptor, sampleCount: NS.UInteger) { +RenderPipelineDescriptor_setSampleCount :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=RenderPipelineDescriptor, objc_name="setStencilAttachmentPixelFormat") -RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) { +RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) { msgSend(nil, self, "setStencilAttachmentPixelFormat:", stencilAttachmentPixelFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setSupportIndirectCommandBuffers") -RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) { +RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) { msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationControlPointIndexType") -RenderPipelineDescriptor_setTessellationControlPointIndexType :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) { +RenderPipelineDescriptor_setTessellationControlPointIndexType :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) { msgSend(nil, self, "setTessellationControlPointIndexType:", tessellationControlPointIndexType) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorFormat") -RenderPipelineDescriptor_setTessellationFactorFormat :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) { +RenderPipelineDescriptor_setTessellationFactorFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) { msgSend(nil, self, "setTessellationFactorFormat:", tessellationFactorFormat) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorScaleEnabled") -RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) { +RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) { msgSend(nil, self, "setTessellationFactorScaleEnabled:", tessellationFactorScaleEnabled) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorStepFunction") -RenderPipelineDescriptor_setTessellationFactorStepFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) { +RenderPipelineDescriptor_setTessellationFactorStepFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) { msgSend(nil, self, "setTessellationFactorStepFunction:", tessellationFactorStepFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationOutputWindingOrder") -RenderPipelineDescriptor_setTessellationOutputWindingOrder :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) { +RenderPipelineDescriptor_setTessellationOutputWindingOrder :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) { msgSend(nil, self, "setTessellationOutputWindingOrder:", tessellationOutputWindingOrder) } @(objc_type=RenderPipelineDescriptor, objc_name="setTessellationPartitionMode") -RenderPipelineDescriptor_setTessellationPartitionMode :: #force_inline proc(self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) { +RenderPipelineDescriptor_setTessellationPartitionMode :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) { msgSend(nil, self, "setTessellationPartitionMode:", tessellationPartitionMode) } @(objc_type=RenderPipelineDescriptor, objc_name="setVertexDescriptor") -RenderPipelineDescriptor_setVertexDescriptor :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) { +RenderPipelineDescriptor_setVertexDescriptor :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) { msgSend(nil, self, "setVertexDescriptor:", vertexDescriptor) } @(objc_type=RenderPipelineDescriptor, objc_name="setVertexFunction") -RenderPipelineDescriptor_setVertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, vertexFunction: ^Function) { +RenderPipelineDescriptor_setVertexFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, vertexFunction: ^Function) { msgSend(nil, self, "setVertexFunction:", vertexFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="stencilAttachmentPixelFormat") -RenderPipelineDescriptor_stencilAttachmentPixelFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> PixelFormat { +RenderPipelineDescriptor_stencilAttachmentPixelFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "stencilAttachmentPixelFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="supportIndirectCommandBuffers") -RenderPipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_supportIndirectCommandBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationControlPointIndexType") -RenderPipelineDescriptor_tessellationControlPointIndexType :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType { +RenderPipelineDescriptor_tessellationControlPointIndexType :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType { return msgSend(TessellationControlPointIndexType, self, "tessellationControlPointIndexType") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorFormat") -RenderPipelineDescriptor_tessellationFactorFormat :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationFactorFormat { +RenderPipelineDescriptor_tessellationFactorFormat :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> TessellationFactorFormat { return msgSend(TessellationFactorFormat, self, "tessellationFactorFormat") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorStepFunction") -RenderPipelineDescriptor_tessellationFactorStepFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction { +RenderPipelineDescriptor_tessellationFactorStepFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction { return msgSend(TessellationFactorStepFunction, self, "tessellationFactorStepFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationOutputWindingOrder") -RenderPipelineDescriptor_tessellationOutputWindingOrder :: #force_inline proc(self: ^RenderPipelineDescriptor) -> Winding { +RenderPipelineDescriptor_tessellationOutputWindingOrder :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> Winding { return msgSend(Winding, self, "tessellationOutputWindingOrder") } @(objc_type=RenderPipelineDescriptor, objc_name="tessellationPartitionMode") -RenderPipelineDescriptor_tessellationPartitionMode :: #force_inline proc(self: ^RenderPipelineDescriptor) -> TessellationPartitionMode { +RenderPipelineDescriptor_tessellationPartitionMode :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> TessellationPartitionMode { return msgSend(TessellationPartitionMode, self, "tessellationPartitionMode") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexBuffers") -RenderPipelineDescriptor_vertexBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_vertexBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "vertexBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexDescriptor") -RenderPipelineDescriptor_vertexDescriptor :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^VertexDescriptor { +RenderPipelineDescriptor_vertexDescriptor :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^VertexDescriptor { return msgSend(^VertexDescriptor, self, "vertexDescriptor") } @(objc_type=RenderPipelineDescriptor, objc_name="vertexFunction") -RenderPipelineDescriptor_vertexFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { +RenderPipelineDescriptor_vertexFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^Function { return msgSend(^Function, self, "vertexFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="objectFunction") -RenderPipelineDescriptor_objectFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { +RenderPipelineDescriptor_objectFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^Function { return msgSend(^Function, self, "objectFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="setObjectFunction") -RenderPipelineDescriptor_setObjectFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, objectFunction: ^Function) { +RenderPipelineDescriptor_setObjectFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, objectFunction: ^Function) { msgSend(nil, self, "setObjectFunction:", objectFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="meshFunction") -RenderPipelineDescriptor_meshFunction :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^Function { +RenderPipelineDescriptor_meshFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^Function { return msgSend(^Function, self, "meshFunction") } @(objc_type=RenderPipelineDescriptor, objc_name="setMeshFunction") -RenderPipelineDescriptor_setMeshFunction :: #force_inline proc(self: ^RenderPipelineDescriptor, meshFunction: ^Function) { +RenderPipelineDescriptor_setMeshFunction :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, meshFunction: ^Function) { msgSend(nil, self, "setMeshFunction:", meshFunction) } @(objc_type=RenderPipelineDescriptor, objc_name="maxTotalThreadsPerObjectThreadgroup") -RenderPipelineDescriptor_maxTotalThreadsPerObjectThreadgroup :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_maxTotalThreadsPerObjectThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerObjectThreadgroup") } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerObjectThreadgroup") -RenderPipelineDescriptor_setMaxTotalThreadsPerObjectThreadgroup :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTotalThreadsPerObjectThreadgroup: NS.UInteger) { +RenderPipelineDescriptor_setMaxTotalThreadsPerObjectThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, maxTotalThreadsPerObjectThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerObjectThreadgroup:", maxTotalThreadsPerObjectThreadgroup) } @(objc_type=RenderPipelineDescriptor, objc_name="maxTotalThreadsPerMeshThreadgroup") -RenderPipelineDescriptor_maxTotalThreadsPerMeshThreadgroup :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_maxTotalThreadsPerMeshThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerMeshThreadgroup") } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerMeshThreadgroup") -RenderPipelineDescriptor_setMaxTotalThreadsPerMeshThreadgroup :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTotalThreadsPerMeshThreadgroup: NS.UInteger) { +RenderPipelineDescriptor_setMaxTotalThreadsPerMeshThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, maxTotalThreadsPerMeshThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerMeshThreadgroup:", maxTotalThreadsPerMeshThreadgroup) } @(objc_type=RenderPipelineDescriptor, objc_name="objectThreadgroupSizeIsMultipleOfThreadExecutionWidth") -RenderPipelineDescriptor_objectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_objectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "objectThreadgroupSizeIsMultipleOfThreadExecutionWidth") } @(objc_type=RenderPipelineDescriptor, objc_name="setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth") -RenderPipelineDescriptor_setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineDescriptor, objectThreadgroupSizeIsMultipleOfThreadExecutionWidth: NS.UInteger) { +RenderPipelineDescriptor_setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, objectThreadgroupSizeIsMultipleOfThreadExecutionWidth: NS.UInteger) { msgSend(nil, self, "setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth:", objectThreadgroupSizeIsMultipleOfThreadExecutionWidth) } @(objc_type=RenderPipelineDescriptor, objc_name="meshThreadgroupSizeIsMultipleOfThreadExecutionWidth") -RenderPipelineDescriptor_meshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_meshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "meshThreadgroupSizeIsMultipleOfThreadExecutionWidth") } @(objc_type=RenderPipelineDescriptor, objc_name="setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth") -RenderPipelineDescriptor_setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineDescriptor, meshThreadgroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { +RenderPipelineDescriptor_setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, meshThreadgroupSizeIsMultipleOfThreadExecutionWidth: BOOL) { msgSend(nil, self, "setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth:", meshThreadgroupSizeIsMultipleOfThreadExecutionWidth) } @(objc_type=RenderPipelineDescriptor, objc_name="payloadMemoryLength") -RenderPipelineDescriptor_payloadMemoryLength :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_payloadMemoryLength :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "payloadMemoryLength") } @(objc_type=RenderPipelineDescriptor, objc_name="setPayloadMemoryLength") -RenderPipelineDescriptor_setPayloadMemoryLength :: #force_inline proc(self: ^RenderPipelineDescriptor, payloadMemoryLength: NS.UInteger) { +RenderPipelineDescriptor_setPayloadMemoryLength :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, payloadMemoryLength: NS.UInteger) { msgSend(nil, self, "setPayloadMemoryLength:", payloadMemoryLength) } @(objc_type=RenderPipelineDescriptor, objc_name="maxTotalThreadgroupsPerMeshGrid") -RenderPipelineDescriptor_maxTotalThreadgroupsPerMeshGrid :: #force_inline proc(self: ^RenderPipelineDescriptor) -> NS.UInteger { +RenderPipelineDescriptor_maxTotalThreadgroupsPerMeshGrid :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadgroupsPerMeshGrid") } @(objc_type=RenderPipelineDescriptor, objc_name="setMaxTotalThreadgroupsPerMeshGrid") -RenderPipelineDescriptor_setMaxTotalThreadgroupsPerMeshGrid :: #force_inline proc(self: ^RenderPipelineDescriptor, maxTotalThreadgroupsPerMeshGrid: NS.UInteger) { +RenderPipelineDescriptor_setMaxTotalThreadgroupsPerMeshGrid :: #force_inline proc "c" (self: ^RenderPipelineDescriptor, maxTotalThreadgroupsPerMeshGrid: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadgroupsPerMeshGrid:", maxTotalThreadgroupsPerMeshGrid) } @(objc_type=RenderPipelineDescriptor, objc_name="objectBuffers") -RenderPipelineDescriptor_objectBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_objectBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "objectBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="meshBuffers") -RenderPipelineDescriptor_meshBuffers :: #force_inline proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +RenderPipelineDescriptor_meshBuffers :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "meshBuffers") } @(objc_type=RenderPipelineDescriptor, objc_name="alphaToCoverageEnabled") -RenderPipelineDescriptor_alphaToCoverageEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_alphaToCoverageEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "alphaToCoverageEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="alphaToOneEnabled") -RenderPipelineDescriptor_alphaToOneEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_alphaToOneEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "alphaToOneEnabled") } @(objc_type=RenderPipelineDescriptor, objc_name="rasterizationEnabled") -RenderPipelineDescriptor_rasterizationEnabled :: #force_inline proc(self: ^RenderPipelineDescriptor) -> BOOL { +RenderPipelineDescriptor_rasterizationEnabled :: #force_inline proc "c" (self: ^RenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "rasterizationEnabled") } @@ -3904,44 +3904,44 @@ Methods: RenderPipelineReflection :: struct { using _: NS.Object } @(objc_type=RenderPipelineReflection, objc_name="alloc", objc_is_class_method=true) -RenderPipelineReflection_alloc :: #force_inline proc() -> ^RenderPipelineReflection { +RenderPipelineReflection_alloc :: #force_inline proc "c" () -> ^RenderPipelineReflection { return msgSend(^RenderPipelineReflection, RenderPipelineReflection, "alloc") } @(objc_type=RenderPipelineReflection, objc_name="init") -RenderPipelineReflection_init :: #force_inline proc(self: ^RenderPipelineReflection) -> ^RenderPipelineReflection { +RenderPipelineReflection_init :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^RenderPipelineReflection { return msgSend(^RenderPipelineReflection, self, "init") } @(objc_type=RenderPipelineReflection, objc_name="fragmentArguments") -RenderPipelineReflection_fragmentArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_fragmentArguments :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "fragmentArguments") } @(objc_type=RenderPipelineReflection, objc_name="tileArguments") -RenderPipelineReflection_tileArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_tileArguments :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "tileArguments") } @(objc_type=RenderPipelineReflection, objc_name="vertexArguments") -RenderPipelineReflection_vertexArguments :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_vertexArguments :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexArguments") } @(objc_type=RenderPipelineReflection, objc_name="vertexBindings") -RenderPipelineReflection_vertexBindings :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_vertexBindings :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexBindings") } @(objc_type=RenderPipelineReflection, objc_name="fragmentBindings") -RenderPipelineReflection_fragmentBindings :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_fragmentBindings :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "fragmentBindings") } @(objc_type=RenderPipelineReflection, objc_name="tileBindings") -RenderPipelineReflection_tileBindings :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_tileBindings :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "tileBindings") } @(objc_type=RenderPipelineReflection, objc_name="objectBindings") -RenderPipelineReflection_objectBindings :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_objectBindings :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "objectBindings") } @(objc_type=RenderPipelineReflection, objc_name="meshBindings") -RenderPipelineReflection_meshBindings :: #force_inline proc(self: ^RenderPipelineReflection) -> ^NS.Array { +RenderPipelineReflection_meshBindings :: #force_inline proc "c" (self: ^RenderPipelineReflection) -> ^NS.Array { return msgSend(^NS.Array, self, "meshBindings") } @@ -3961,19 +3961,19 @@ Methods: ResourceStatePassDescriptor :: struct { using _: NS.Copying(ResourceStatePassDescriptor) } @(objc_type=ResourceStatePassDescriptor, objc_name="alloc", objc_is_class_method=true) -ResourceStatePassDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_alloc :: #force_inline proc "c" () -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "alloc") } @(objc_type=ResourceStatePassDescriptor, objc_name="init") -ResourceStatePassDescriptor_init :: #force_inline proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_init :: #force_inline proc "c" (self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, self, "init") } @(objc_type=ResourceStatePassDescriptor, objc_name="resourceStatePassDescriptor", objc_is_class_method=true) -ResourceStatePassDescriptor_resourceStatePassDescriptor :: #force_inline proc() -> ^ResourceStatePassDescriptor { +ResourceStatePassDescriptor_resourceStatePassDescriptor :: #force_inline proc "c" () -> ^ResourceStatePassDescriptor { return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "resourceStatePassDescriptor") } @(objc_type=ResourceStatePassDescriptor, objc_name="sampleBufferAttachments") -ResourceStatePassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassDescriptor_sampleBufferAttachments :: #force_inline proc "c" (self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @@ -3997,35 +3997,35 @@ Methods: ResourceStatePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ResourceStatePassSampleBufferAttachmentDescriptor) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, ResourceStatePassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="init") -ResourceStatePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptor_init :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { +ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { +ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { +ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { +ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } @@ -4045,19 +4045,19 @@ Methods: ResourceStatePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, ResourceStatePassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="init") -ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { +ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="object") -ResourceStatePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { +ResourceStatePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^ResourceStatePassSampleBufferAttachmentDescriptor { return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { +ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -4105,131 +4105,131 @@ Methods: SamplerDescriptor :: struct { using _: NS.Copying(SamplerDescriptor) } @(objc_type=SamplerDescriptor, objc_name="alloc", objc_is_class_method=true) -SamplerDescriptor_alloc :: #force_inline proc() -> ^SamplerDescriptor { +SamplerDescriptor_alloc :: #force_inline proc "c" () -> ^SamplerDescriptor { return msgSend(^SamplerDescriptor, SamplerDescriptor, "alloc") } @(objc_type=SamplerDescriptor, objc_name="init") -SamplerDescriptor_init :: #force_inline proc(self: ^SamplerDescriptor) -> ^SamplerDescriptor { +SamplerDescriptor_init :: #force_inline proc "c" (self: ^SamplerDescriptor) -> ^SamplerDescriptor { return msgSend(^SamplerDescriptor, self, "init") } @(objc_type=SamplerDescriptor, objc_name="borderColor") -SamplerDescriptor_borderColor :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerBorderColor { +SamplerDescriptor_borderColor :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerBorderColor { return msgSend(SamplerBorderColor, self, "borderColor") } @(objc_type=SamplerDescriptor, objc_name="compareFunction") -SamplerDescriptor_compareFunction :: #force_inline proc(self: ^SamplerDescriptor) -> CompareFunction { +SamplerDescriptor_compareFunction :: #force_inline proc "c" (self: ^SamplerDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "compareFunction") } @(objc_type=SamplerDescriptor, objc_name="label") -SamplerDescriptor_label :: #force_inline proc(self: ^SamplerDescriptor) -> ^NS.String { +SamplerDescriptor_label :: #force_inline proc "c" (self: ^SamplerDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=SamplerDescriptor, objc_name="lodAverage") -SamplerDescriptor_lodAverage :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_lodAverage :: #force_inline proc "c" (self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "lodAverage") } @(objc_type=SamplerDescriptor, objc_name="lodMaxClamp") -SamplerDescriptor_lodMaxClamp :: #force_inline proc(self: ^SamplerDescriptor) -> f32 { +SamplerDescriptor_lodMaxClamp :: #force_inline proc "c" (self: ^SamplerDescriptor) -> f32 { return msgSend(f32, self, "lodMaxClamp") } @(objc_type=SamplerDescriptor, objc_name="lodMinClamp") -SamplerDescriptor_lodMinClamp :: #force_inline proc(self: ^SamplerDescriptor) -> f32 { +SamplerDescriptor_lodMinClamp :: #force_inline proc "c" (self: ^SamplerDescriptor) -> f32 { return msgSend(f32, self, "lodMinClamp") } @(objc_type=SamplerDescriptor, objc_name="magFilter") -SamplerDescriptor_magFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { +SamplerDescriptor_magFilter :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerMinMagFilter { return msgSend(SamplerMinMagFilter, self, "magFilter") } @(objc_type=SamplerDescriptor, objc_name="maxAnisotropy") -SamplerDescriptor_maxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor) -> NS.UInteger { +SamplerDescriptor_maxAnisotropy :: #force_inline proc "c" (self: ^SamplerDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxAnisotropy") } @(objc_type=SamplerDescriptor, objc_name="minFilter") -SamplerDescriptor_minFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter { +SamplerDescriptor_minFilter :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerMinMagFilter { return msgSend(SamplerMinMagFilter, self, "minFilter") } @(objc_type=SamplerDescriptor, objc_name="mipFilter") -SamplerDescriptor_mipFilter :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerMipFilter { +SamplerDescriptor_mipFilter :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerMipFilter { return msgSend(SamplerMipFilter, self, "mipFilter") } @(objc_type=SamplerDescriptor, objc_name="normalizedCoordinates") -SamplerDescriptor_normalizedCoordinates :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_normalizedCoordinates :: #force_inline proc "c" (self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "normalizedCoordinates") } @(objc_type=SamplerDescriptor, objc_name="rAddressMode") -SamplerDescriptor_rAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_rAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "rAddressMode") } @(objc_type=SamplerDescriptor, objc_name="sAddressMode") -SamplerDescriptor_sAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_sAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "sAddressMode") } @(objc_type=SamplerDescriptor, objc_name="setBorderColor") -SamplerDescriptor_setBorderColor :: #force_inline proc(self: ^SamplerDescriptor, borderColor: SamplerBorderColor) { +SamplerDescriptor_setBorderColor :: #force_inline proc "c" (self: ^SamplerDescriptor, borderColor: SamplerBorderColor) { msgSend(nil, self, "setBorderColor:", borderColor) } @(objc_type=SamplerDescriptor, objc_name="setCompareFunction") -SamplerDescriptor_setCompareFunction :: #force_inline proc(self: ^SamplerDescriptor, compareFunction: CompareFunction) { +SamplerDescriptor_setCompareFunction :: #force_inline proc "c" (self: ^SamplerDescriptor, compareFunction: CompareFunction) { msgSend(nil, self, "setCompareFunction:", compareFunction) } @(objc_type=SamplerDescriptor, objc_name="setLabel") -SamplerDescriptor_setLabel :: #force_inline proc(self: ^SamplerDescriptor, label: ^NS.String) { +SamplerDescriptor_setLabel :: #force_inline proc "c" (self: ^SamplerDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=SamplerDescriptor, objc_name="setLodAverage") -SamplerDescriptor_setLodAverage :: #force_inline proc(self: ^SamplerDescriptor, lodAverage: BOOL) { +SamplerDescriptor_setLodAverage :: #force_inline proc "c" (self: ^SamplerDescriptor, lodAverage: BOOL) { msgSend(nil, self, "setLodAverage:", lodAverage) } @(objc_type=SamplerDescriptor, objc_name="setLodMaxClamp") -SamplerDescriptor_setLodMaxClamp :: #force_inline proc(self: ^SamplerDescriptor, lodMaxClamp: f32) { +SamplerDescriptor_setLodMaxClamp :: #force_inline proc "c" (self: ^SamplerDescriptor, lodMaxClamp: f32) { msgSend(nil, self, "setLodMaxClamp:", lodMaxClamp) } @(objc_type=SamplerDescriptor, objc_name="setLodMinClamp") -SamplerDescriptor_setLodMinClamp :: #force_inline proc(self: ^SamplerDescriptor, lodMinClamp: f32) { +SamplerDescriptor_setLodMinClamp :: #force_inline proc "c" (self: ^SamplerDescriptor, lodMinClamp: f32) { msgSend(nil, self, "setLodMinClamp:", lodMinClamp) } @(objc_type=SamplerDescriptor, objc_name="setMagFilter") -SamplerDescriptor_setMagFilter :: #force_inline proc(self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) { +SamplerDescriptor_setMagFilter :: #force_inline proc "c" (self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) { msgSend(nil, self, "setMagFilter:", magFilter) } @(objc_type=SamplerDescriptor, objc_name="setMaxAnisotropy") -SamplerDescriptor_setMaxAnisotropy :: #force_inline proc(self: ^SamplerDescriptor, maxAnisotropy: NS.UInteger) { +SamplerDescriptor_setMaxAnisotropy :: #force_inline proc "c" (self: ^SamplerDescriptor, maxAnisotropy: NS.UInteger) { msgSend(nil, self, "setMaxAnisotropy:", maxAnisotropy) } @(objc_type=SamplerDescriptor, objc_name="setMinFilter") -SamplerDescriptor_setMinFilter :: #force_inline proc(self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) { +SamplerDescriptor_setMinFilter :: #force_inline proc "c" (self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) { msgSend(nil, self, "setMinFilter:", minFilter) } @(objc_type=SamplerDescriptor, objc_name="setMipFilter") -SamplerDescriptor_setMipFilter :: #force_inline proc(self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) { +SamplerDescriptor_setMipFilter :: #force_inline proc "c" (self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) { msgSend(nil, self, "setMipFilter:", mipFilter) } @(objc_type=SamplerDescriptor, objc_name="setNormalizedCoordinates") -SamplerDescriptor_setNormalizedCoordinates :: #force_inline proc(self: ^SamplerDescriptor, normalizedCoordinates: BOOL) { +SamplerDescriptor_setNormalizedCoordinates :: #force_inline proc "c" (self: ^SamplerDescriptor, normalizedCoordinates: BOOL) { msgSend(nil, self, "setNormalizedCoordinates:", normalizedCoordinates) } @(objc_type=SamplerDescriptor, objc_name="setRAddressMode") -SamplerDescriptor_setRAddressMode :: #force_inline proc(self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) { +SamplerDescriptor_setRAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) { msgSend(nil, self, "setRAddressMode:", rAddressMode) } @(objc_type=SamplerDescriptor, objc_name="setSAddressMode") -SamplerDescriptor_setSAddressMode :: #force_inline proc(self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) { +SamplerDescriptor_setSAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) { msgSend(nil, self, "setSAddressMode:", sAddressMode) } @(objc_type=SamplerDescriptor, objc_name="setSupportArgumentBuffers") -SamplerDescriptor_setSupportArgumentBuffers :: #force_inline proc(self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) { +SamplerDescriptor_setSupportArgumentBuffers :: #force_inline proc "c" (self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) { msgSend(nil, self, "setSupportArgumentBuffers:", supportArgumentBuffers) } @(objc_type=SamplerDescriptor, objc_name="setTAddressMode") -SamplerDescriptor_setTAddressMode :: #force_inline proc(self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) { +SamplerDescriptor_setTAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) { msgSend(nil, self, "setTAddressMode:", tAddressMode) } @(objc_type=SamplerDescriptor, objc_name="supportArgumentBuffers") -SamplerDescriptor_supportArgumentBuffers :: #force_inline proc(self: ^SamplerDescriptor) -> BOOL { +SamplerDescriptor_supportArgumentBuffers :: #force_inline proc "c" (self: ^SamplerDescriptor) -> BOOL { return msgSend(BOOL, self, "supportArgumentBuffers") } @(objc_type=SamplerDescriptor, objc_name="tAddressMode") -SamplerDescriptor_tAddressMode :: #force_inline proc(self: ^SamplerDescriptor) -> SamplerAddressMode { +SamplerDescriptor_tAddressMode :: #force_inline proc "c" (self: ^SamplerDescriptor) -> SamplerAddressMode { return msgSend(SamplerAddressMode, self, "tAddressMode") } @@ -4248,15 +4248,15 @@ Methods: SharedEventHandle :: struct { using _: NS.Object } @(objc_type=SharedEventHandle, objc_name="alloc", objc_is_class_method=true) -SharedEventHandle_alloc :: #force_inline proc() -> ^SharedEventHandle { +SharedEventHandle_alloc :: #force_inline proc "c" () -> ^SharedEventHandle { return msgSend(^SharedEventHandle, SharedEventHandle, "alloc") } @(objc_type=SharedEventHandle, objc_name="init") -SharedEventHandle_init :: #force_inline proc(self: ^SharedEventHandle) -> ^SharedEventHandle { +SharedEventHandle_init :: #force_inline proc "c" (self: ^SharedEventHandle) -> ^SharedEventHandle { return msgSend(^SharedEventHandle, self, "init") } @(objc_type=SharedEventHandle, objc_name="label") -SharedEventHandle_label :: #force_inline proc(self: ^SharedEventHandle) -> ^NS.String { +SharedEventHandle_label :: #force_inline proc "c" (self: ^SharedEventHandle) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -4276,19 +4276,19 @@ Methods: SharedEventListener :: struct { using _: NS.Object } @(objc_type=SharedEventListener, objc_name="alloc", objc_is_class_method=true) -SharedEventListener_alloc :: #force_inline proc() -> ^SharedEventListener { +SharedEventListener_alloc :: #force_inline proc "c" () -> ^SharedEventListener { return msgSend(^SharedEventListener, SharedEventListener, "alloc") } @(objc_type=SharedEventListener, objc_name="dispatchQueue") -SharedEventListener_dispatchQueue :: #force_inline proc(self: ^SharedEventListener) -> dispatch_queue_t { +SharedEventListener_dispatchQueue :: #force_inline proc "c" (self: ^SharedEventListener) -> dispatch_queue_t { return msgSend(dispatch_queue_t, self, "dispatchQueue") } @(objc_type=SharedEventListener, objc_name="init") -SharedEventListener_init :: #force_inline proc(self: ^SharedEventListener) -> ^SharedEventListener { +SharedEventListener_init :: #force_inline proc "c" (self: ^SharedEventListener) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "init") } @(objc_type=SharedEventListener, objc_name="initWithDispatchQueue") -SharedEventListener_initWithDispatchQueue :: #force_inline proc(self: ^SharedEventListener, dispatchQueue: dispatch_queue_t) -> ^SharedEventListener { +SharedEventListener_initWithDispatchQueue :: #force_inline proc "c" (self: ^SharedEventListener, dispatchQueue: dispatch_queue_t) -> ^SharedEventListener { return msgSend(^SharedEventListener, self, "initWithDispatchQueue:", dispatchQueue) } @@ -4308,19 +4308,19 @@ Methods: SharedTextureHandle :: struct { using _: NS.Object } @(objc_type=SharedTextureHandle, objc_name="alloc", objc_is_class_method=true) -SharedTextureHandle_alloc :: #force_inline proc() -> ^SharedTextureHandle { +SharedTextureHandle_alloc :: #force_inline proc "c" () -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, SharedTextureHandle, "alloc") } @(objc_type=SharedTextureHandle, objc_name="init") -SharedTextureHandle_init :: #force_inline proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle { +SharedTextureHandle_init :: #force_inline proc "c" (self: ^SharedTextureHandle) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "init") } @(objc_type=SharedTextureHandle, objc_name="device") -SharedTextureHandle_device :: #force_inline proc(self: ^SharedTextureHandle) -> ^Device { +SharedTextureHandle_device :: #force_inline proc "c" (self: ^SharedTextureHandle) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=SharedTextureHandle, objc_name="label") -SharedTextureHandle_label :: #force_inline proc(self: ^SharedTextureHandle) -> ^NS.String { +SharedTextureHandle_label :: #force_inline proc "c" (self: ^SharedTextureHandle) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -4346,43 +4346,43 @@ Methods: StageInputOutputDescriptor :: struct { using _: NS.Copying(StageInputOutputDescriptor) } @(objc_type=StageInputOutputDescriptor, objc_name="alloc", objc_is_class_method=true) -StageInputOutputDescriptor_alloc :: #force_inline proc() -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_alloc :: #force_inline proc "c" () -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "alloc") } @(objc_type=StageInputOutputDescriptor, objc_name="init") -StageInputOutputDescriptor_init :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_init :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, self, "init") } @(objc_type=StageInputOutputDescriptor, objc_name="attributes") -StageInputOutputDescriptor_attributes :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray { +StageInputOutputDescriptor_attributes :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray { return msgSend(^AttributeDescriptorArray, self, "attributes") } @(objc_type=StageInputOutputDescriptor, objc_name="indexBufferIndex") -StageInputOutputDescriptor_indexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor) -> NS.UInteger { +StageInputOutputDescriptor_indexBufferIndex :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "indexBufferIndex") } @(objc_type=StageInputOutputDescriptor, objc_name="indexType") -StageInputOutputDescriptor_indexType :: #force_inline proc(self: ^StageInputOutputDescriptor) -> IndexType { +StageInputOutputDescriptor_indexType :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) -> IndexType { return msgSend(IndexType, self, "indexType") } @(objc_type=StageInputOutputDescriptor, objc_name="layouts") -StageInputOutputDescriptor_layouts :: #force_inline proc(self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray { +StageInputOutputDescriptor_layouts :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray { return msgSend(^BufferLayoutDescriptorArray, self, "layouts") } @(objc_type=StageInputOutputDescriptor, objc_name="reset") -StageInputOutputDescriptor_reset :: #force_inline proc(self: ^StageInputOutputDescriptor) { +StageInputOutputDescriptor_reset :: #force_inline proc "c" (self: ^StageInputOutputDescriptor) { msgSend(nil, self, "reset") } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexBufferIndex") -StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.UInteger) { +StageInputOutputDescriptor_setIndexBufferIndex :: #force_inline proc "c" (self: ^StageInputOutputDescriptor, indexBufferIndex: NS.UInteger) { msgSend(nil, self, "setIndexBufferIndex:", indexBufferIndex) } @(objc_type=StageInputOutputDescriptor, objc_name="setIndexType") -StageInputOutputDescriptor_setIndexType :: #force_inline proc(self: ^StageInputOutputDescriptor, indexType: IndexType) { +StageInputOutputDescriptor_setIndexType :: #force_inline proc "c" (self: ^StageInputOutputDescriptor, indexType: IndexType) { msgSend(nil, self, "setIndexType:", indexType) } @(objc_type=StageInputOutputDescriptor, objc_name="stageInputOutputDescriptor", objc_is_class_method=true) -StageInputOutputDescriptor_stageInputOutputDescriptor :: #force_inline proc() -> ^StageInputOutputDescriptor { +StageInputOutputDescriptor_stageInputOutputDescriptor :: #force_inline proc "c" () -> ^StageInputOutputDescriptor { return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "stageInputOutputDescriptor") } @@ -4412,59 +4412,59 @@ Methods: StencilDescriptor :: struct { using _: NS.Copying(StencilDescriptor) } @(objc_type=StencilDescriptor, objc_name="alloc", objc_is_class_method=true) -StencilDescriptor_alloc :: #force_inline proc() -> ^StencilDescriptor { +StencilDescriptor_alloc :: #force_inline proc "c" () -> ^StencilDescriptor { return msgSend(^StencilDescriptor, StencilDescriptor, "alloc") } @(objc_type=StencilDescriptor, objc_name="init") -StencilDescriptor_init :: #force_inline proc(self: ^StencilDescriptor) -> ^StencilDescriptor { +StencilDescriptor_init :: #force_inline proc "c" (self: ^StencilDescriptor) -> ^StencilDescriptor { return msgSend(^StencilDescriptor, self, "init") } @(objc_type=StencilDescriptor, objc_name="depthFailureOperation") -StencilDescriptor_depthFailureOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_depthFailureOperation :: #force_inline proc "c" (self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "depthFailureOperation") } @(objc_type=StencilDescriptor, objc_name="depthStencilPassOperation") -StencilDescriptor_depthStencilPassOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_depthStencilPassOperation :: #force_inline proc "c" (self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "depthStencilPassOperation") } @(objc_type=StencilDescriptor, objc_name="readMask") -StencilDescriptor_readMask :: #force_inline proc(self: ^StencilDescriptor) -> u32 { +StencilDescriptor_readMask :: #force_inline proc "c" (self: ^StencilDescriptor) -> u32 { return msgSend(u32, self, "readMask") } @(objc_type=StencilDescriptor, objc_name="setDepthFailureOperation") -StencilDescriptor_setDepthFailureOperation :: #force_inline proc(self: ^StencilDescriptor, depthFailureOperation: StencilOperation) { +StencilDescriptor_setDepthFailureOperation :: #force_inline proc "c" (self: ^StencilDescriptor, depthFailureOperation: StencilOperation) { msgSend(nil, self, "setDepthFailureOperation:", depthFailureOperation) } @(objc_type=StencilDescriptor, objc_name="setDepthStencilPassOperation") -StencilDescriptor_setDepthStencilPassOperation :: #force_inline proc(self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) { +StencilDescriptor_setDepthStencilPassOperation :: #force_inline proc "c" (self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) { msgSend(nil, self, "setDepthStencilPassOperation:", depthStencilPassOperation) } @(objc_type=StencilDescriptor, objc_name="setReadMask") -StencilDescriptor_setReadMask :: #force_inline proc(self: ^StencilDescriptor, readMask: u32) { +StencilDescriptor_setReadMask :: #force_inline proc "c" (self: ^StencilDescriptor, readMask: u32) { msgSend(nil, self, "setReadMask:", readMask) } @(objc_type=StencilDescriptor, objc_name="setStencilCompareFunction") -StencilDescriptor_setStencilCompareFunction :: #force_inline proc(self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) { +StencilDescriptor_setStencilCompareFunction :: #force_inline proc "c" (self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) { msgSend(nil, self, "setStencilCompareFunction:", stencilCompareFunction) } @(objc_type=StencilDescriptor, objc_name="setStencilFailureOperation") -StencilDescriptor_setStencilFailureOperation :: #force_inline proc(self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) { +StencilDescriptor_setStencilFailureOperation :: #force_inline proc "c" (self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) { msgSend(nil, self, "setStencilFailureOperation:", stencilFailureOperation) } @(objc_type=StencilDescriptor, objc_name="setWriteMask") -StencilDescriptor_setWriteMask :: #force_inline proc(self: ^StencilDescriptor, writeMask: u32) { +StencilDescriptor_setWriteMask :: #force_inline proc "c" (self: ^StencilDescriptor, writeMask: u32) { msgSend(nil, self, "setWriteMask:", writeMask) } @(objc_type=StencilDescriptor, objc_name="stencilCompareFunction") -StencilDescriptor_stencilCompareFunction :: #force_inline proc(self: ^StencilDescriptor) -> CompareFunction { +StencilDescriptor_stencilCompareFunction :: #force_inline proc "c" (self: ^StencilDescriptor) -> CompareFunction { return msgSend(CompareFunction, self, "stencilCompareFunction") } @(objc_type=StencilDescriptor, objc_name="stencilFailureOperation") -StencilDescriptor_stencilFailureOperation :: #force_inline proc(self: ^StencilDescriptor) -> StencilOperation { +StencilDescriptor_stencilFailureOperation :: #force_inline proc "c" (self: ^StencilDescriptor) -> StencilOperation { return msgSend(StencilOperation, self, "stencilFailureOperation") } @(objc_type=StencilDescriptor, objc_name="writeMask") -StencilDescriptor_writeMask :: #force_inline proc(self: ^StencilDescriptor) -> u32 { +StencilDescriptor_writeMask :: #force_inline proc "c" (self: ^StencilDescriptor) -> u32 { return msgSend(u32, self, "writeMask") } @@ -4490,43 +4490,43 @@ Methods: StructMember :: struct { using _: NS.Object } @(objc_type=StructMember, objc_name="alloc", objc_is_class_method=true) -StructMember_alloc :: #force_inline proc() -> ^StructMember { +StructMember_alloc :: #force_inline proc "c" () -> ^StructMember { return msgSend(^StructMember, StructMember, "alloc") } @(objc_type=StructMember, objc_name="init") -StructMember_init :: #force_inline proc(self: ^StructMember) -> ^StructMember { +StructMember_init :: #force_inline proc "c" (self: ^StructMember) -> ^StructMember { return msgSend(^StructMember, self, "init") } @(objc_type=StructMember, objc_name="argumentIndex") -StructMember_argumentIndex :: #force_inline proc(self: ^StructMember) -> NS.UInteger { +StructMember_argumentIndex :: #force_inline proc "c" (self: ^StructMember) -> NS.UInteger { return msgSend(NS.UInteger, self, "argumentIndex") } @(objc_type=StructMember, objc_name="arrayType") -StructMember_arrayType :: #force_inline proc(self: ^StructMember) -> ^ArrayType { +StructMember_arrayType :: #force_inline proc "c" (self: ^StructMember) -> ^ArrayType { return msgSend(^ArrayType, self, "arrayType") } @(objc_type=StructMember, objc_name="dataType") -StructMember_dataType :: #force_inline proc(self: ^StructMember) -> DataType { +StructMember_dataType :: #force_inline proc "c" (self: ^StructMember) -> DataType { return msgSend(DataType, self, "dataType") } @(objc_type=StructMember, objc_name="name") -StructMember_name :: #force_inline proc(self: ^StructMember) -> ^NS.String { +StructMember_name :: #force_inline proc "c" (self: ^StructMember) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=StructMember, objc_name="offset") -StructMember_offset :: #force_inline proc(self: ^StructMember) -> NS.UInteger { +StructMember_offset :: #force_inline proc "c" (self: ^StructMember) -> NS.UInteger { return msgSend(NS.UInteger, self, "offset") } @(objc_type=StructMember, objc_name="pointerType") -StructMember_pointerType :: #force_inline proc(self: ^StructMember) -> ^PointerType { +StructMember_pointerType :: #force_inline proc "c" (self: ^StructMember) -> ^PointerType { return msgSend(^PointerType, self, "pointerType") } @(objc_type=StructMember, objc_name="structType") -StructMember_structType :: #force_inline proc(self: ^StructMember) -> ^StructType { +StructMember_structType :: #force_inline proc "c" (self: ^StructMember) -> ^StructType { return msgSend(^StructType, self, "structType") } @(objc_type=StructMember, objc_name="textureReferenceType") -StructMember_textureReferenceType :: #force_inline proc(self: ^StructMember) -> ^TextureReferenceType { +StructMember_textureReferenceType :: #force_inline proc "c" (self: ^StructMember) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "textureReferenceType") } @@ -4546,19 +4546,19 @@ Methods: StructType :: struct { using _: Type } @(objc_type=StructType, objc_name="alloc", objc_is_class_method=true) -StructType_alloc :: #force_inline proc() -> ^StructType { +StructType_alloc :: #force_inline proc "c" () -> ^StructType { return msgSend(^StructType, StructType, "alloc") } @(objc_type=StructType, objc_name="init") -StructType_init :: #force_inline proc(self: ^StructType) -> ^StructType { +StructType_init :: #force_inline proc "c" (self: ^StructType) -> ^StructType { return msgSend(^StructType, self, "init") } @(objc_type=StructType, objc_name="memberByName") -StructType_memberByName :: #force_inline proc(self: ^StructType, name: ^NS.String) -> ^StructMember { +StructType_memberByName :: #force_inline proc "c" (self: ^StructType, name: ^NS.String) -> ^StructMember { return msgSend(^StructMember, self, "memberByName:", name) } @(objc_type=StructType, objc_name="members") -StructType_members :: #force_inline proc(self: ^StructType) -> ^NS.Array { +StructType_members :: #force_inline proc "c" (self: ^StructType) -> ^NS.Array { return msgSend(^NS.Array, self, "members") } @@ -4609,152 +4609,152 @@ Methods: TextureDescriptor :: struct { using _: NS.Copying(TextureDescriptor) } @(objc_type=TextureDescriptor, objc_name="alloc", objc_is_class_method=true) -TextureDescriptor_alloc :: #force_inline proc() -> ^TextureDescriptor { +TextureDescriptor_alloc :: #force_inline proc "c" () -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "alloc") } @(objc_type=TextureDescriptor, objc_name="init") -TextureDescriptor_init :: #force_inline proc(self: ^TextureDescriptor) -> ^TextureDescriptor { +TextureDescriptor_init :: #force_inline proc "c" (self: ^TextureDescriptor) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, self, "init") } @(objc_type=TextureDescriptor, objc_name="allowGPUOptimizedContents") -TextureDescriptor_allowGPUOptimizedContents :: #force_inline proc(self: ^TextureDescriptor) -> BOOL { +TextureDescriptor_allowGPUOptimizedContents :: #force_inline proc "c" (self: ^TextureDescriptor) -> BOOL { return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=TextureDescriptor, objc_name="arrayLength") -TextureDescriptor_arrayLength :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_arrayLength :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=TextureDescriptor, objc_name="cpuCacheMode") -TextureDescriptor_cpuCacheMode :: #force_inline proc(self: ^TextureDescriptor) -> CPUCacheMode { +TextureDescriptor_cpuCacheMode :: #force_inline proc "c" (self: ^TextureDescriptor) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=TextureDescriptor, objc_name="depth") -TextureDescriptor_depth :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_depth :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "depth") } @(objc_type=TextureDescriptor, objc_name="hazardTrackingMode") -TextureDescriptor_hazardTrackingMode :: #force_inline proc(self: ^TextureDescriptor) -> HazardTrackingMode { +TextureDescriptor_hazardTrackingMode :: #force_inline proc "c" (self: ^TextureDescriptor) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=TextureDescriptor, objc_name="height") -TextureDescriptor_height :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_height :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "height") } @(objc_type=TextureDescriptor, objc_name="mipmapLevelCount") -TextureDescriptor_mipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_mipmapLevelCount :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "mipmapLevelCount") } @(objc_type=TextureDescriptor, objc_name="pixelFormat") -TextureDescriptor_pixelFormat :: #force_inline proc(self: ^TextureDescriptor) -> PixelFormat { +TextureDescriptor_pixelFormat :: #force_inline proc "c" (self: ^TextureDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=TextureDescriptor, objc_name="resourceOptions") -TextureDescriptor_resourceOptions :: #force_inline proc(self: ^TextureDescriptor) -> ResourceOptions { +TextureDescriptor_resourceOptions :: #force_inline proc "c" (self: ^TextureDescriptor) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=TextureDescriptor, objc_name="sampleCount") -TextureDescriptor_sampleCount :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_sampleCount :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=TextureDescriptor, objc_name="setAllowGPUOptimizedContents") -TextureDescriptor_setAllowGPUOptimizedContents :: #force_inline proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { +TextureDescriptor_setAllowGPUOptimizedContents :: #force_inline proc "c" (self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) { msgSend(nil, self, "setAllowGPUOptimizedContents:", allowGPUOptimizedContents) } @(objc_type=TextureDescriptor, objc_name="setArrayLength") -TextureDescriptor_setArrayLength :: #force_inline proc(self: ^TextureDescriptor, arrayLength: NS.UInteger) { +TextureDescriptor_setArrayLength :: #force_inline proc "c" (self: ^TextureDescriptor, arrayLength: NS.UInteger) { msgSend(nil, self, "setArrayLength:", arrayLength) } @(objc_type=TextureDescriptor, objc_name="setCpuCacheMode") -TextureDescriptor_setCpuCacheMode :: #force_inline proc(self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) { +TextureDescriptor_setCpuCacheMode :: #force_inline proc "c" (self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) { msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode) } @(objc_type=TextureDescriptor, objc_name="setDepth") -TextureDescriptor_setDepth :: #force_inline proc(self: ^TextureDescriptor, depth: NS.UInteger) { +TextureDescriptor_setDepth :: #force_inline proc "c" (self: ^TextureDescriptor, depth: NS.UInteger) { msgSend(nil, self, "setDepth:", depth) } @(objc_type=TextureDescriptor, objc_name="setHazardTrackingMode") -TextureDescriptor_setHazardTrackingMode :: #force_inline proc(self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) { +TextureDescriptor_setHazardTrackingMode :: #force_inline proc "c" (self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) { msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode) } @(objc_type=TextureDescriptor, objc_name="setHeight") -TextureDescriptor_setHeight :: #force_inline proc(self: ^TextureDescriptor, height: NS.UInteger) { +TextureDescriptor_setHeight :: #force_inline proc "c" (self: ^TextureDescriptor, height: NS.UInteger) { msgSend(nil, self, "setHeight:", height) } @(objc_type=TextureDescriptor, objc_name="setMipmapLevelCount") -TextureDescriptor_setMipmapLevelCount :: #force_inline proc(self: ^TextureDescriptor, mipmapLevelCount: NS.UInteger) { +TextureDescriptor_setMipmapLevelCount :: #force_inline proc "c" (self: ^TextureDescriptor, mipmapLevelCount: NS.UInteger) { msgSend(nil, self, "setMipmapLevelCount:", mipmapLevelCount) } @(objc_type=TextureDescriptor, objc_name="setPixelFormat") -TextureDescriptor_setPixelFormat :: #force_inline proc(self: ^TextureDescriptor, pixelFormat: PixelFormat) { +TextureDescriptor_setPixelFormat :: #force_inline proc "c" (self: ^TextureDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @(objc_type=TextureDescriptor, objc_name="setResourceOptions") -TextureDescriptor_setResourceOptions :: #force_inline proc(self: ^TextureDescriptor, resourceOptions: ResourceOptions) { +TextureDescriptor_setResourceOptions :: #force_inline proc "c" (self: ^TextureDescriptor, resourceOptions: ResourceOptions) { msgSend(nil, self, "setResourceOptions:", resourceOptions) } @(objc_type=TextureDescriptor, objc_name="setSampleCount") -TextureDescriptor_setSampleCount :: #force_inline proc(self: ^TextureDescriptor, sampleCount: NS.UInteger) { +TextureDescriptor_setSampleCount :: #force_inline proc "c" (self: ^TextureDescriptor, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=TextureDescriptor, objc_name="setStorageMode") -TextureDescriptor_setStorageMode :: #force_inline proc(self: ^TextureDescriptor, storageMode: StorageMode) { +TextureDescriptor_setStorageMode :: #force_inline proc "c" (self: ^TextureDescriptor, storageMode: StorageMode) { msgSend(nil, self, "setStorageMode:", storageMode) } @(objc_type=TextureDescriptor, objc_name="setSwizzle") -TextureDescriptor_setSwizzle :: #force_inline proc(self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) { +TextureDescriptor_setSwizzle :: #force_inline proc "c" (self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) { msgSend(nil, self, "setSwizzle:", swizzle) } @(objc_type=TextureDescriptor, objc_name="setTextureType") -TextureDescriptor_setTextureType :: #force_inline proc(self: ^TextureDescriptor, textureType: TextureType) { +TextureDescriptor_setTextureType :: #force_inline proc "c" (self: ^TextureDescriptor, textureType: TextureType) { msgSend(nil, self, "setTextureType:", textureType) } @(objc_type=TextureDescriptor, objc_name="setUsage") -TextureDescriptor_setUsage :: #force_inline proc(self: ^TextureDescriptor, usage: TextureUsage) { +TextureDescriptor_setUsage :: #force_inline proc "c" (self: ^TextureDescriptor, usage: TextureUsage) { msgSend(nil, self, "setUsage:", usage) } @(objc_type=TextureDescriptor, objc_name="setWidth") -TextureDescriptor_setWidth :: #force_inline proc(self: ^TextureDescriptor, width: NS.UInteger) { +TextureDescriptor_setWidth :: #force_inline proc "c" (self: ^TextureDescriptor, width: NS.UInteger) { msgSend(nil, self, "setWidth:", width) } @(objc_type=TextureDescriptor, objc_name="storageMode") -TextureDescriptor_storageMode :: #force_inline proc(self: ^TextureDescriptor) -> StorageMode { +TextureDescriptor_storageMode :: #force_inline proc "c" (self: ^TextureDescriptor) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=TextureDescriptor, objc_name="swizzle") -TextureDescriptor_swizzle :: #force_inline proc(self: ^TextureDescriptor) -> TextureSwizzleChannels { +TextureDescriptor_swizzle :: #force_inline proc "c" (self: ^TextureDescriptor) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=TextureDescriptor, objc_name="texture2DDescriptorWithPixelFormat", objc_is_class_method=true) -TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, height: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { +TextureDescriptor_texture2DDescriptorWithPixelFormat :: #force_inline proc "c" (pixelFormat: PixelFormat, width: NS.UInteger, height: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped) } @(objc_type=TextureDescriptor, objc_name="textureBufferDescriptorWithPixelFormat", objc_is_class_method=true) -TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, width: NS.UInteger, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { +TextureDescriptor_textureBufferDescriptorWithPixelFormat :: #force_inline proc "c" (pixelFormat: PixelFormat, width: NS.UInteger, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage) } @(objc_type=TextureDescriptor, objc_name="textureCubeDescriptorWithPixelFormat", objc_is_class_method=true) -TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc(pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { +TextureDescriptor_textureCubeDescriptorWithPixelFormat :: #force_inline proc "c" (pixelFormat: PixelFormat, size: NS.UInteger, mipmapped: BOOL) -> ^TextureDescriptor { return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped) } @(objc_type=TextureDescriptor, objc_name="textureType") -TextureDescriptor_textureType :: #force_inline proc(self: ^TextureDescriptor) -> TextureType { +TextureDescriptor_textureType :: #force_inline proc "c" (self: ^TextureDescriptor) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=TextureDescriptor, objc_name="usage") -TextureDescriptor_usage :: #force_inline proc(self: ^TextureDescriptor) -> TextureUsage { +TextureDescriptor_usage :: #force_inline proc "c" (self: ^TextureDescriptor) -> TextureUsage { return msgSend(TextureUsage, self, "usage") } @(objc_type=TextureDescriptor, objc_name="width") -TextureDescriptor_width :: #force_inline proc(self: ^TextureDescriptor) -> NS.UInteger { +TextureDescriptor_width :: #force_inline proc "c" (self: ^TextureDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "width") } @(objc_type=TextureDescriptor, objc_name="compressionType") -TextureDescriptor_compressionType :: #force_inline proc(self: ^TextureDescriptor) -> TextureCompressionType { +TextureDescriptor_compressionType :: #force_inline proc "c" (self: ^TextureDescriptor) -> TextureCompressionType { return msgSend(TextureCompressionType, self, "compressionType") } @(objc_type=TextureDescriptor, objc_name="setCompressionType") -TextureDescriptor_setCompressionType :: #force_inline proc(self: ^TextureDescriptor, compressionType: TextureCompressionType) { +TextureDescriptor_setCompressionType :: #force_inline proc "c" (self: ^TextureDescriptor, compressionType: TextureCompressionType) { msgSend(nil, self, "setCompressionType:", compressionType) } @@ -4776,27 +4776,27 @@ Methods: TextureReferenceType :: struct { using _: Type } @(objc_type=TextureReferenceType, objc_name="alloc", objc_is_class_method=true) -TextureReferenceType_alloc :: #force_inline proc() -> ^TextureReferenceType { +TextureReferenceType_alloc :: #force_inline proc "c" () -> ^TextureReferenceType { return msgSend(^TextureReferenceType, TextureReferenceType, "alloc") } @(objc_type=TextureReferenceType, objc_name="init") -TextureReferenceType_init :: #force_inline proc(self: ^TextureReferenceType) -> ^TextureReferenceType { +TextureReferenceType_init :: #force_inline proc "c" (self: ^TextureReferenceType) -> ^TextureReferenceType { return msgSend(^TextureReferenceType, self, "init") } @(objc_type=TextureReferenceType, objc_name="access") -TextureReferenceType_access :: #force_inline proc(self: ^TextureReferenceType) -> ArgumentAccess { +TextureReferenceType_access :: #force_inline proc "c" (self: ^TextureReferenceType) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=TextureReferenceType, objc_name="isDepthTexture") -TextureReferenceType_isDepthTexture :: #force_inline proc(self: ^TextureReferenceType) -> BOOL { +TextureReferenceType_isDepthTexture :: #force_inline proc "c" (self: ^TextureReferenceType) -> BOOL { return msgSend(BOOL, self, "isDepthTexture") } @(objc_type=TextureReferenceType, objc_name="textureDataType") -TextureReferenceType_textureDataType :: #force_inline proc(self: ^TextureReferenceType) -> DataType { +TextureReferenceType_textureDataType :: #force_inline proc "c" (self: ^TextureReferenceType) -> DataType { return msgSend(DataType, self, "textureDataType") } @(objc_type=TextureReferenceType, objc_name="textureType") -TextureReferenceType_textureType :: #force_inline proc(self: ^TextureReferenceType) -> TextureType { +TextureReferenceType_textureType :: #force_inline proc "c" (self: ^TextureReferenceType) -> TextureType { return msgSend(TextureType, self, "textureType") } @@ -4816,19 +4816,19 @@ Methods: TileRenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(TileRenderPipelineColorAttachmentDescriptor) } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -TileRenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, TileRenderPipelineColorAttachmentDescriptor, "alloc") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="init") -TileRenderPipelineColorAttachmentDescriptor_init :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptor_init :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "init") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat") -TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat { +TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat") -TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { +TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @@ -4848,19 +4848,19 @@ Methods: TileRenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -TileRenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineColorAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, TileRenderPipelineColorAttachmentDescriptorArray, "alloc") } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="init") -TileRenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineColorAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init") } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="object") -TileRenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^TileRenderPipelineColorAttachmentDescriptor { +TileRenderPipelineColorAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^TileRenderPipelineColorAttachmentDescriptor { return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject") -TileRenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { +TileRenderPipelineColorAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -4893,71 +4893,71 @@ Methods: TileRenderPipelineDescriptor :: struct { using _: NS.Copying(TileRenderPipelineDescriptor) } @(objc_type=TileRenderPipelineDescriptor, objc_name="alloc", objc_is_class_method=true) -TileRenderPipelineDescriptor_alloc :: #force_inline proc() -> ^TileRenderPipelineDescriptor { +TileRenderPipelineDescriptor_alloc :: #force_inline proc "c" () -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, TileRenderPipelineDescriptor, "alloc") } @(objc_type=TileRenderPipelineDescriptor, objc_name="init") -TileRenderPipelineDescriptor_init :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { +TileRenderPipelineDescriptor_init :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor { return msgSend(^TileRenderPipelineDescriptor, self, "init") } @(objc_type=TileRenderPipelineDescriptor, objc_name="binaryArchives") -TileRenderPipelineDescriptor_binaryArchives :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^NS.Array { +TileRenderPipelineDescriptor_binaryArchives :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "binaryArchives") } @(objc_type=TileRenderPipelineDescriptor, objc_name="colorAttachments") -TileRenderPipelineDescriptor_colorAttachments :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray { +TileRenderPipelineDescriptor_colorAttachments :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray { return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments") } @(objc_type=TileRenderPipelineDescriptor, objc_name="label") -TileRenderPipelineDescriptor_label :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^NS.String { +TileRenderPipelineDescriptor_label :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=TileRenderPipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.UInteger { +TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=TileRenderPipelineDescriptor, objc_name="rasterSampleCount") -TileRenderPipelineDescriptor_rasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> NS.UInteger { +TileRenderPipelineDescriptor_rasterSampleCount :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "rasterSampleCount") } @(objc_type=TileRenderPipelineDescriptor, objc_name="reset") -TileRenderPipelineDescriptor_reset :: #force_inline proc(self: ^TileRenderPipelineDescriptor) { +TileRenderPipelineDescriptor_reset :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) { msgSend(nil, self, "reset") } @(objc_type=TileRenderPipelineDescriptor, objc_name="setBinaryArchives") -TileRenderPipelineDescriptor_setBinaryArchives :: #force_inline proc(self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) { +TileRenderPipelineDescriptor_setBinaryArchives :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) { msgSend(nil, self, "setBinaryArchives:", binaryArchives) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setLabel") -TileRenderPipelineDescriptor_setLabel :: #force_inline proc(self: ^TileRenderPipelineDescriptor, label: ^NS.String) { +TileRenderPipelineDescriptor_setLabel :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup") -TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { +TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.UInteger) { msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setRasterSampleCount") -TileRenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { +TileRenderPipelineDescriptor_setRasterSampleCount :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.UInteger) { msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setThreadgroupSizeMatchesTileSize") -TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: #force_inline proc(self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) { +TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) { msgSend(nil, self, "setThreadgroupSizeMatchesTileSize:", threadgroupSizeMatchesTileSize) } @(objc_type=TileRenderPipelineDescriptor, objc_name="setTileFunction") -TileRenderPipelineDescriptor_setTileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^Function) { +TileRenderPipelineDescriptor_setTileFunction :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor, tileFunction: ^Function) { msgSend(nil, self, "setTileFunction:", tileFunction) } @(objc_type=TileRenderPipelineDescriptor, objc_name="threadgroupSizeMatchesTileSize") -TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> BOOL { +TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> BOOL { return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") } @(objc_type=TileRenderPipelineDescriptor, objc_name="tileBuffers") -TileRenderPipelineDescriptor_tileBuffers :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { +TileRenderPipelineDescriptor_tileBuffers :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray { return msgSend(^PipelineBufferDescriptorArray, self, "tileBuffers") } @(objc_type=TileRenderPipelineDescriptor, objc_name="tileFunction") -TileRenderPipelineDescriptor_tileFunction :: #force_inline proc(self: ^TileRenderPipelineDescriptor) -> ^Function { +TileRenderPipelineDescriptor_tileFunction :: #force_inline proc "c" (self: ^TileRenderPipelineDescriptor) -> ^Function { return msgSend(^Function, self, "tileFunction") } @@ -4976,15 +4976,15 @@ Methods: Type :: struct { using _: NS.Object } @(objc_type=Type, objc_name="alloc", objc_is_class_method=true) -Type_alloc :: #force_inline proc() -> ^Type { +Type_alloc :: #force_inline proc "c" () -> ^Type { return msgSend(^Type, Type, "alloc") } @(objc_type=Type, objc_name="init") -Type_init :: #force_inline proc(self: ^Type) -> ^Type { +Type_init :: #force_inline proc "c" (self: ^Type) -> ^Type { return msgSend(^Type, self, "init") } @(objc_type=Type, objc_name="dataType") -Type_dataType :: #force_inline proc(self: ^Type) -> DataType { +Type_dataType :: #force_inline proc "c" (self: ^Type) -> DataType { return msgSend(DataType, self, "dataType") } @@ -5008,35 +5008,35 @@ Methods: VertexAttribute :: struct { using _: NS.Object } @(objc_type=VertexAttribute, objc_name="alloc", objc_is_class_method=true) -VertexAttribute_alloc :: #force_inline proc() -> ^VertexAttribute { +VertexAttribute_alloc :: #force_inline proc "c" () -> ^VertexAttribute { return msgSend(^VertexAttribute, VertexAttribute, "alloc") } @(objc_type=VertexAttribute, objc_name="init") -VertexAttribute_init :: #force_inline proc(self: ^VertexAttribute) -> ^VertexAttribute { +VertexAttribute_init :: #force_inline proc "c" (self: ^VertexAttribute) -> ^VertexAttribute { return msgSend(^VertexAttribute, self, "init") } @(objc_type=VertexAttribute, objc_name="attributeIndex") -VertexAttribute_attributeIndex :: #force_inline proc(self: ^VertexAttribute) -> NS.UInteger { +VertexAttribute_attributeIndex :: #force_inline proc "c" (self: ^VertexAttribute) -> NS.UInteger { return msgSend(NS.UInteger, self, "attributeIndex") } @(objc_type=VertexAttribute, objc_name="attributeType") -VertexAttribute_attributeType :: #force_inline proc(self: ^VertexAttribute) -> DataType { +VertexAttribute_attributeType :: #force_inline proc "c" (self: ^VertexAttribute) -> DataType { return msgSend(DataType, self, "attributeType") } @(objc_type=VertexAttribute, objc_name="isActive") -VertexAttribute_isActive :: #force_inline proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isActive :: #force_inline proc "c" (self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isActive") } @(objc_type=VertexAttribute, objc_name="isPatchControlPointData") -VertexAttribute_isPatchControlPointData :: #force_inline proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isPatchControlPointData :: #force_inline proc "c" (self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isPatchControlPointData") } @(objc_type=VertexAttribute, objc_name="isPatchData") -VertexAttribute_isPatchData :: #force_inline proc(self: ^VertexAttribute) -> BOOL { +VertexAttribute_isPatchData :: #force_inline proc "c" (self: ^VertexAttribute) -> BOOL { return msgSend(BOOL, self, "isPatchData") } @(objc_type=VertexAttribute, objc_name="name") -VertexAttribute_name :: #force_inline proc(self: ^VertexAttribute) -> ^NS.String { +VertexAttribute_name :: #force_inline proc "c" (self: ^VertexAttribute) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -5060,35 +5060,35 @@ Methods: VertexAttributeDescriptor :: struct { using _: NS.Copying(VertexAttributeDescriptor) } @(objc_type=VertexAttributeDescriptor, objc_name="alloc", objc_is_class_method=true) -VertexAttributeDescriptor_alloc :: #force_inline proc() -> ^VertexAttributeDescriptor { +VertexAttributeDescriptor_alloc :: #force_inline proc "c" () -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, VertexAttributeDescriptor, "alloc") } @(objc_type=VertexAttributeDescriptor, objc_name="init") -VertexAttributeDescriptor_init :: #force_inline proc(self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor { +VertexAttributeDescriptor_init :: #force_inline proc "c" (self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "init") } @(objc_type=VertexAttributeDescriptor, objc_name="bufferIndex") -VertexAttributeDescriptor_bufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.UInteger { +VertexAttributeDescriptor_bufferIndex :: #force_inline proc "c" (self: ^VertexAttributeDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferIndex") } @(objc_type=VertexAttributeDescriptor, objc_name="format") -VertexAttributeDescriptor_format :: #force_inline proc(self: ^VertexAttributeDescriptor) -> VertexFormat { +VertexAttributeDescriptor_format :: #force_inline proc "c" (self: ^VertexAttributeDescriptor) -> VertexFormat { return msgSend(VertexFormat, self, "format") } @(objc_type=VertexAttributeDescriptor, objc_name="offset") -VertexAttributeDescriptor_offset :: #force_inline proc(self: ^VertexAttributeDescriptor) -> NS.UInteger { +VertexAttributeDescriptor_offset :: #force_inline proc "c" (self: ^VertexAttributeDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "offset") } @(objc_type=VertexAttributeDescriptor, objc_name="setBufferIndex") -VertexAttributeDescriptor_setBufferIndex :: #force_inline proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.UInteger) { +VertexAttributeDescriptor_setBufferIndex :: #force_inline proc "c" (self: ^VertexAttributeDescriptor, bufferIndex: NS.UInteger) { msgSend(nil, self, "setBufferIndex:", bufferIndex) } @(objc_type=VertexAttributeDescriptor, objc_name="setFormat") -VertexAttributeDescriptor_setFormat :: #force_inline proc(self: ^VertexAttributeDescriptor, format: VertexFormat) { +VertexAttributeDescriptor_setFormat :: #force_inline proc "c" (self: ^VertexAttributeDescriptor, format: VertexFormat) { msgSend(nil, self, "setFormat:", format) } @(objc_type=VertexAttributeDescriptor, objc_name="setOffset") -VertexAttributeDescriptor_setOffset :: #force_inline proc(self: ^VertexAttributeDescriptor, offset: NS.UInteger) { +VertexAttributeDescriptor_setOffset :: #force_inline proc "c" (self: ^VertexAttributeDescriptor, offset: NS.UInteger) { msgSend(nil, self, "setOffset:", offset) } @@ -5108,19 +5108,19 @@ Methods: VertexAttributeDescriptorArray :: struct { using _: NS.Object } @(objc_type=VertexAttributeDescriptorArray, objc_name="alloc", objc_is_class_method=true) -VertexAttributeDescriptorArray_alloc :: #force_inline proc() -> ^VertexAttributeDescriptorArray { +VertexAttributeDescriptorArray_alloc :: #force_inline proc "c" () -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, VertexAttributeDescriptorArray, "alloc") } @(objc_type=VertexAttributeDescriptorArray, objc_name="init") -VertexAttributeDescriptorArray_init :: #force_inline proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { +VertexAttributeDescriptorArray_init :: #force_inline proc "c" (self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, self, "init") } @(objc_type=VertexAttributeDescriptorArray, objc_name="object") -VertexAttributeDescriptorArray_object :: #force_inline proc(self: ^VertexAttributeDescriptorArray, index: NS.UInteger) -> ^VertexAttributeDescriptor { +VertexAttributeDescriptorArray_object :: #force_inline proc "c" (self: ^VertexAttributeDescriptorArray, index: NS.UInteger) -> ^VertexAttributeDescriptor { return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexAttributeDescriptorArray, objc_name="setObject") -VertexAttributeDescriptorArray_setObject :: #force_inline proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: NS.UInteger) { +VertexAttributeDescriptorArray_setObject :: #force_inline proc "c" (self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index) } @@ -5144,35 +5144,35 @@ Methods: VertexBufferLayoutDescriptor :: struct { using _: NS.Copying(VertexBufferLayoutDescriptor) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="alloc", objc_is_class_method=true) -VertexBufferLayoutDescriptor_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptor_alloc :: #force_inline proc "c" () -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, VertexBufferLayoutDescriptor, "alloc") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="init") -VertexBufferLayoutDescriptor_init :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptor_init :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "init") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepFunction") -VertexBufferLayoutDescriptor_setStepFunction :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) { +VertexBufferLayoutDescriptor_setStepFunction :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) { msgSend(nil, self, "setStepFunction:", stepFunction) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepRate") -VertexBufferLayoutDescriptor_setStepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.UInteger) { +VertexBufferLayoutDescriptor_setStepRate :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor, stepRate: NS.UInteger) { msgSend(nil, self, "setStepRate:", stepRate) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="setStride") -VertexBufferLayoutDescriptor_setStride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor, stride: NS.UInteger) { +VertexBufferLayoutDescriptor_setStride :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor, stride: NS.UInteger) { msgSend(nil, self, "setStride:", stride) } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepFunction") -VertexBufferLayoutDescriptor_stepFunction :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction { +VertexBufferLayoutDescriptor_stepFunction :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction { return msgSend(VertexStepFunction, self, "stepFunction") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stepRate") -VertexBufferLayoutDescriptor_stepRate :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { +VertexBufferLayoutDescriptor_stepRate :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "stepRate") } @(objc_type=VertexBufferLayoutDescriptor, objc_name="stride") -VertexBufferLayoutDescriptor_stride :: #force_inline proc(self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { +VertexBufferLayoutDescriptor_stride :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "stride") } @@ -5192,19 +5192,19 @@ Methods: VertexBufferLayoutDescriptorArray :: struct { using _: NS.Object } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="alloc", objc_is_class_method=true) -VertexBufferLayoutDescriptorArray_alloc :: #force_inline proc() -> ^VertexBufferLayoutDescriptorArray { +VertexBufferLayoutDescriptorArray_alloc :: #force_inline proc "c" () -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, VertexBufferLayoutDescriptorArray, "alloc") } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="init") -VertexBufferLayoutDescriptorArray_init :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { +VertexBufferLayoutDescriptorArray_init :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, self, "init") } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="object") -VertexBufferLayoutDescriptorArray_object :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, index: NS.UInteger) -> ^VertexBufferLayoutDescriptor { +VertexBufferLayoutDescriptorArray_object :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptorArray, index: NS.UInteger) -> ^VertexBufferLayoutDescriptor { return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index) } @(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject") -VertexBufferLayoutDescriptorArray_setObject :: #force_inline proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: NS.UInteger) { +VertexBufferLayoutDescriptorArray_setObject :: #force_inline proc "c" (self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index) } @@ -5226,27 +5226,27 @@ Methods: VertexDescriptor :: struct { using _: NS.Copying(VertexDescriptor) } @(objc_type=VertexDescriptor, objc_name="alloc", objc_is_class_method=true) -VertexDescriptor_alloc :: #force_inline proc() -> ^VertexDescriptor { +VertexDescriptor_alloc :: #force_inline proc "c" () -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "alloc") } @(objc_type=VertexDescriptor, objc_name="init") -VertexDescriptor_init :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexDescriptor { +VertexDescriptor_init :: #force_inline proc "c" (self: ^VertexDescriptor) -> ^VertexDescriptor { return msgSend(^VertexDescriptor, self, "init") } @(objc_type=VertexDescriptor, objc_name="attributes") -VertexDescriptor_attributes :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray { +VertexDescriptor_attributes :: #force_inline proc "c" (self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray { return msgSend(^VertexAttributeDescriptorArray, self, "attributes") } @(objc_type=VertexDescriptor, objc_name="layouts") -VertexDescriptor_layouts :: #force_inline proc(self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray { +VertexDescriptor_layouts :: #force_inline proc "c" (self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray { return msgSend(^VertexBufferLayoutDescriptorArray, self, "layouts") } @(objc_type=VertexDescriptor, objc_name="reset") -VertexDescriptor_reset :: #force_inline proc(self: ^VertexDescriptor) { +VertexDescriptor_reset :: #force_inline proc "c" (self: ^VertexDescriptor) { msgSend(nil, self, "reset") } @(objc_type=VertexDescriptor, objc_name="vertexDescriptor", objc_is_class_method=true) -VertexDescriptor_vertexDescriptor :: #force_inline proc() -> ^VertexDescriptor { +VertexDescriptor_vertexDescriptor :: #force_inline proc "c" () -> ^VertexDescriptor { return msgSend(^VertexDescriptor, VertexDescriptor, "vertexDescriptor") } @@ -5267,23 +5267,23 @@ Methods: VisibleFunctionTableDescriptor :: struct { using _: NS.Copying(VisibleFunctionTableDescriptor) } @(objc_type=VisibleFunctionTableDescriptor, objc_name="alloc", objc_is_class_method=true) -VisibleFunctionTableDescriptor_alloc :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_alloc :: #force_inline proc "c" () -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "alloc") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="init") -VisibleFunctionTableDescriptor_init :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_init :: #force_inline proc "c" (self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, self, "init") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="functionCount") -VisibleFunctionTableDescriptor_functionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor) -> NS.UInteger { +VisibleFunctionTableDescriptor_functionCount :: #force_inline proc "c" (self: ^VisibleFunctionTableDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "functionCount") } @(objc_type=VisibleFunctionTableDescriptor, objc_name="setFunctionCount") -VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.UInteger) { +VisibleFunctionTableDescriptor_setFunctionCount :: #force_inline proc "c" (self: ^VisibleFunctionTableDescriptor, functionCount: NS.UInteger) { msgSend(nil, self, "setFunctionCount:", functionCount) } @(objc_type=VisibleFunctionTableDescriptor, objc_name="visibleFunctionTableDescriptor", objc_is_class_method=true) -VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: #force_inline proc() -> ^VisibleFunctionTableDescriptor { +VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: #force_inline proc "c" () -> ^VisibleFunctionTableDescriptor { return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "visibleFunctionTableDescriptor") } @@ -5301,12 +5301,12 @@ Methods: AccelerationStructure :: struct { using _: Resource } @(objc_type=AccelerationStructure, objc_name="size") -AccelerationStructure_size :: #force_inline proc(self: ^AccelerationStructure) -> NS.UInteger { +AccelerationStructure_size :: #force_inline proc "c" (self: ^AccelerationStructure) -> NS.UInteger { return msgSend(NS.UInteger, self, "size") } @(objc_type=AccelerationStructure, objc_name="getResourceID") -AccelerationStructure_getResourceID :: #force_inline proc(self: ^AccelerationStructure) -> ResourceID { +AccelerationStructure_getResourceID :: #force_inline proc "c" (self: ^AccelerationStructure) -> ResourceID { return msgSend(ResourceID, self, "getResourceID") } @@ -5335,55 +5335,55 @@ Methods: AccelerationStructureCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure") -AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { +AccelerationStructureCommandEncoder_buildAccelerationStructure :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure") -AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { +AccelerationStructureCommandEncoder_copyAccelerationStructure :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure") -AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { +AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) { msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure") -AccelerationStructureCommandEncoder_refitAccelerationStructure :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^AccelerationStructure, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { +AccelerationStructureCommandEncoder_refitAccelerationStructure :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^AccelerationStructure, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger) { msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructureWithOptions") -AccelerationStructureCommandEncoder_refitAccelerationStructureWithOptions :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^AccelerationStructure, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger, options: AccelerationStructureRefitOptions) { +AccelerationStructureCommandEncoder_refitAccelerationStructureWithOptions :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^AccelerationStructure, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^AccelerationStructure, scratchBuffer: ^Buffer, scratchBufferOffset: NS.UInteger, options: AccelerationStructureRefitOptions) { msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:options:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset, options) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="sampleCountersInBuffer") -AccelerationStructureCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { +AccelerationStructureCommandEncoder_sampleCountersInBuffer :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="updateFence") -AccelerationStructureCommandEncoder_updateFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { +AccelerationStructureCommandEncoder_updateFence :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeap") -AccelerationStructureCommandEncoder_useHeap :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heap: ^Heap) { +AccelerationStructureCommandEncoder_useHeap :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps") -AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, heaps: []^Heap) { +AccelerationStructureCommandEncoder_useHeaps :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, heaps: []^Heap) { msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource") -AccelerationStructureCommandEncoder_useResource :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resource: ^Resource, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResource :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources") -AccelerationStructureCommandEncoder_useResources :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, resources: []^Resource, usage: ResourceUsage) { +AccelerationStructureCommandEncoder_useResources :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, resources: []^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", resources, NS.UInteger(len(resources)), usage) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence") -AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { +AccelerationStructureCommandEncoder_waitForFence :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @(objc_type=AccelerationStructureCommandEncoder, objc_name="writeCompactedAccelerationStructureSize") -AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: #force_inline proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, buffer: ^Buffer, offset: NS.UInteger) { +AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: #force_inline proc "c" (self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^AccelerationStructure, buffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "writeCompactedAccelerationStructureSize:toBuffer:offset:", accelerationStructure, buffer, offset) } @@ -5394,41 +5394,41 @@ AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: # AccelerationStructurePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(AccelerationStructurePassSampleBufferAttachmentDescriptor) } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructurePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { +AccelerationStructurePassSampleBufferAttachmentDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptor, AccelerationStructurePassSampleBufferAttachmentDescriptor, "alloc") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="init") -AccelerationStructurePassSampleBufferAttachmentDescriptor_init :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { +AccelerationStructurePassSampleBufferAttachmentDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptor, self, "init") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer") -AccelerationStructurePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { +AccelerationStructurePassSampleBufferAttachmentDescriptor_sampleBuffer :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> ^CounterSampleBuffer { return msgSend(^CounterSampleBuffer, self, "sampleBuffer") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer") -AccelerationStructurePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { +AccelerationStructurePassSampleBufferAttachmentDescriptor_setSampleBuffer :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, sampleBuffer: ^CounterSampleBuffer) { msgSend(nil, self, "setSampleBuffer:", sampleBuffer) } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex") -AccelerationStructurePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +AccelerationStructurePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "startOfEncoderSampleIndex") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex") -AccelerationStructurePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { +AccelerationStructurePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex) } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex") -AccelerationStructurePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> NS.UInteger { +AccelerationStructurePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "endOfEncoderSampleIndex") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex") -AccelerationStructurePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { +AccelerationStructurePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.UInteger) { msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex) } @@ -5438,21 +5438,21 @@ AccelerationStructurePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleI AccelerationStructurePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptorArray, objc_name="alloc", objc_is_class_method=true) -AccelerationStructurePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc() -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { +AccelerationStructurePassSampleBufferAttachmentDescriptorArray_alloc :: #force_inline proc "c" () -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, AccelerationStructurePassSampleBufferAttachmentDescriptorArray, "alloc") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptorArray, objc_name="init") -AccelerationStructurePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { +AccelerationStructurePassSampleBufferAttachmentDescriptorArray_init :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, self, "init") } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptorArray, objc_name="object") -AccelerationStructurePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { +AccelerationStructurePassSampleBufferAttachmentDescriptorArray_object :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, attachmentIndex: NS.UInteger) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptor { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex) } @(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptorArray, objc_name="setObject") -AccelerationStructurePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc(self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, attachment: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { +AccelerationStructurePassSampleBufferAttachmentDescriptorArray_setObject :: #force_inline proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, attachment: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, attachmentIndex: NS.UInteger) { msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex) } @@ -5463,21 +5463,21 @@ AccelerationStructurePassDescriptor :: struct { using _: NS.Copying(Acceleration @(objc_type=AccelerationStructurePassDescriptor, objc_name="alloc", objc_is_class_method=true) -AccelerationStructurePassDescriptor_alloc :: #force_inline proc() -> ^AccelerationStructurePassDescriptor { +AccelerationStructurePassDescriptor_alloc :: #force_inline proc "c" () -> ^AccelerationStructurePassDescriptor { return msgSend(^AccelerationStructurePassDescriptor, AccelerationStructurePassDescriptor, "alloc") } @(objc_type=AccelerationStructurePassDescriptor, objc_name="init") -AccelerationStructurePassDescriptor_init :: #force_inline proc(self: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructurePassDescriptor { +AccelerationStructurePassDescriptor_init :: #force_inline proc "c" (self: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructurePassDescriptor { return msgSend(^AccelerationStructurePassDescriptor, self, "init") } @(objc_type=AccelerationStructurePassDescriptor, objc_name="accelerationStructurePassDescriptor", objc_is_class_method=true) -AccelerationStructurePassDescriptor_accelerationStructurePassDescriptor :: #force_inline proc() -> ^AccelerationStructurePassDescriptor { +AccelerationStructurePassDescriptor_accelerationStructurePassDescriptor :: #force_inline proc "c" () -> ^AccelerationStructurePassDescriptor { return msgSend(^AccelerationStructurePassDescriptor, AccelerationStructurePassDescriptor, "accelerationStructurePassDescriptor") } @(objc_type=AccelerationStructurePassDescriptor, objc_name="sampleBufferAttachments") -AccelerationStructurePassDescriptor_sampleBufferAttachments :: #force_inline proc(self: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { +AccelerationStructurePassDescriptor_sampleBufferAttachments :: #force_inline proc "c" (self: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructurePassSampleBufferAttachmentDescriptorArray { return msgSend(^AccelerationStructurePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments") } @@ -5488,27 +5488,27 @@ AccelerationStructurePassDescriptor_sampleBufferAttachments :: #force_inline pr Binding :: struct { using _: NS.Object } @(objc_type=Binding, objc_name="name") -Binding_name :: #force_inline proc(self: ^Binding) -> ^NS.String { +Binding_name :: #force_inline proc "c" (self: ^Binding) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Binding, objc_name="type") -Binding_type :: #force_inline proc(self: ^Binding) -> BindingType { +Binding_type :: #force_inline proc "c" (self: ^Binding) -> BindingType { return msgSend(BindingType, self, "type") } @(objc_type=Binding, objc_name="access") -Binding_access :: #force_inline proc(self: ^Binding) -> ArgumentAccess { +Binding_access :: #force_inline proc "c" (self: ^Binding) -> ArgumentAccess { return msgSend(ArgumentAccess, self, "access") } @(objc_type=Binding, objc_name="index") -Binding_index :: #force_inline proc(self: ^Binding) -> NS.UInteger { +Binding_index :: #force_inline proc "c" (self: ^Binding) -> NS.UInteger { return msgSend(NS.UInteger, self, "index") } @(objc_type=Binding, objc_name="isUsed") -Binding_isUsed :: #force_inline proc(self: ^Binding) -> BOOL { +Binding_isUsed :: #force_inline proc "c" (self: ^Binding) -> BOOL { return msgSend(BOOL, self, "isUsed") } @(objc_type=Binding, objc_name="isArgument") -Binding_isArgument :: #force_inline proc(self: ^Binding) -> BOOL { +Binding_isArgument :: #force_inline proc "c" (self: ^Binding) -> BOOL { return msgSend(BOOL, self, "isArgument") } @@ -5518,23 +5518,23 @@ Binding_isArgument :: #force_inline proc(self: ^Binding) -> BOOL { BufferBinding :: struct { using _: Binding } @(objc_type=BufferBinding, objc_name="bufferAlignment") -BufferBinding_bufferAlignment :: #force_inline proc(self: ^BufferBinding) -> NS.UInteger { +BufferBinding_bufferAlignment :: #force_inline proc "c" (self: ^BufferBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferAlignment") } @(objc_type=BufferBinding, objc_name="bufferDataSize") -BufferBinding_bufferDataSize :: #force_inline proc(self: ^BufferBinding) -> NS.UInteger { +BufferBinding_bufferDataSize :: #force_inline proc "c" (self: ^BufferBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferDataSize") } @(objc_type=BufferBinding, objc_name="bufferDataType") -BufferBinding_bufferDataType :: #force_inline proc(self: ^BufferBinding) -> DataType { +BufferBinding_bufferDataType :: #force_inline proc "c" (self: ^BufferBinding) -> DataType { return msgSend(DataType, self, "bufferDataType") } @(objc_type=BufferBinding, objc_name="bufferStructType") -BufferBinding_bufferStructType :: #force_inline proc(self: ^BufferBinding) -> ^StructType { +BufferBinding_bufferStructType :: #force_inline proc "c" (self: ^BufferBinding) -> ^StructType { return msgSend(^StructType, self, "bufferStructType") } @(objc_type=BufferBinding, objc_name="bufferPointerType") -BufferBinding_bufferPointerType :: #force_inline proc(self: ^BufferBinding) -> ^PointerType { +BufferBinding_bufferPointerType :: #force_inline proc "c" (self: ^BufferBinding) -> ^PointerType { return msgSend(^PointerType, self, "bufferPointerType") } @@ -5544,11 +5544,11 @@ BufferBinding_bufferPointerType :: #force_inline proc(self: ^BufferBinding) -> ^ ThreadgroupBinding :: struct { using _: Binding } @(objc_type=ThreadgroupBinding, objc_name="threadgroupMemoryAlignment") -ThreadgroupBinding_threadgroupMemoryAlignment :: #force_inline proc(self: ^ThreadgroupBinding) -> NS.UInteger { +ThreadgroupBinding_threadgroupMemoryAlignment :: #force_inline proc "c" (self: ^ThreadgroupBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadgroupMemoryAlignment") } @(objc_type=ThreadgroupBinding, objc_name="threadgroupMemoryDataSize") -ThreadgroupBinding_threadgroupMemoryDataSize :: #force_inline proc(self: ^ThreadgroupBinding) -> NS.UInteger { +ThreadgroupBinding_threadgroupMemoryDataSize :: #force_inline proc "c" (self: ^ThreadgroupBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadgroupMemoryDataSize") } @@ -5558,19 +5558,19 @@ ThreadgroupBinding_threadgroupMemoryDataSize :: #force_inline proc(self: ^Thread TextureBinding :: struct { using _: Binding } @(objc_type=TextureBinding, objc_name="textureType") -TextureBinding_textureType :: #force_inline proc(self: ^TextureBinding) -> TextureType { +TextureBinding_textureType :: #force_inline proc "c" (self: ^TextureBinding) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=TextureBinding, objc_name="textureDataType") -TextureBinding_textureDataType :: #force_inline proc(self: ^TextureBinding) -> DataType { +TextureBinding_textureDataType :: #force_inline proc "c" (self: ^TextureBinding) -> DataType { return msgSend(DataType, self, "textureDataType") } @(objc_type=TextureBinding, objc_name="isDepthTexture") -TextureBinding_isDepthTexture :: #force_inline proc(self: ^TextureBinding) -> BOOL { +TextureBinding_isDepthTexture :: #force_inline proc "c" (self: ^TextureBinding) -> BOOL { return msgSend(BOOL, self, "isDepthTexture") } @(objc_type=TextureBinding, objc_name="arrayLength") -TextureBinding_arrayLength :: #force_inline proc(self: ^TextureBinding) -> NS.UInteger { +TextureBinding_arrayLength :: #force_inline proc "c" (self: ^TextureBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @@ -5580,11 +5580,11 @@ TextureBinding_arrayLength :: #force_inline proc(self: ^TextureBinding) -> NS.UI ObjectPayloadBinding :: struct { using _: Binding } @(objc_type=ObjectPayloadBinding, objc_name="objectPayloadAlignment") -ObjectPayloadBinding_objectPayloadAlignment :: #force_inline proc(self: ^ObjectPayloadBinding) -> NS.UInteger { +ObjectPayloadBinding_objectPayloadAlignment :: #force_inline proc "c" (self: ^ObjectPayloadBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "objectPayloadAlignment") } @(objc_type=ObjectPayloadBinding, objc_name="objectPayloadDataSize") -ObjectPayloadBinding_objectPayloadDataSize :: #force_inline proc(self: ^ObjectPayloadBinding) -> NS.UInteger { +ObjectPayloadBinding_objectPayloadDataSize :: #force_inline proc "c" (self: ^ObjectPayloadBinding) -> NS.UInteger { return msgSend(NS.UInteger, self, "objectPayloadDataSize") } @@ -5626,114 +5626,114 @@ Methods: ArgumentEncoder :: struct { using _: NS.Object } @(objc_type=ArgumentEncoder, objc_name="alignment") -ArgumentEncoder_alignment :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { +ArgumentEncoder_alignment :: #force_inline proc "c" (self: ^ArgumentEncoder) -> NS.UInteger { return msgSend(NS.UInteger, self, "alignment") } @(objc_type=ArgumentEncoder, objc_name="constantData") -ArgumentEncoder_constantData :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> rawptr { +ArgumentEncoder_constantData :: #force_inline proc "c" (self: ^ArgumentEncoder, index: NS.UInteger) -> rawptr { return msgSend(rawptr, self, "constantDataAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="device") -ArgumentEncoder_device :: #force_inline proc(self: ^ArgumentEncoder) -> ^Device { +ArgumentEncoder_device :: #force_inline proc "c" (self: ^ArgumentEncoder) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=ArgumentEncoder, objc_name="encodedLength") -ArgumentEncoder_encodedLength :: #force_inline proc(self: ^ArgumentEncoder) -> NS.UInteger { +ArgumentEncoder_encodedLength :: #force_inline proc "c" (self: ^ArgumentEncoder) -> NS.UInteger { return msgSend(NS.UInteger, self, "encodedLength") } @(objc_type=ArgumentEncoder, objc_name="label") -ArgumentEncoder_label :: #force_inline proc(self: ^ArgumentEncoder) -> ^NS.String { +ArgumentEncoder_label :: #force_inline proc "c" (self: ^ArgumentEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBuffer") -ArgumentEncoder_newArgumentEncoderForBuffer :: #force_inline proc(self: ^ArgumentEncoder, index: NS.UInteger) -> ^ArgumentEncoder { +ArgumentEncoder_newArgumentEncoderForBuffer :: #force_inline proc "c" (self: ^ArgumentEncoder, index: NS.UInteger) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index) } @(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure") -ArgumentEncoder_setAccelerationStructure :: #force_inline proc(self: ^ArgumentEncoder, accelerationStructure: ^AccelerationStructure, index: NS.UInteger) { +ArgumentEncoder_setAccelerationStructure :: #force_inline proc "c" (self: ^ArgumentEncoder, accelerationStructure: ^AccelerationStructure, index: NS.UInteger) { msgSend(nil, self, "setAccelerationStructure:atIndex:", accelerationStructure, index) } @(objc_type=ArgumentEncoder, objc_name="setArgumentBufferWithOffset") -ArgumentEncoder_setArgumentBufferWithOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, offset: NS.UInteger) { +ArgumentEncoder_setArgumentBufferWithOffset :: #force_inline proc "c" (self: ^ArgumentEncoder, argumentBuffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset) } @(objc_type=ArgumentEncoder, objc_name="setArgumentBufferWithStartOffset") -ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset :: #force_inline proc(self: ^ArgumentEncoder, argumentBuffer: ^Buffer, startOffset: NS.UInteger, arrayElement: NS.UInteger) { +ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset :: #force_inline proc "c" (self: ^ArgumentEncoder, argumentBuffer: ^Buffer, startOffset: NS.UInteger, arrayElement: NS.UInteger) { msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement) } @(objc_type=ArgumentEncoder, objc_name="setBuffer") -ArgumentEncoder_setBuffer :: #force_inline proc(self: ^ArgumentEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +ArgumentEncoder_setBuffer :: #force_inline proc "c" (self: ^ArgumentEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ArgumentEncoder, objc_name="setBuffers") -ArgumentEncoder_setBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +ArgumentEncoder_setBuffers :: #force_inline proc "odin" (self: ^ArgumentEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { assert(len(buffers) == len(offsets)) msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineState") -ArgumentEncoder_setComputePipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^ComputePipelineState, index: NS.UInteger) { +ArgumentEncoder_setComputePipelineState :: #force_inline proc "c" (self: ^ArgumentEncoder, pipeline: ^ComputePipelineState, index: NS.UInteger) { msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates") -ArgumentEncoder_setComputePipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^ComputePipelineState, range: NS.Range) { +ArgumentEncoder_setComputePipelineStates :: #force_inline proc "odin" (self: ^ArgumentEncoder, pipelines: []^ComputePipelineState, range: NS.Range) { assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setComputePipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer") -ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^IndirectCommandBuffer, index: NS.UInteger) { +ArgumentEncoder_setIndirectCommandBuffer :: #force_inline proc "c" (self: ^ArgumentEncoder, indirectCommandBuffer: ^IndirectCommandBuffer, index: NS.UInteger) { msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index) } @(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers") -ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc(self: ^ArgumentEncoder, buffers: []^IndirectCommandBuffer, range: NS.Range) { +ArgumentEncoder_setIndirectCommandBuffers :: #force_inline proc "odin" (self: ^ArgumentEncoder, buffers: []^IndirectCommandBuffer, range: NS.Range) { assert(range.length <= NS.UInteger(len(buffers))) msgSend(nil, self, "setIndirectCommandBuffers:withRange:", raw_data(buffers), range) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable") -ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, index: NS.UInteger) { +ArgumentEncoder_setIntersectionFunctionTable :: #force_inline proc "c" (self: ^ArgumentEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables") -ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { +ArgumentEncoder_setIntersectionFunctionTables :: #force_inline proc "odin" (self: ^ArgumentEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ArgumentEncoder, objc_name="setLabel") -ArgumentEncoder_setLabel :: #force_inline proc(self: ^ArgumentEncoder, label: ^NS.String) { +ArgumentEncoder_setLabel :: #force_inline proc "c" (self: ^ArgumentEncoder, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineState") -ArgumentEncoder_setRenderPipelineState :: #force_inline proc(self: ^ArgumentEncoder, pipeline: ^RenderPipelineState, index: NS.UInteger) { +ArgumentEncoder_setRenderPipelineState :: #force_inline proc "c" (self: ^ArgumentEncoder, pipeline: ^RenderPipelineState, index: NS.UInteger) { msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index) } @(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates") -ArgumentEncoder_setRenderPipelineStates :: #force_inline proc(self: ^ArgumentEncoder, pipelines: []^RenderPipelineState, range: NS.Range) { +ArgumentEncoder_setRenderPipelineStates :: #force_inline proc "odin" (self: ^ArgumentEncoder, pipelines: []^RenderPipelineState, range: NS.Range) { assert(range.length <= NS.UInteger(len(pipelines))) msgSend(nil, self, "setRenderPipelineStates:withRange:", raw_data(pipelines), range) } @(objc_type=ArgumentEncoder, objc_name="setSamplerState") -ArgumentEncoder_setSamplerState :: #force_inline proc(self: ^ArgumentEncoder, sampler: ^SamplerState, index: NS.UInteger) { +ArgumentEncoder_setSamplerState :: #force_inline proc "c" (self: ^ArgumentEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ArgumentEncoder, objc_name="setSamplerStates") -ArgumentEncoder_setSamplerStates :: #force_inline proc(self: ^ArgumentEncoder, samplers: []^SamplerState, range: NS.Range) { +ArgumentEncoder_setSamplerStates :: #force_inline proc "odin" (self: ^ArgumentEncoder, samplers: []^SamplerState, range: NS.Range) { assert(range.length <= NS.UInteger(len(samplers))) msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=ArgumentEncoder, objc_name="setTexture") -ArgumentEncoder_setTexture :: #force_inline proc(self: ^ArgumentEncoder, texture: ^Texture, index: NS.UInteger) { +ArgumentEncoder_setTexture :: #force_inline proc "c" (self: ^ArgumentEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ArgumentEncoder, objc_name="setTextures") -ArgumentEncoder_setTextures :: #force_inline proc(self: ^ArgumentEncoder, textures: []^Texture, range: NS.Range) { +ArgumentEncoder_setTextures :: #force_inline proc "odin" (self: ^ArgumentEncoder, textures: []^Texture, range: NS.Range) { assert(range.length <= NS.UInteger(len(textures))) msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable") -ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTable: ^VisibleFunctionTable, index: NS.UInteger) { +ArgumentEncoder_setVisibleFunctionTable :: #force_inline proc "c" (self: ^ArgumentEncoder, visibleFunctionTable: ^VisibleFunctionTable, index: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index) } @(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables") -ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ArgumentEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { +ArgumentEncoder_setVisibleFunctionTables :: #force_inline proc "odin" (self: ^ArgumentEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { assert(range.length <= NS.UInteger(len(visibleFunctionTables))) msgSend(nil, self, "setVisibleFunctionTables:withRange:", raw_data(visibleFunctionTables), range) } @@ -5757,41 +5757,41 @@ Methods: BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) } @(objc_type=BinaryArchive, objc_name="addComputePipelineFunctions") -BinaryArchive_addComputePipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +BinaryArchive_addComputePipelineFunctions :: #force_inline proc "contextless" (self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctions") -BinaryArchive_addRenderPipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +BinaryArchive_addRenderPipelineFunctions :: #force_inline proc "contextless" (self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctions") -BinaryArchive_addTileRenderPipelineFunctions :: #force_inline proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { +BinaryArchive_addTileRenderPipelineFunctions :: #force_inline proc "contextless" (self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, &error) return } @(objc_type=BinaryArchive, objc_name="device") -BinaryArchive_device :: #force_inline proc(self: ^BinaryArchive) -> ^Device { +BinaryArchive_device :: #force_inline proc "c" (self: ^BinaryArchive) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=BinaryArchive, objc_name="label") -BinaryArchive_label :: #force_inline proc(self: ^BinaryArchive) -> ^NS.String { +BinaryArchive_label :: #force_inline proc "c" (self: ^BinaryArchive) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=BinaryArchive, objc_name="serializeToURL") -BinaryArchive_serializeToURL :: #force_inline proc(self: ^BinaryArchive, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { +BinaryArchive_serializeToURL :: #force_inline proc "contextless" (self: ^BinaryArchive, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) return } @(objc_type=BinaryArchive, objc_name="setLabel") -BinaryArchive_setLabel :: #force_inline proc(self: ^BinaryArchive, label: ^NS.String) { +BinaryArchive_setLabel :: #force_inline proc "c" (self: ^BinaryArchive, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=BinaryArchive, objc_name="addFunction") -BinaryArchive_addFunction :: #force_inline proc(self: ^BinaryArchive, descriptor: ^FunctionDescriptor, library: ^Library) -> (ok: BOOL, error: ^NS.Error) { +BinaryArchive_addFunction :: #force_inline proc "contextless" (self: ^BinaryArchive, descriptor: ^FunctionDescriptor, library: ^Library) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "addFunction:", descriptor, library, &error) return } @@ -5833,103 +5833,103 @@ Methods: BlitCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=BlitCommandEncoder, objc_name="copyFromBufferEx") -BlitCommandEncoder_copyFromBufferEx :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromBufferEx :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBufferExWithOptions") -BlitCommandEncoder_copyFromBufferExWithOptions :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { +BlitCommandEncoder_copyFromBufferExWithOptions :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, sourceBytesPerRow: NS.UInteger, sourceBytesPerImage: NS.UInteger, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin, options: BlitOption) { msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer") -BlitCommandEncoder_copyFromBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, size: NS.UInteger) { +BlitCommandEncoder_copyFromBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceBuffer: ^Buffer, sourceOffset: NS.UInteger, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, size: NS.UInteger) { msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTextureEx") -BlitCommandEncoder_copyFromTextureEx :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger) { +BlitCommandEncoder_copyFromTextureEx :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTextureExWithOptions") -BlitCommandEncoder_copyFromTextureExWithOptions :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger, options: BlitOption) { +BlitCommandEncoder_copyFromTextureExWithOptions :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger, destinationBytesPerRow: NS.UInteger, destinationBytesPerImage: NS.UInteger, options: BlitOption) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTextureWithDestinationOrigin") -BlitCommandEncoder_copyFromTextureWithDestinationOrigin :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { +BlitCommandEncoder_copyFromTextureWithDestinationOrigin :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, destinationOrigin: Origin) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTextureWithCounts") -BlitCommandEncoder_copyFromTextureWithCounts :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, sliceCount: NS.UInteger, levelCount: NS.UInteger) { +BlitCommandEncoder_copyFromTextureWithCounts :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, sourceSlice: NS.UInteger, sourceLevel: NS.UInteger, destinationTexture: ^Texture, destinationSlice: NS.UInteger, destinationLevel: NS.UInteger, sliceCount: NS.UInteger, levelCount: NS.UInteger) { msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount) } @(objc_type=BlitCommandEncoder, objc_name="copyFromTexture") -BlitCommandEncoder_copyFromTexture :: #force_inline proc(self: ^BlitCommandEncoder, sourceTexture: ^Texture, destinationTexture: ^Texture) { +BlitCommandEncoder_copyFromTexture :: #force_inline proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, destinationTexture: ^Texture) { msgSend(nil, self, "copyFromTexture:toTexture:", sourceTexture, destinationTexture) } @(objc_type=BlitCommandEncoder, objc_name="copyIndirectCommandBuffer") -BlitCommandEncoder_copyIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, source: ^IndirectCommandBuffer, sourceRange: NS.Range, destination: ^IndirectCommandBuffer, destinationIndex: NS.UInteger) { +BlitCommandEncoder_copyIndirectCommandBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, source: ^IndirectCommandBuffer, sourceRange: NS.Range, destination: ^IndirectCommandBuffer, destinationIndex: NS.UInteger) { msgSend(nil, self, "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:", source, sourceRange, destination, destinationIndex) } @(objc_type=BlitCommandEncoder, objc_name="fillBuffer") -BlitCommandEncoder_fillBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range, value: u8) { +BlitCommandEncoder_fillBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range, value: u8) { msgSend(nil, self, "fillBuffer:range:value:", buffer, range, value) } @(objc_type=BlitCommandEncoder, objc_name="generateMipmapsForTexture") -BlitCommandEncoder_generateMipmapsForTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { +BlitCommandEncoder_generateMipmapsForTexture :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "generateMipmapsForTexture:", texture) } @(objc_type=BlitCommandEncoder, objc_name="getTextureAccessCounters") -BlitCommandEncoder_getTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger, resetCounters: BOOL, countersBuffer: ^Buffer, countersBufferOffset: NS.UInteger) { +BlitCommandEncoder_getTextureAccessCounters :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger, resetCounters: BOOL, countersBuffer: ^Buffer, countersBufferOffset: NS.UInteger) { msgSend(nil, self, "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:", texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess") -BlitCommandEncoder_optimizeContentsForCPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { +BlitCommandEncoder_optimizeContentsForCPUAccess :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "optimizeContentsForCPUAccess:", texture) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccessWithSliceAndLevel") -BlitCommandEncoder_optimizeContentsForCPUAccessWithSliceAndLevel :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { +BlitCommandEncoder_optimizeContentsForCPUAccessWithSliceAndLevel :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "optimizeContentsForCPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess") -BlitCommandEncoder_optimizeContentsForGPUAccess :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture) { +BlitCommandEncoder_optimizeContentsForGPUAccess :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) { msgSend(nil, self, "optimizeContentsForGPUAccess:", texture) } @(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccessWithSliceAndLevel") -BlitCommandEncoder_optimizeContentsForGPUAccessWithSliceAndLevel :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { +BlitCommandEncoder_optimizeContentsForGPUAccessWithSliceAndLevel :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "optimizeContentsForGPUAccess:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="optimizeIndirectCommandBuffer") -BlitCommandEncoder_optimizeIndirectCommandBuffer :: #force_inline proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^Buffer, range: NS.Range) { +BlitCommandEncoder_optimizeIndirectCommandBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, indirectCommandBuffer: ^Buffer, range: NS.Range) { msgSend(nil, self, "optimizeIndirectCommandBuffer:withRange:", indirectCommandBuffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetCommandsInBuffer") -BlitCommandEncoder_resetCommandsInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range) { +BlitCommandEncoder_resetCommandsInBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, buffer: ^Buffer, range: NS.Range) { msgSend(nil, self, "resetCommandsInBuffer:withRange:", buffer, range) } @(objc_type=BlitCommandEncoder, objc_name="resetTextureAccessCounters") -BlitCommandEncoder_resetTextureAccessCounters :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { +BlitCommandEncoder_resetTextureAccessCounters :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "resetTextureAccessCounters:region:mipLevel:slice:", texture, region, mipLevel, slice) } @(objc_type=BlitCommandEncoder, objc_name="resolveCounters") -BlitCommandEncoder_resolveCounters :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, range: NS.Range, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger) { +BlitCommandEncoder_resolveCounters :: #force_inline proc "c" (self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, range: NS.Range, destinationBuffer: ^Buffer, destinationOffset: NS.UInteger) { msgSend(nil, self, "resolveCounters:inRange:destinationBuffer:destinationOffset:", sampleBuffer, range, destinationBuffer, destinationOffset) } @(objc_type=BlitCommandEncoder, objc_name="sampleCountersInBuffer") -BlitCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { +BlitCommandEncoder_sampleCountersInBuffer :: #force_inline proc "c" (self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeResource") -BlitCommandEncoder_synchronizeResource :: #force_inline proc(self: ^BlitCommandEncoder, resource: ^Resource) { +BlitCommandEncoder_synchronizeResource :: #force_inline proc "c" (self: ^BlitCommandEncoder, resource: ^Resource) { msgSend(nil, self, "synchronizeResource:", resource) } @(objc_type=BlitCommandEncoder, objc_name="synchronizeTexture") -BlitCommandEncoder_synchronizeTexture :: #force_inline proc(self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { +BlitCommandEncoder_synchronizeTexture :: #force_inline proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, slice: NS.UInteger, level: NS.UInteger) { msgSend(nil, self, "synchronizeTexture:slice:level:", texture, slice, level) } @(objc_type=BlitCommandEncoder, objc_name="updateFence") -BlitCommandEncoder_updateFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^Fence) { +BlitCommandEncoder_updateFence :: #force_inline proc "c" (self: ^BlitCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=BlitCommandEncoder, objc_name="waitForFence") -BlitCommandEncoder_waitForFence :: #force_inline proc(self: ^BlitCommandEncoder, fence: ^Fence) { +BlitCommandEncoder_waitForFence :: #force_inline proc "c" (self: ^BlitCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @@ -5953,60 +5953,60 @@ Methods: Buffer :: struct { using _: Resource } @(objc_type=Buffer, objc_name="addDebugMarker") -Buffer_addDebugMarker :: #force_inline proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) { +Buffer_addDebugMarker :: #force_inline proc "c" (self: ^Buffer, marker: ^NS.String, range: NS.Range) { msgSend(nil, self, "addDebugMarker:range:", marker, range) } @(objc_type=Buffer, objc_name="contents") -Buffer_contents :: #force_inline proc(self: ^Buffer) -> []byte { +Buffer_contents :: #force_inline proc "c" (self: ^Buffer) -> []byte { contents := msgSend([^]byte, self, "contents") length := Buffer_length(self) return contents[:length] } @(objc_type=Buffer, objc_name="contentsPointer") -Buffer_contentsPointer :: #force_inline proc(self: ^Buffer) -> rawptr { +Buffer_contentsPointer :: #force_inline proc "c" (self: ^Buffer) -> rawptr { return msgSend(rawptr, self, "contents") } @(objc_type=Buffer, objc_name="contentsAsSlice") -Buffer_contentsAsSlice :: #force_inline proc(self: ^Buffer, $T: typeid/[]$E) -> T { +Buffer_contentsAsSlice :: #force_inline proc "c" (self: ^Buffer, $T: typeid/[]$E) -> T { contents := msgSend([^]byte, self, "contents") length := Buffer_length(self) return mem.slice_data_cast(T, contents[:length]) } @(objc_type=Buffer, objc_name="contentsAsType") -Buffer_contentsAsType :: #force_inline proc(self: ^Buffer, $T: typeid, offset: uintptr = 0) -> ^T { +Buffer_contentsAsType :: #force_inline proc "c" (self: ^Buffer, $T: typeid, offset: uintptr = 0) -> ^T { ptr := msgSend(rawptr, self, "contents") return (^T)(uintptr(ptr) + offset) } @(objc_type=Buffer, objc_name="didModifyRange") -Buffer_didModifyRange :: #force_inline proc(self: ^Buffer, range: NS.Range) { +Buffer_didModifyRange :: #force_inline proc "c" (self: ^Buffer, range: NS.Range) { msgSend(nil, self, "didModifyRange:", range) } @(objc_type=Buffer, objc_name="length") -Buffer_length :: #force_inline proc(self: ^Buffer) -> NS.UInteger { +Buffer_length :: #force_inline proc "c" (self: ^Buffer) -> NS.UInteger { return msgSend(NS.UInteger, self, "length") } @(objc_type=Buffer, objc_name="newRemoteBufferViewForDevice") -Buffer_newRemoteBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^Device) -> ^Buffer { +Buffer_newRemoteBufferViewForDevice :: #force_inline proc "c" (self: ^Buffer, device: ^Device) -> ^Buffer { return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) } @(objc_type=Buffer, objc_name="newTexture") -Buffer_newTexture :: #force_inline proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Texture { +Buffer_newTexture :: #force_inline proc "c" (self: ^Buffer, descriptor: ^TextureDescriptor, offset: NS.UInteger, bytesPerRow: NS.UInteger) -> ^Texture { return msgSend(^Texture, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow) } @(objc_type=Buffer, objc_name="remoteStorageBuffer") -Buffer_remoteStorageBuffer :: #force_inline proc(self: ^Buffer) -> ^Buffer { +Buffer_remoteStorageBuffer :: #force_inline proc "c" (self: ^Buffer) -> ^Buffer { return msgSend(^Buffer, self, "remoteStorageBuffer") } @(objc_type=Buffer, objc_name="removeAllDebugMarkers") -Buffer_removeAllDebugMarkers :: #force_inline proc(self: ^Buffer) { +Buffer_removeAllDebugMarkers :: #force_inline proc "c" (self: ^Buffer) { msgSend(nil, self, "removeAllDebugMarkers") } @(objc_type=Buffer, objc_name="newRemoveBufferViewForDevice") -Buffer_newRemoveBufferViewForDevice :: #force_inline proc(self: ^Buffer, device: ^Device) -> ^Buffer { +Buffer_newRemoveBufferViewForDevice :: #force_inline proc "c" (self: ^Buffer, device: ^Device) -> ^Buffer { return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device) } @(objc_type=Buffer, objc_name="gpuAddress") -Buffer_gpuAddress :: #force_inline proc(self: ^Buffer) -> u64 { +Buffer_gpuAddress :: #force_inline proc "c" (self: ^Buffer) -> u64 { return msgSend(u64, self, "gpuAddress") } @@ -6029,27 +6029,27 @@ Methods: CaptureScope :: struct { using _: NS.Object } @(objc_type=CaptureScope, objc_name="beginScope") -CaptureScope_beginScope :: #force_inline proc(self: ^CaptureScope) { +CaptureScope_beginScope :: #force_inline proc "c" (self: ^CaptureScope) { msgSend(nil, self, "beginScope") } @(objc_type=CaptureScope, objc_name="commandQueue") -CaptureScope_commandQueue :: #force_inline proc(self: ^CaptureScope) -> ^CommandQueue { +CaptureScope_commandQueue :: #force_inline proc "c" (self: ^CaptureScope) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandQueue") } @(objc_type=CaptureScope, objc_name="device") -CaptureScope_device :: #force_inline proc(self: ^CaptureScope) -> ^Device { +CaptureScope_device :: #force_inline proc "c" (self: ^CaptureScope) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=CaptureScope, objc_name="endScope") -CaptureScope_endScope :: #force_inline proc(self: ^CaptureScope) { +CaptureScope_endScope :: #force_inline proc "c" (self: ^CaptureScope) { msgSend(nil, self, "endScope") } @(objc_type=CaptureScope, objc_name="label") -CaptureScope_label :: #force_inline proc(self: ^CaptureScope) -> ^NS.String { +CaptureScope_label :: #force_inline proc "c" (self: ^CaptureScope) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CaptureScope, objc_name="setLabel") -CaptureScope_setLabel :: #force_inline proc(self: ^CaptureScope, label: ^NS.String) { +CaptureScope_setLabel :: #force_inline proc "c" (self: ^CaptureScope, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6101,151 +6101,151 @@ Methods: CommandBuffer :: struct { using _: NS.Object } @(objc_type=CommandBuffer, objc_name="GPUEndTime") -CommandBuffer_GPUEndTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_GPUEndTime :: #force_inline proc "c" (self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "GPUEndTime") } @(objc_type=CommandBuffer, objc_name="GPUStartTime") -CommandBuffer_GPUStartTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_GPUStartTime :: #force_inline proc "c" (self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "GPUStartTime") } @(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoder") -CommandBuffer_accelerationStructureCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^AccelerationStructureCommandEncoder { +CommandBuffer_accelerationStructureCommandEncoder :: #force_inline proc "c" (self: ^CommandBuffer) -> ^AccelerationStructureCommandEncoder { return msgSend(^AccelerationStructureCommandEncoder, self, "accelerationStructureCommandEncoder") } @(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoderWithDescriptor") -CommandBuffer_accelerationStructureCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, descriptor: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructureCommandEncoder { +CommandBuffer_accelerationStructureCommandEncoderWithDescriptor :: #force_inline proc "c" (self: ^CommandBuffer, descriptor: ^AccelerationStructurePassDescriptor) -> ^AccelerationStructureCommandEncoder { return msgSend(^AccelerationStructureCommandEncoder, self, "accelerationStructureCommandEncoderWithDescriptor:", descriptor) } @(objc_type=CommandBuffer, objc_name="addCompletedHandler") -CommandBuffer_addCompletedHandler :: #force_inline proc(self: ^CommandBuffer, block: CommandBufferHandler) { +CommandBuffer_addCompletedHandler :: #force_inline proc "c" (self: ^CommandBuffer, block: CommandBufferHandler) { msgSend(nil, self, "addCompletedHandler:", block) } @(objc_type=CommandBuffer, objc_name="addScheduledHandler") -CommandBuffer_addScheduledHandler :: #force_inline proc(self: ^CommandBuffer, block: CommandBufferHandler) { +CommandBuffer_addScheduledHandler :: #force_inline proc "c" (self: ^CommandBuffer, block: CommandBufferHandler) { msgSend(nil, self, "addScheduledHandler:", block) } @(objc_type=CommandBuffer, objc_name="blitCommandEncoder") -CommandBuffer_blitCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^BlitCommandEncoder { +CommandBuffer_blitCommandEncoder :: #force_inline proc "c" (self: ^CommandBuffer) -> ^BlitCommandEncoder { return msgSend(^BlitCommandEncoder, self, "blitCommandEncoder") } @(objc_type=CommandBuffer, objc_name="blitCommandEncoderWithDescriptor") -CommandBuffer_blitCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^BlitCommandEncoder { +CommandBuffer_blitCommandEncoderWithDescriptor :: #force_inline proc "c" (self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^BlitCommandEncoder { return msgSend(^BlitCommandEncoder, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor) } @(objc_type=CommandBuffer, objc_name="commandQueue") -CommandBuffer_commandQueue :: #force_inline proc(self: ^CommandBuffer) -> ^CommandQueue { +CommandBuffer_commandQueue :: #force_inline proc "c" (self: ^CommandBuffer) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandQueue") } @(objc_type=CommandBuffer, objc_name="commit") -CommandBuffer_commit :: #force_inline proc(self: ^CommandBuffer) { +CommandBuffer_commit :: #force_inline proc "c" (self: ^CommandBuffer) { msgSend(nil, self, "commit") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoder") -CommandBuffer_computeCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^ComputeCommandEncoder { +CommandBuffer_computeCommandEncoder :: #force_inline proc "c" (self: ^CommandBuffer) -> ^ComputeCommandEncoder { return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoder") } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor") -CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^ComputeCommandEncoder { +CommandBuffer_computeCommandEncoderWithDescriptor :: #force_inline proc "c" (self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^ComputeCommandEncoder { return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor) } @(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType") -CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^ComputeCommandEncoder { +CommandBuffer_computeCommandEncoderWithDispatchType :: #force_inline proc "c" (self: ^CommandBuffer, dispatchType: DispatchType) -> ^ComputeCommandEncoder { return msgSend(^ComputeCommandEncoder, self, "computeCommandEncoderWithDispatchType:", dispatchType) } @(objc_type=CommandBuffer, objc_name="device") -CommandBuffer_device :: #force_inline proc(self: ^CommandBuffer) -> ^Device { +CommandBuffer_device :: #force_inline proc "c" (self: ^CommandBuffer) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=CommandBuffer, objc_name="encodeSignalEvent") -CommandBuffer_encodeSignalEvent :: #force_inline proc(self: ^CommandBuffer, event: ^Event, value: u64) { +CommandBuffer_encodeSignalEvent :: #force_inline proc "c" (self: ^CommandBuffer, event: ^Event, value: u64) { msgSend(nil, self, "encodeSignalEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="encodeWaitForEvent") -CommandBuffer_encodeWaitForEvent :: #force_inline proc(self: ^CommandBuffer, event: ^Event, value: u64) { +CommandBuffer_encodeWaitForEvent :: #force_inline proc "c" (self: ^CommandBuffer, event: ^Event, value: u64) { msgSend(nil, self, "encodeWaitForEvent:value:", event, value) } @(objc_type=CommandBuffer, objc_name="enqueue") -CommandBuffer_enqueue :: #force_inline proc(self: ^CommandBuffer) { +CommandBuffer_enqueue :: #force_inline proc "c" (self: ^CommandBuffer) { msgSend(nil, self, "enqueue") } @(objc_type=CommandBuffer, objc_name="error") -CommandBuffer_error :: #force_inline proc(self: ^CommandBuffer) -> ^NS.Error { +CommandBuffer_error :: #force_inline proc "c" (self: ^CommandBuffer) -> ^NS.Error { return msgSend(^NS.Error, self, "error") } @(objc_type=CommandBuffer, objc_name="errorOptions") -CommandBuffer_errorOptions :: #force_inline proc(self: ^CommandBuffer) -> CommandBufferErrorOption { +CommandBuffer_errorOptions :: #force_inline proc "c" (self: ^CommandBuffer) -> CommandBufferErrorOption { return msgSend(CommandBufferErrorOption, self, "errorOptions") } @(objc_type=CommandBuffer, objc_name="kernelEndTime") -CommandBuffer_kernelEndTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_kernelEndTime :: #force_inline proc "c" (self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "kernelEndTime") } @(objc_type=CommandBuffer, objc_name="kernelStartTime") -CommandBuffer_kernelStartTime :: #force_inline proc(self: ^CommandBuffer) -> CFTimeInterval { +CommandBuffer_kernelStartTime :: #force_inline proc "c" (self: ^CommandBuffer) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "kernelStartTime") } @(objc_type=CommandBuffer, objc_name="label") -CommandBuffer_label :: #force_inline proc(self: ^CommandBuffer) -> ^NS.String { +CommandBuffer_label :: #force_inline proc "c" (self: ^CommandBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandBuffer, objc_name="logs") -CommandBuffer_logs :: #force_inline proc(self: ^CommandBuffer) -> ^LogContainer { +CommandBuffer_logs :: #force_inline proc "c" (self: ^CommandBuffer) -> ^LogContainer { return msgSend(^LogContainer, self, "logs") } @(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoder") -CommandBuffer_parallelRenderCommandEncoder :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { +CommandBuffer_parallelRenderCommandEncoder :: #force_inline proc "c" (self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^ParallelRenderCommandEncoder { return msgSend(^ParallelRenderCommandEncoder, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="popDebugGroup") -CommandBuffer_popDebugGroup :: #force_inline proc(self: ^CommandBuffer) { +CommandBuffer_popDebugGroup :: #force_inline proc "c" (self: ^CommandBuffer) { msgSend(nil, self, "popDebugGroup") } @(objc_type=CommandBuffer, objc_name="presentDrawable") -CommandBuffer_presentDrawable :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable) { +CommandBuffer_presentDrawable :: #force_inline proc "c" (self: ^CommandBuffer, drawable: ^Drawable) { msgSend(nil, self, "presentDrawable:", drawable) } @(objc_type=CommandBuffer, objc_name="presentDrawableAfterMinimumDuration") -CommandBuffer_presentDrawableAfterMinimumDuration :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable, duration: CFTimeInterval) { +CommandBuffer_presentDrawableAfterMinimumDuration :: #force_inline proc "c" (self: ^CommandBuffer, drawable: ^Drawable, duration: CFTimeInterval) { msgSend(nil, self, "presentDrawable:afterMinimumDuration:", drawable, duration) } @(objc_type=CommandBuffer, objc_name="presentDrawableAtTime") -CommandBuffer_presentDrawableAtTime :: #force_inline proc(self: ^CommandBuffer, drawable: ^Drawable, presentationTime: CFTimeInterval) { +CommandBuffer_presentDrawableAtTime :: #force_inline proc "c" (self: ^CommandBuffer, drawable: ^Drawable, presentationTime: CFTimeInterval) { msgSend(nil, self, "presentDrawable:atTime:", drawable, presentationTime) } @(objc_type=CommandBuffer, objc_name="pushDebugGroup") -CommandBuffer_pushDebugGroup :: #force_inline proc(self: ^CommandBuffer, string: ^NS.String) { +CommandBuffer_pushDebugGroup :: #force_inline proc "c" (self: ^CommandBuffer, string: ^NS.String) { msgSend(nil, self, "pushDebugGroup:", string) } @(objc_type=CommandBuffer, objc_name="renderCommandEncoderWithDescriptor") -CommandBuffer_renderCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^RenderCommandEncoder { +CommandBuffer_renderCommandEncoderWithDescriptor :: #force_inline proc "c" (self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^RenderCommandEncoder { return msgSend(^RenderCommandEncoder, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor) } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoder") -CommandBuffer_resourceStateCommandEncoder :: #force_inline proc(self: ^CommandBuffer) -> ^CommandBuffer { +CommandBuffer_resourceStateCommandEncoder :: #force_inline proc "c" (self: ^CommandBuffer) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "resourceStateCommandEncoder") } @(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoderWithDescriptor") -CommandBuffer_resourceStateCommandEncoderWithDescriptor :: #force_inline proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^ResourceStateCommandEncoder { +CommandBuffer_resourceStateCommandEncoderWithDescriptor :: #force_inline proc "c" (self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^ResourceStateCommandEncoder { return msgSend(^ResourceStateCommandEncoder, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor) } @(objc_type=CommandBuffer, objc_name="retainedReferences") -CommandBuffer_retainedReferences :: #force_inline proc(self: ^CommandBuffer) -> BOOL { +CommandBuffer_retainedReferences :: #force_inline proc "c" (self: ^CommandBuffer) -> BOOL { return msgSend(BOOL, self, "retainedReferences") } @(objc_type=CommandBuffer, objc_name="setLabel") -CommandBuffer_setLabel :: #force_inline proc(self: ^CommandBuffer, label: ^NS.String) { +CommandBuffer_setLabel :: #force_inline proc "c" (self: ^CommandBuffer, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=CommandBuffer, objc_name="status") -CommandBuffer_status :: #force_inline proc(self: ^CommandBuffer) -> CommandBufferStatus { +CommandBuffer_status :: #force_inline proc "c" (self: ^CommandBuffer) -> CommandBufferStatus { return msgSend(CommandBufferStatus, self, "status") } @(objc_type=CommandBuffer, objc_name="waitUntilCompleted") -CommandBuffer_waitUntilCompleted :: #force_inline proc(self: ^CommandBuffer) { +CommandBuffer_waitUntilCompleted :: #force_inline proc "c" (self: ^CommandBuffer) { msgSend(nil, self, "waitUntilCompleted") } @(objc_type=CommandBuffer, objc_name="waitUntilScheduled") -CommandBuffer_waitUntilScheduled :: #force_inline proc(self: ^CommandBuffer) { +CommandBuffer_waitUntilScheduled :: #force_inline proc "c" (self: ^CommandBuffer) { msgSend(nil, self, "waitUntilScheduled") } @@ -6264,15 +6264,15 @@ Methods: CommandBufferEncoderInfo :: struct { using _: NS.Object } @(objc_type=CommandBufferEncoderInfo, objc_name="debugSignposts") -CommandBufferEncoderInfo_debugSignposts :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> ^NS.Array { +CommandBufferEncoderInfo_debugSignposts :: #force_inline proc "c" (self: ^CommandBufferEncoderInfo) -> ^NS.Array { return msgSend(^NS.Array, self, "debugSignposts") } @(objc_type=CommandBufferEncoderInfo, objc_name="errorState") -CommandBufferEncoderInfo_errorState :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState { +CommandBufferEncoderInfo_errorState :: #force_inline proc "c" (self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState { return msgSend(CommandEncoderErrorState, self, "errorState") } @(objc_type=CommandBufferEncoderInfo, objc_name="label") -CommandBufferEncoderInfo_label :: #force_inline proc(self: ^CommandBufferEncoderInfo) -> ^NS.String { +CommandBufferEncoderInfo_label :: #force_inline proc "c" (self: ^CommandBufferEncoderInfo) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -6295,31 +6295,31 @@ Methods: CommandEncoder :: struct { using _: NS.Object } @(objc_type=CommandEncoder, objc_name="device") -CommandEncoder_device :: #force_inline proc(self: ^CommandEncoder) -> ^Device { +CommandEncoder_device :: #force_inline proc "c" (self: ^CommandEncoder) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=CommandEncoder, objc_name="endEncoding") -CommandEncoder_endEncoding :: #force_inline proc(self: ^CommandEncoder) { +CommandEncoder_endEncoding :: #force_inline proc "c" (self: ^CommandEncoder) { msgSend(nil, self, "endEncoding") } @(objc_type=CommandEncoder, objc_name="insertDebugSignpost") -CommandEncoder_insertDebugSignpost :: #force_inline proc(self: ^CommandEncoder, string: ^NS.String) { +CommandEncoder_insertDebugSignpost :: #force_inline proc "c" (self: ^CommandEncoder, string: ^NS.String) { msgSend(nil, self, "insertDebugSignpost:", string) } @(objc_type=CommandEncoder, objc_name="label") -CommandEncoder_label :: #force_inline proc(self: ^CommandEncoder) -> ^NS.String { +CommandEncoder_label :: #force_inline proc "c" (self: ^CommandEncoder) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandEncoder, objc_name="popDebugGroup") -CommandEncoder_popDebugGroup :: #force_inline proc(self: ^CommandEncoder) { +CommandEncoder_popDebugGroup :: #force_inline proc "c" (self: ^CommandEncoder) { msgSend(nil, self, "popDebugGroup") } @(objc_type=CommandEncoder, objc_name="pushDebugGroup") -CommandEncoder_pushDebugGroup :: #force_inline proc(self: ^CommandEncoder, string: ^NS.String) { +CommandEncoder_pushDebugGroup :: #force_inline proc "c" (self: ^CommandEncoder, string: ^NS.String) { msgSend(nil, self, "pushDebugGroup:", string) } @(objc_type=CommandEncoder, objc_name="setLabel") -CommandEncoder_setLabel :: #force_inline proc(self: ^CommandEncoder, label: ^NS.String) { +CommandEncoder_setLabel :: #force_inline proc "c" (self: ^CommandEncoder, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6342,31 +6342,31 @@ Methods: CommandQueue :: struct { using _: NS.Object } @(objc_type=CommandQueue, objc_name="commandBuffer") -CommandQueue_commandBuffer :: #force_inline proc(self: ^CommandQueue) -> ^CommandBuffer { +CommandQueue_commandBuffer :: #force_inline proc "c" (self: ^CommandQueue) -> ^CommandBuffer { return msgSend(^CommandBuffer, self, "commandBuffer") } @(objc_type=CommandQueue, objc_name="commandBufferWithDescriptor") -CommandQueue_commandBufferWithDescriptor :: #force_inline proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { +CommandQueue_commandBufferWithDescriptor :: #force_inline proc "c" (self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandBufferWithDescriptor:", descriptor) } @(objc_type=CommandQueue, objc_name="commandBufferWithUnretainedReferences") -CommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc(self: ^CommandQueue) -> ^CommandQueue { +CommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc "c" (self: ^CommandQueue) -> ^CommandQueue { return msgSend(^CommandQueue, self, "commandBufferWithUnretainedReferences") } @(objc_type=CommandQueue, objc_name="device") -CommandQueue_device :: #force_inline proc(self: ^CommandQueue) -> ^Device { +CommandQueue_device :: #force_inline proc "c" (self: ^CommandQueue) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=CommandQueue, objc_name="insertDebugCaptureBoundary") -CommandQueue_insertDebugCaptureBoundary :: #force_inline proc(self: ^CommandQueue) { +CommandQueue_insertDebugCaptureBoundary :: #force_inline proc "c" (self: ^CommandQueue) { msgSend(nil, self, "insertDebugCaptureBoundary") } @(objc_type=CommandQueue, objc_name="label") -CommandQueue_label :: #force_inline proc(self: ^CommandQueue) -> ^NS.String { +CommandQueue_label :: #force_inline proc "c" (self: ^CommandQueue) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CommandQueue, objc_name="setLabel") -CommandQueue_setLabel :: #force_inline proc(self: ^CommandQueue, label: ^NS.String) { +CommandQueue_setLabel :: #force_inline proc "c" (self: ^CommandQueue, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -6417,146 +6417,146 @@ Methods: ComputeCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroups") -ComputeCommandEncoder_dispatchThreadgroups :: #force_inline proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreadgroups :: #force_inline proc "c" (self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroupsWithIndirectBuffer") -ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: #force_inline proc "c" (self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:", indirectBuffer, indirectBufferOffset, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchThreads") -ComputeCommandEncoder_dispatchThreads :: #force_inline proc(self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) { +ComputeCommandEncoder_dispatchThreads :: #force_inline proc "c" (self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "dispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) } @(objc_type=ComputeCommandEncoder, objc_name="dispatchType") -ComputeCommandEncoder_dispatchType :: #force_inline proc(self: ^ComputeCommandEncoder) -> DispatchType { +ComputeCommandEncoder_dispatchType :: #force_inline proc "c" (self: ^ComputeCommandEncoder) -> DispatchType { return msgSend(DispatchType, self, "dispatchType") } @(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer") -ComputeCommandEncoder_executeCommandsInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +ComputeCommandEncoder_executeCommandsInBuffer :: #force_inline proc "c" (self: ^ComputeCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } @(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBufferWithRange") -ComputeCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { +ComputeCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc "c" (self: ^ComputeCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources") -ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: []^Resource) { +ComputeCommandEncoder_memoryBarrierWithResources :: #force_inline proc "c" (self: ^ComputeCommandEncoder, resources: []^Resource) { msgSend(nil, self, "memoryBarrierWithResources:count:", raw_data(resources), NS.UInteger(len(resources))) } @(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope") -ComputeCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^ComputeCommandEncoder, scope: BarrierScope) { +ComputeCommandEncoder_memoryBarrierWithScope :: #force_inline proc "c" (self: ^ComputeCommandEncoder, scope: BarrierScope) { msgSend(nil, self, "memoryBarrierWithScope:", scope) } @(objc_type=ComputeCommandEncoder, objc_name="sampleCountersInBuffer") -ComputeCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { +ComputeCommandEncoder_sampleCountersInBuffer :: #force_inline proc "c" (self: ^ComputeCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=ComputeCommandEncoder, objc_name="setAccelerationStructure") -ComputeCommandEncoder_setAccelerationStructure :: #force_inline proc(self: ^ComputeCommandEncoder, accelerationStructure: ^AccelerationStructure, bufferIndex: NS.UInteger) { +ComputeCommandEncoder_setAccelerationStructure :: #force_inline proc "c" (self: ^ComputeCommandEncoder, accelerationStructure: ^AccelerationStructure, bufferIndex: NS.UInteger) { msgSend(nil, self, "setAccelerationStructure:atBufferIndex:", accelerationStructure, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffer") -ComputeCommandEncoder_setBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +ComputeCommandEncoder_setBuffer :: #force_inline proc "c" (self: ^ComputeCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBufferOffset") -ComputeCommandEncoder_setBufferOffset :: #force_inline proc(self: ^ComputeCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +ComputeCommandEncoder_setBufferOffset :: #force_inline proc "c" (self: ^ComputeCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBufferOffset:atIndex:", offset, index) } @(objc_type=ComputeCommandEncoder, objc_name="setBuffers") -ComputeCommandEncoder_setBuffers :: #force_inline proc(self: ^ComputeCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +ComputeCommandEncoder_setBuffers :: #force_inline proc "odin" (self: ^ComputeCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { assert(len(buffers) == len(offsets)) assert(range.length <= NS.UInteger(len(buffers))) msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=ComputeCommandEncoder, objc_name="setBytes") -ComputeCommandEncoder_setBytes :: #force_inline proc(self: ^ComputeCommandEncoder, bytes: []byte, index: NS.UInteger) { +ComputeCommandEncoder_setBytes :: #force_inline proc "c" (self: ^ComputeCommandEncoder, bytes: []byte, index: NS.UInteger) { msgSend(nil, self, "setBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState") -ComputeCommandEncoder_setComputePipelineState :: #force_inline proc(self: ^ComputeCommandEncoder, pipelineState: ^ComputePipelineState) { +ComputeCommandEncoder_setComputePipelineState :: #force_inline proc "c" (self: ^ComputeCommandEncoder, pipelineState: ^ComputePipelineState) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=ComputeCommandEncoder, objc_name="setImageblockWidth") -ComputeCommandEncoder_setImageblockWidth :: #force_inline proc(self: ^ComputeCommandEncoder, width: NS.UInteger, height: NS.UInteger) { +ComputeCommandEncoder_setImageblockWidth :: #force_inline proc "c" (self: ^ComputeCommandEncoder, width: NS.UInteger, height: NS.UInteger) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTable") -ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, bufferIndex: NS.UInteger) { +ComputeCommandEncoder_setIntersectionFunctionTable :: #force_inline proc "c" (self: ^ComputeCommandEncoder, intersectionFunctionTable: ^IntersectionFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables") -ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { +ComputeCommandEncoder_setIntersectionFunctionTables :: #force_inline proc "odin" (self: ^ComputeCommandEncoder, intersectionFunctionTables: []^IntersectionFunctionTable, range: NS.Range) { assert(range.length <= NS.UInteger(len(intersectionFunctionTables))) msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", raw_data(intersectionFunctionTables), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerState") -ComputeCommandEncoder_setSamplerState :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +ComputeCommandEncoder_setSamplerState :: #force_inline proc "c" (self: ^ComputeCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:atIndex:", sampler, index) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStateWithLod") -ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp :: #force_inline proc(self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp :: #force_inline proc "c" (self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithLod") -ComputeCommandEncoder_setSamplerStatesWithLod :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { +ComputeCommandEncoder_setSamplerStatesWithLod :: #force_inline proc "c" (self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=ComputeCommandEncoder, objc_name="setSamplerStatesWithRange") -ComputeCommandEncoder_setSamplerStatesWithRange :: #force_inline proc(self: ^ComputeCommandEncoder, samplers: []^SamplerState, range: NS.Range) { +ComputeCommandEncoder_setSamplerStatesWithRange :: #force_inline proc "c" (self: ^ComputeCommandEncoder, samplers: []^SamplerState, range: NS.Range) { msgSend(nil, self, "setSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion") -ComputeCommandEncoder_setStageInRegion :: #force_inline proc(self: ^ComputeCommandEncoder, region: Region) { +ComputeCommandEncoder_setStageInRegion :: #force_inline proc "c" (self: ^ComputeCommandEncoder, region: Region) { msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=ComputeCommandEncoder, objc_name="setStageInRegionWithIndirectBuffer") -ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: #force_inline proc(self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: #force_inline proc "c" (self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "setStageInRegionWithIndirectBuffer:indirectBufferOffset:", indirectBuffer, indirectBufferOffset) } @(objc_type=ComputeCommandEncoder, objc_name="setTexture") -ComputeCommandEncoder_setTexture :: #force_inline proc(self: ^ComputeCommandEncoder, texture: ^Texture, index: NS.UInteger) { +ComputeCommandEncoder_setTexture :: #force_inline proc "c" (self: ^ComputeCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTexture:atIndex:", texture, index) } @(objc_type=ComputeCommandEncoder, objc_name="setTextures") -ComputeCommandEncoder_setTextures :: #force_inline proc(self: ^ComputeCommandEncoder, textures: []^Texture, range: NS.Range) { +ComputeCommandEncoder_setTextures :: #force_inline proc "c" (self: ^ComputeCommandEncoder, textures: []^Texture, range: NS.Range) { msgSend(nil, self, "setTextures:withRange:", raw_data(textures), range) } @(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength") -ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^ComputeCommandEncoder, length: NS.UInteger, index: NS.UInteger) { +ComputeCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc "c" (self: ^ComputeCommandEncoder, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTable") -ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { +ComputeCommandEncoder_setVisibleFunctionTable :: #force_inline proc "c" (self: ^ComputeCommandEncoder, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables") -ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc(self: ^ComputeCommandEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { +ComputeCommandEncoder_setVisibleFunctionTables :: #force_inline proc "c" (self: ^ComputeCommandEncoder, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", raw_data(visibleFunctionTables), range) } @(objc_type=ComputeCommandEncoder, objc_name="updateFence") -ComputeCommandEncoder_updateFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { +ComputeCommandEncoder_updateFence :: #force_inline proc "c" (self: ^ComputeCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ComputeCommandEncoder, objc_name="useHeap") -ComputeCommandEncoder_useHeap :: #force_inline proc(self: ^ComputeCommandEncoder, heap: ^Heap) { +ComputeCommandEncoder_useHeap :: #force_inline proc "c" (self: ^ComputeCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=ComputeCommandEncoder, objc_name="useHeaps") -ComputeCommandEncoder_useHeaps :: #force_inline proc(self: ^ComputeCommandEncoder, heaps: []^Heap) { +ComputeCommandEncoder_useHeaps :: #force_inline proc "c" (self: ^ComputeCommandEncoder, heaps: []^Heap) { msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=ComputeCommandEncoder, objc_name="useResource") -ComputeCommandEncoder_useResource :: #force_inline proc(self: ^ComputeCommandEncoder, resource: ^Resource, usage: ResourceUsage) { +ComputeCommandEncoder_useResource :: #force_inline proc "c" (self: ^ComputeCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=ComputeCommandEncoder, objc_name="useResources") -ComputeCommandEncoder_useResources :: #force_inline proc(self: ^ComputeCommandEncoder, resources: []^Resource, usage: ResourceUsage) { +ComputeCommandEncoder_useResources :: #force_inline proc "c" (self: ^ComputeCommandEncoder, resources: []^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", raw_data(resources), NS.UInteger(len(resources)), usage) } @(objc_type=ComputeCommandEncoder, objc_name="waitForFence") -ComputeCommandEncoder_waitForFence :: #force_inline proc(self: ^ComputeCommandEncoder, fence: ^Fence) { +ComputeCommandEncoder_waitForFence :: #force_inline proc "c" (self: ^ComputeCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @@ -6583,48 +6583,48 @@ Methods: ComputePipelineState :: struct { using _: NS.Object } @(objc_type=ComputePipelineState, objc_name="device") -ComputePipelineState_device :: #force_inline proc(self: ^ComputePipelineState) -> ^Device { +ComputePipelineState_device :: #force_inline proc "c" (self: ^ComputePipelineState) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction") -ComputePipelineState_functionHandleWithFunction :: #force_inline proc(self: ^ComputePipelineState, function: ^Function) -> ^FunctionHandle { +ComputePipelineState_functionHandleWithFunction :: #force_inline proc "c" (self: ^ComputePipelineState, function: ^Function) -> ^FunctionHandle { return msgSend(^FunctionHandle, self, "functionHandleWithFunction:", function) } @(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions") -ComputePipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { +ComputePipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc "c" (self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=ComputePipelineState, objc_name="label") -ComputePipelineState_label :: #force_inline proc(self: ^ComputePipelineState) -> ^NS.String { +ComputePipelineState_label :: #force_inline proc "c" (self: ^ComputePipelineState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=ComputePipelineState, objc_name="maxTotalThreadsPerThreadgroup") -ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { +ComputePipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^ComputePipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=ComputePipelineState, objc_name="newComputePipelineState") -ComputePipelineState_newComputePipelineState :: #force_inline proc(self: ^ComputePipelineState, functions: ^NS.Array) -> (state: ^ComputePipelineState, error: ^NS.Error) { +ComputePipelineState_newComputePipelineState :: #force_inline proc "contextless" (self: ^ComputePipelineState, functions: ^NS.Array) -> (state: ^ComputePipelineState, error: ^NS.Error) { state = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, &error) return } @(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTable") -ComputePipelineState_newIntersectionFunctionTable :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTable { +ComputePipelineState_newIntersectionFunctionTable :: #force_inline proc "c" (self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTable { return msgSend(^IntersectionFunctionTable, self, "newIntersectionFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTable") -ComputePipelineState_newVisibleFunctionTable :: #force_inline proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTable { +ComputePipelineState_newVisibleFunctionTable :: #force_inline proc "c" (self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTable { return msgSend(^VisibleFunctionTable, self, "newVisibleFunctionTableWithDescriptor:", descriptor) } @(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength") -ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { +ComputePipelineState_staticThreadgroupMemoryLength :: #force_inline proc "c" (self: ^ComputePipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "staticThreadgroupMemoryLength") } @(objc_type=ComputePipelineState, objc_name="supportIndirectCommandBuffers") -ComputePipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^ComputePipelineState) -> BOOL { +ComputePipelineState_supportIndirectCommandBuffers :: #force_inline proc "c" (self: ^ComputePipelineState) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=ComputePipelineState, objc_name="threadExecutionWidth") -ComputePipelineState_threadExecutionWidth :: #force_inline proc(self: ^ComputePipelineState) -> NS.UInteger { +ComputePipelineState_threadExecutionWidth :: #force_inline proc "c" (self: ^ComputePipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "threadExecutionWidth") } @@ -6641,7 +6641,7 @@ Methods: Counter :: struct { using _: NS.Object } @(objc_type=Counter, objc_name="name") -Counter_name :: #force_inline proc(self: ^Counter) -> ^NS.String { +Counter_name :: #force_inline proc "c" (self: ^Counter) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -6661,19 +6661,19 @@ Methods: CounterSampleBuffer :: struct { using _: NS.Object } @(objc_type=CounterSampleBuffer, objc_name="device") -CounterSampleBuffer_device :: #force_inline proc(self: ^CounterSampleBuffer) -> ^Device { +CounterSampleBuffer_device :: #force_inline proc "c" (self: ^CounterSampleBuffer) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=CounterSampleBuffer, objc_name="label") -CounterSampleBuffer_label :: #force_inline proc(self: ^CounterSampleBuffer) -> ^NS.String { +CounterSampleBuffer_label :: #force_inline proc "c" (self: ^CounterSampleBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=CounterSampleBuffer, objc_name="resolveCounterRange") -CounterSampleBuffer_resolveCounterRange :: #force_inline proc(self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data { +CounterSampleBuffer_resolveCounterRange :: #force_inline proc "c" (self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data { return msgSend(^NS.Data, self, "resolveCounterRange:", range) } @(objc_type=CounterSampleBuffer, objc_name="sampleCount") -CounterSampleBuffer_sampleCount :: #force_inline proc(self: ^CounterSampleBuffer) -> NS.UInteger { +CounterSampleBuffer_sampleCount :: #force_inline proc "c" (self: ^CounterSampleBuffer) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @@ -6691,11 +6691,11 @@ Methods: CounterSet :: struct { using _: NS.Object } @(objc_type=CounterSet, objc_name="counters") -CounterSet_counters :: #force_inline proc(self: ^CounterSet) -> ^NS.Array { +CounterSet_counters :: #force_inline proc "c" (self: ^CounterSet) -> ^NS.Array { return msgSend(^NS.Array, self, "counters") } @(objc_type=CounterSet, objc_name="name") -CounterSet_name :: #force_inline proc(self: ^CounterSet) -> ^NS.String { +CounterSet_name :: #force_inline proc "c" (self: ^CounterSet) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -6713,11 +6713,11 @@ Methods: DepthStencilState :: struct { using _: NS.Object } @(objc_type=DepthStencilState, objc_name="device") -DepthStencilState_device :: #force_inline proc(self: ^DepthStencilState) -> ^Device { +DepthStencilState_device :: #force_inline proc "c" (self: ^DepthStencilState) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=DepthStencilState, objc_name="label") -DepthStencilState_label :: #force_inline proc(self: ^DepthStencilState) -> ^NS.String { +DepthStencilState_label :: #force_inline proc "c" (self: ^DepthStencilState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @@ -6828,150 +6828,150 @@ Methods: Device :: struct { using _: NS.Object } @(objc_type=Device, objc_name="accelerationStructureSizesWithDescriptor") -Device_accelerationStructureSizesWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes { +Device_accelerationStructureSizesWithDescriptor :: #force_inline proc "c" (self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes { return msgSend(AccelerationStructureSizes, self, "accelerationStructureSizesWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="areBarycentricCoordsSupported") -Device_areBarycentricCoordsSupported :: #force_inline proc(self: ^Device) -> BOOL { +Device_areBarycentricCoordsSupported :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "areBarycentricCoordsSupported") } @(objc_type=Device, objc_name="areProgrammableSamplePositionsSupported") -Device_areProgrammableSamplePositionsSupported :: #force_inline proc(self: ^Device) -> BOOL { +Device_areProgrammableSamplePositionsSupported :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "areProgrammableSamplePositionsSupported") } @(objc_type=Device, objc_name="areRasterOrderGroupsSupported") -Device_areRasterOrderGroupsSupported :: #force_inline proc(self: ^Device) -> BOOL { +Device_areRasterOrderGroupsSupported :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "areRasterOrderGroupsSupported") } @(objc_type=Device, objc_name="argumentBuffersSupport") -Device_argumentBuffersSupport :: #force_inline proc(self: ^Device) -> ArgumentBuffersTier { +Device_argumentBuffersSupport :: #force_inline proc "c" (self: ^Device) -> ArgumentBuffersTier { return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport") } @(objc_type=Device, objc_name="convertSparsePixelRegions") -Device_convertSparsePixelRegions :: #force_inline proc(self: ^Device, pixelRegions, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: NS.UInteger) { +Device_convertSparsePixelRegions :: #force_inline proc "c" (self: ^Device, pixelRegions, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions) } @(objc_type=Device, objc_name="convertSparseTileRegions") -Device_convertSparseTileRegions :: #force_inline proc(self: ^Device, tileRegions, pixelRegions: ^Region, tileSize: Size, numRegions: NS.UInteger) { +Device_convertSparseTileRegions :: #force_inline proc "c" (self: ^Device, tileRegions, pixelRegions: ^Region, tileSize: Size, numRegions: NS.UInteger) { msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions) } @(objc_type=Device, objc_name="counterSets") -Device_counterSets :: #force_inline proc(self: ^Device) -> ^NS.Array { +Device_counterSets :: #force_inline proc "c" (self: ^Device) -> ^NS.Array { return msgSend(^NS.Array, self, "counterSets") } @(objc_type=Device, objc_name="currentAllocatedSize") -Device_currentAllocatedSize :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_currentAllocatedSize :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Device, objc_name="getDefaultSamplePositions") -Device_getDefaultSamplePositions :: #force_inline proc(self: ^Device, positions: []SamplePosition) { +Device_getDefaultSamplePositions :: #force_inline proc "c" (self: ^Device, positions: []SamplePosition) { msgSend(nil, self, "getDefaultSamplePositions:count:", raw_data(positions), NS.UInteger(len(positions))) } @(objc_type=Device, objc_name="hasUnifiedMemory") -Device_hasUnifiedMemory :: #force_inline proc(self: ^Device) -> BOOL { +Device_hasUnifiedMemory :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "hasUnifiedMemory") } @(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength") -Device_heapBufferSizeAndAlignWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> (size, align: NS.UInteger) { +Device_heapBufferSizeAndAlignWithLength :: #force_inline proc "c" (self: ^Device, length: NS.UInteger, options: ResourceOptions) -> (size, align: NS.UInteger) { res := msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options) return res.size, res.align } @(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor") -Device_heapTextureSizeAndAlignWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> (size, align: NS.UInteger) { +Device_heapTextureSizeAndAlignWithDescriptor :: #force_inline proc "c" (self: ^Device, desc: ^TextureDescriptor) -> (size, align: NS.UInteger) { res := msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc) return res.size, res.align } @(objc_type=Device, objc_name="isDepth24Stencil8PixelFormatSupported") -Device_isDepth24Stencil8PixelFormatSupported :: #force_inline proc(self: ^Device) -> BOOL { +Device_isDepth24Stencil8PixelFormatSupported :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "isDepth24Stencil8PixelFormatSupported") } @(objc_type=Device, objc_name="isHeadless") -Device_isHeadless :: #force_inline proc(self: ^Device) -> BOOL { +Device_isHeadless :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "isHeadless") } @(objc_type=Device, objc_name="isLowPower") -Device_isLowPower :: #force_inline proc(self: ^Device) -> BOOL { +Device_isLowPower :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "isLowPower") } @(objc_type=Device, objc_name="isRemovable") -Device_isRemovable :: #force_inline proc(self: ^Device) -> BOOL { +Device_isRemovable :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "isRemovable") } @(objc_type=Device, objc_name="location") -Device_location :: #force_inline proc(self: ^Device) -> DeviceLocation { +Device_location :: #force_inline proc "c" (self: ^Device) -> DeviceLocation { return msgSend(DeviceLocation, self, "location") } @(objc_type=Device, objc_name="locationNumber") -Device_locationNumber :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_locationNumber :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "locationNumber") } @(objc_type=Device, objc_name="maxArgumentBufferSamplerCount") -Device_maxArgumentBufferSamplerCount :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_maxArgumentBufferSamplerCount :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxArgumentBufferSamplerCount") } @(objc_type=Device, objc_name="maxBufferLength") -Device_maxBufferLength :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_maxBufferLength :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxBufferLength") } @(objc_type=Device, objc_name="maxThreadgroupMemoryLength") -Device_maxThreadgroupMemoryLength :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_maxThreadgroupMemoryLength :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxThreadgroupMemoryLength") } @(objc_type=Device, objc_name="maxThreadsPerThreadgroup") -Device_maxThreadsPerThreadgroup :: #force_inline proc(self: ^Device) -> Size { +Device_maxThreadsPerThreadgroup :: #force_inline proc "c" (self: ^Device) -> Size { return msgSend(Size, self, "maxThreadsPerThreadgroup") } @(objc_type=Device, objc_name="maxTransferRate") -Device_maxTransferRate :: #force_inline proc(self: ^Device) -> u64 { +Device_maxTransferRate :: #force_inline proc "c" (self: ^Device) -> u64 { return msgSend(u64, self, "maxTransferRate") } @(objc_type=Device, objc_name="minimumLinearTextureAlignmentForPixelFormat") -Device_minimumLinearTextureAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> NS.UInteger { +Device_minimumLinearTextureAlignmentForPixelFormat :: #force_inline proc "c" (self: ^Device, format: PixelFormat) -> NS.UInteger { return msgSend(NS.UInteger, self, "minimumLinearTextureAlignmentForPixelFormat:", format) } @(objc_type=Device, objc_name="minimumTextureBufferAlignmentForPixelFormat") -Device_minimumTextureBufferAlignmentForPixelFormat :: #force_inline proc(self: ^Device, format: PixelFormat) -> NS.UInteger { +Device_minimumTextureBufferAlignmentForPixelFormat :: #force_inline proc "c" (self: ^Device, format: PixelFormat) -> NS.UInteger { return msgSend(NS.UInteger, self, "minimumTextureBufferAlignmentForPixelFormat:", format) } @(objc_type=Device, objc_name="name") -Device_name :: #force_inline proc(self: ^Device) -> ^NS.String { +Device_name :: #force_inline proc "c" (self: ^Device) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Device, objc_name="newAccelerationStructureWithDescriptor") -Device_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^AccelerationStructure { +Device_newAccelerationStructureWithDescriptor :: #force_inline proc "c" (self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newAccelerationStructureWithSize") -Device_newAccelerationStructureWithSize :: #force_inline proc(self: ^Device, size: NS.UInteger) -> ^AccelerationStructure { +Device_newAccelerationStructureWithSize :: #force_inline proc "c" (self: ^Device, size: NS.UInteger) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithSize:", size) } @(objc_type=Device, objc_name="newArgumentEncoderWithArguments") -Device_newArgumentEncoderWithArguments :: #force_inline proc(self: ^Device, arguments: ^NS.Array) -> ^ArgumentEncoder { +Device_newArgumentEncoderWithArguments :: #force_inline proc "c" (self: ^Device, arguments: ^NS.Array) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithArguments:", arguments) } @(objc_type=Device, objc_name="newBinaryArchive") -Device_newBinaryArchive :: #force_inline proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (res: ^BinaryArchive, error: ^NS.Error) { +Device_newBinaryArchive :: #force_inline proc "contextless" (self: ^Device, descriptor: ^BinaryArchiveDescriptor) -> (res: ^BinaryArchive, error: ^NS.Error) { res = msgSend(^BinaryArchive, self, "newBinaryArchiveWithDescriptor:error:", descriptor, &error) return } @(objc_type=Device, objc_name="newBufferWithBytes") -Device_newBufferWithBytes :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions) -> ^Buffer { +Device_newBufferWithBytes :: #force_inline proc "c" (self: ^Device, bytes: []byte, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithBytes:length:options:", raw_data(bytes), NS.UInteger(len(bytes)), options) } @(objc_type=Device, objc_name="newBufferWithBytesNoCopy") -Device_newBufferWithBytesNoCopy :: #force_inline proc(self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { +Device_newBufferWithBytesNoCopy :: #force_inline proc "c" (self: ^Device, bytes: []byte, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithBytesNoCopy:length:options:deallocator:", raw_data(bytes), NS.UInteger(len(bytes)), options, deallocator) } @(objc_type=Device, objc_name="newBufferWithSlice") -Device_newBufferWithSlice :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions) -> ^Buffer { +Device_newBufferWithSlice :: #force_inline proc "c" (self: ^Device, slice: $S/[]$E, options: ResourceOptions) -> ^Buffer { return Device_newBufferWithBytes(self, mem.slice_to_bytes(slice), options) } @(objc_type=Device, objc_name="newBufferWithSliceNoCopy") -Device_newBufferWithSliceNoCopy :: #force_inline proc(self: ^Device, slice: $S/[]$E, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { +Device_newBufferWithSliceNoCopy :: #force_inline proc "c" (self: ^Device, slice: $S/[]$E, options: ResourceOptions, deallocator: rawptr) -> ^Buffer { return Device_newBufferWithBytesNotCopy(self, mem.slice_to_bytes(slice), options, deallocator) } @(objc_type=Device, objc_name="newBufferWithLength") -Device_newBufferWithLength :: #force_inline proc(self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { +Device_newBufferWithLength :: #force_inline proc "c" (self: ^Device, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) } @@ -6985,37 +6985,37 @@ Device_newBuffer :: proc{ } @(objc_type=Device, objc_name="newCommandQueue") -Device_newCommandQueue :: #force_inline proc(self: ^Device) -> ^CommandQueue { +Device_newCommandQueue :: #force_inline proc "c" (self: ^Device) -> ^CommandQueue { return msgSend(^CommandQueue, self, "newCommandQueue") } @(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount") -Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc(self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^CommandQueue { +Device_newCommandQueueWithMaxCommandBufferCount :: #force_inline proc "c" (self: ^Device, maxCommandBufferCount: NS.UInteger) -> ^CommandQueue { return msgSend(^CommandQueue, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptorWithCompletionHandler") -Device_newComputePipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> ^ComputePipelineState { +Device_newComputePipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc "c" (self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithDescriptorWithReflection") -Device_newComputePipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) { +Device_newComputePipelineStateWithDescriptorWithReflection :: #force_inline proc "contextless" (self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) { res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithCompletionHandler") -Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) -> ^ComputePipelineState { +Device_newComputePipelineStateWithFunctionWithCompletionHandler :: #force_inline proc "c" (self: ^Device, computeFunction: ^Function, completionHandler: NewComputePipelineStateCompletionHandler) -> ^ComputePipelineState { return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunction") -Device_newComputePipelineStateWithFunction :: #force_inline proc(self: ^Device, computeFunction: ^Function) -> (res: ^ComputePipelineState, error: ^NS.Error) { +Device_newComputePipelineStateWithFunction :: #force_inline proc "contextless" (self: ^Device, computeFunction: ^Function) -> (res: ^ComputePipelineState, error: ^NS.Error) { res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:error:", computeFunction, &error) return } @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler") -Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> (res: ^ComputePipelineState) { +Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler :: #force_inline proc "c" (self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) -> (res: ^ComputePipelineState) { return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler) } @(objc_type=Device, objc_name="newComputePipelineStateWithFunctionWithReflection") -Device_newComputePipelineStateWithFunctionWithReflection :: #force_inline proc(self: ^Device, computeFunction: ^Function, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) { +Device_newComputePipelineStateWithFunctionWithReflection :: #force_inline proc "contextless" (self: ^Device, computeFunction: ^Function, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection) -> (res: ^ComputePipelineState, error: ^NS.Error) { res = msgSend(^ComputePipelineState, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, &error) return } @@ -7031,71 +7031,71 @@ Device_newComputePipelineState :: proc{ } @(objc_type=Device, objc_name="newCounterSampleBuffer") -Device_newCounterSampleBuffer :: #force_inline proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (counter: ^Counter, error: ^NS.Error) { +Device_newCounterSampleBuffer :: #force_inline proc "contextless" (self: ^Device, descriptor: ^CounterSampleBufferDescriptor) -> (counter: ^Counter, error: ^NS.Error) { counter = msgSend(^Counter, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, &error) return } @(objc_type=Device, objc_name="newDefaultLibrary") -Device_newDefaultLibrary :: #force_inline proc(self: ^Device) -> ^Library { +Device_newDefaultLibrary :: #force_inline proc "c" (self: ^Device) -> ^Library { return msgSend(^Library, self, "newDefaultLibrary") } @(objc_type=Device, objc_name="newDefaultLibraryWithBundle") -Device_newDefaultLibraryWithBundle :: #force_inline proc(self: ^Device, bundle: ^NS.Bundle) -> (library: ^Library, error: ^NS.Error) { +Device_newDefaultLibraryWithBundle :: #force_inline proc "contextless" (self: ^Device, bundle: ^NS.Bundle) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newDefaultLibraryWithBundle:error:", bundle, &error) return } @(objc_type=Device, objc_name="newDepthStencilState") -Device_newDepthStencilState :: #force_inline proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^DepthStencilState { +Device_newDepthStencilState :: #force_inline proc "c" (self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^DepthStencilState { return msgSend(^DepthStencilState, self, "newDepthStencilStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newDynamicLibrary") -Device_newDynamicLibrary :: #force_inline proc(self: ^Device, library: ^Library) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { +Device_newDynamicLibrary :: #force_inline proc "contextless" (self: ^Device, library: ^Library) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { dyn_library = msgSend(^DynamicLibrary, self, "newDynamicLibrary:error:", library, &error) return } @(objc_type=Device, objc_name="newDynamicLibraryWithURL") -Device_newDynamicLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { +Device_newDynamicLibraryWithURL :: #force_inline proc "contextless" (self: ^Device, url: ^NS.URL) -> (dyn_library: ^DynamicLibrary, error: ^NS.Error) { dyn_library = msgSend(^DynamicLibrary, self, "newDynamicLibraryWithURL:error:", url, &error) return } @(objc_type=Device, objc_name="newEvent") -Device_newEvent :: #force_inline proc(self: ^Device) -> ^Event { +Device_newEvent :: #force_inline proc "c" (self: ^Device) -> ^Event { return msgSend(^Event, self, "newEvent") } @(objc_type=Device, objc_name="newFence") -Device_newFence :: #force_inline proc(self: ^Device) -> ^Fence { +Device_newFence :: #force_inline proc "c" (self: ^Device) -> ^Fence { return msgSend(^Fence, self, "newFence") } @(objc_type=Device, objc_name="newHeap") -Device_newHeap :: #force_inline proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Heap { +Device_newHeap :: #force_inline proc "c" (self: ^Device, descriptor: ^HeapDescriptor) -> ^Heap { return msgSend(^Heap, self, "newHeapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newIndirectCommandBuffer") -Device_newIndirectCommandBuffer :: #force_inline proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^IndirectCommandBuffer { +Device_newIndirectCommandBuffer :: #force_inline proc "c" (self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: NS.UInteger, options: ResourceOptions) -> ^IndirectCommandBuffer { return msgSend(^IndirectCommandBuffer, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options) } @(objc_type=Device, objc_name="newLibraryWithData") -Device_newLibraryWithData :: #force_inline proc(self: ^Device, data: dispatch_data_t) -> (library: ^Library, error: ^NS.Error) { +Device_newLibraryWithData :: #force_inline proc "contextless" (self: ^Device, data: dispatch_data_t) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newLibraryWithData:error:", data, &error) return } @(objc_type=Device, objc_name="newLibraryWithFile") -Device_newLibraryWithFile :: #force_inline proc(self: ^Device, filepath: ^NS.String) -> (library: ^Library, error: ^NS.Error) { +Device_newLibraryWithFile :: #force_inline proc "contextless" (self: ^Device, filepath: ^NS.String) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newLibraryWithFile:error:", filepath, &error) return } @(objc_type=Device, objc_name="newLibraryWithSourceWithCompletionHandler") -Device_newLibraryWithSourceWithCompletionHandler :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) -> ^Library { +Device_newLibraryWithSourceWithCompletionHandler :: #force_inline proc "c" (self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) -> ^Library { return msgSend(^Library, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler) } @(objc_type=Device, objc_name="newLibraryWithSource") -Device_newLibraryWithSource :: #force_inline proc(self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (library: ^Library, error: ^NS.Error) { +Device_newLibraryWithSource :: #force_inline proc "contextless" (self: ^Device, source: ^NS.String, options: ^CompileOptions) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newLibraryWithSource:options:error:", source, options, &error) return } @(objc_type=Device, objc_name="newLibraryWithURL") -Device_newLibraryWithURL :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (library: ^Library, error: ^NS.Error) { +Device_newLibraryWithURL :: #force_inline proc "contextless" (self: ^Device, url: ^NS.URL) -> (library: ^Library, error: ^NS.Error) { library = msgSend(^Library, self, "newLibraryWithURL:error:", url, &error) return } @@ -7110,34 +7110,34 @@ Device_newLibrary :: proc{ @(objc_type=Device, objc_name="newRasterizationRateMap") -Device_newRasterizationRateMap :: #force_inline proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMap { +Device_newRasterizationRateMap :: #force_inline proc "c" (self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMap { return msgSend(^RasterizationRateMap, self, "newRasterizationRateMapWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithCompletionHandler") -Device_newRenderPipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) -> ^RenderPipelineState { +Device_newRenderPipelineStateWithDescriptorWithCompletionHandler :: #force_inline proc "c" (self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) -> ^RenderPipelineState { return msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor") -Device_newRenderPipelineStateWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { +Device_newRenderPipelineStateWithDescriptor :: #force_inline proc "contextless" (self: ^Device, descriptor: ^RenderPipelineDescriptor) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, &error) return } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler") -Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) -> ^RenderPipelineState { +Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler :: #force_inline proc "c" (self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) -> ^RenderPipelineState { return msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptorWithReflection") -Device_newRenderPipelineStateWithDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { +Device_newRenderPipelineStateWithDescriptorWithReflection :: #force_inline proc "contextless" (self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithCompletionHandler") -Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) -> ^RenderPipelineState { +Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler :: #force_inline proc "c" (self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) -> ^RenderPipelineState { return msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler) } @(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptorWithReflection") -Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { +Device_newRenderPipelineStateWithTileDescriptorWithReflection :: #force_inline proc "contextless" (self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (pipeline: ^RenderPipelineState, error: ^NS.Error) { pipeline = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, &error) return } @@ -7153,23 +7153,23 @@ Device_newRenderPipelineState :: proc{ @(objc_type=Device, objc_name="newSamplerState") -Device_newSamplerState :: #force_inline proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState { +Device_newSamplerState :: #force_inline proc "c" (self: ^Device, descriptor: ^SamplerDescriptor) -> ^SamplerState { return msgSend(^SamplerState, self, "newSamplerStateWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newSharedEvent") -Device_newSharedEvent :: #force_inline proc(self: ^Device) -> ^SharedEvent { +Device_newSharedEvent :: #force_inline proc "c" (self: ^Device) -> ^SharedEvent { return msgSend(^SharedEvent, self, "newSharedEvent") } @(objc_type=Device, objc_name="newSharedEventWithHandle") -Device_newSharedEventWithHandle :: #force_inline proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^SharedEvent { +Device_newSharedEventWithHandle :: #force_inline proc "c" (self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^SharedEvent { return msgSend(^SharedEvent, self, "newSharedEventWithHandle:", sharedEventHandle) } @(objc_type=Device, objc_name="newSharedTextureWithDescriptor") -Device_newSharedTextureWithDescriptor :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^SharedEvent { +Device_newSharedTextureWithDescriptor :: #force_inline proc "c" (self: ^Device, descriptor: ^TextureDescriptor) -> ^SharedEvent { return msgSend(^SharedEvent, self, "newSharedTextureWithDescriptor:", descriptor) } @(objc_type=Device, objc_name="newSharedTextureWithHandle") -Device_newSharedTextureWithHandle :: #force_inline proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^SharedEvent { +Device_newSharedTextureWithHandle :: #force_inline proc "c" (self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^SharedEvent { return msgSend(^SharedEvent, self, "newSharedTextureWithHandle:", sharedHandle) } @(objc_type=Device, objc_name="newSharedTexture") @@ -7179,11 +7179,11 @@ Device_newSharedTexture :: proc{ } @(objc_type=Device, objc_name="newTextureWithDescriptor") -Device_newTextureWithDescriptor :: #force_inline proc(self: ^Device, desc: ^TextureDescriptor) -> ^Texture { +Device_newTextureWithDescriptor :: #force_inline proc "c" (self: ^Device, desc: ^TextureDescriptor) -> ^Texture { return msgSend(^Texture, self, "newTextureWithDescriptor:", desc) } @(objc_type=Device, objc_name="newTextureWithIOSurface") -Device_newTextureWithIOSurface :: #force_inline proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Texture { +Device_newTextureWithIOSurface :: #force_inline proc "c" (self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: NS.UInteger) -> ^Texture { return msgSend(^Texture, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane) } @(objc_type=Device, objc_name="newTexture") @@ -7193,126 +7193,126 @@ Device_newTexture :: proc{ } @(objc_type=Device, objc_name="peerCount") -Device_peerCount :: #force_inline proc(self: ^Device) -> u32 { +Device_peerCount :: #force_inline proc "c" (self: ^Device) -> u32 { return msgSend(u32, self, "peerCount") } @(objc_type=Device, objc_name="peerGroupID") -Device_peerGroupID :: #force_inline proc(self: ^Device) -> u64 { +Device_peerGroupID :: #force_inline proc "c" (self: ^Device) -> u64 { return msgSend(u64, self, "peerGroupID") } @(objc_type=Device, objc_name="peerIndex") -Device_peerIndex :: #force_inline proc(self: ^Device) -> u32 { +Device_peerIndex :: #force_inline proc "c" (self: ^Device) -> u32 { return msgSend(u32, self, "peerIndex") } @(objc_type=Device, objc_name="readWriteTextureSupport") -Device_readWriteTextureSupport :: #force_inline proc(self: ^Device) -> ReadWriteTextureTier { +Device_readWriteTextureSupport :: #force_inline proc "c" (self: ^Device) -> ReadWriteTextureTier { return msgSend(ReadWriteTextureTier, self, "readWriteTextureSupport") } @(objc_type=Device, objc_name="recommendedMaxWorkingSetSize") -Device_recommendedMaxWorkingSetSize :: #force_inline proc(self: ^Device) -> u64 { +Device_recommendedMaxWorkingSetSize :: #force_inline proc "c" (self: ^Device) -> u64 { return msgSend(u64, self, "recommendedMaxWorkingSetSize") } @(objc_type=Device, objc_name="registryID") -Device_registryID :: #force_inline proc(self: ^Device) -> u64 { +Device_registryID :: #force_inline proc "c" (self: ^Device) -> u64 { return msgSend(u64, self, "registryID") } @(objc_type=Device, objc_name="sampleTimestamps") -Device_sampleTimestamps :: #force_inline proc(self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) { +Device_sampleTimestamps :: #force_inline proc "c" (self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) { msgSend(nil, self, "sampleTimestamps:gpuTimestamp:", cpuTimestamp, gpuTimestamp) } @(objc_type=Device, objc_name="sparseTileSizeInBytes") -Device_sparseTileSizeInBytes :: #force_inline proc(self: ^Device) -> NS.UInteger { +Device_sparseTileSizeInBytes :: #force_inline proc "c" (self: ^Device) -> NS.UInteger { return msgSend(NS.UInteger, self, "sparseTileSizeInBytes") } @(objc_type=Device, objc_name="sparseTileSizeWithTextureType") -Device_sparseTileSizeWithTextureType :: #force_inline proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: NS.UInteger) -> Size { +Device_sparseTileSizeWithTextureType :: #force_inline proc "c" (self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: NS.UInteger) -> Size { return msgSend(Size, self, "sparseTileSizeWithTextureType:pixelFormat:sampleCount:", textureType, pixelFormat, sampleCount) } @(objc_type=Device, objc_name="supports32BitFloatFiltering") -Device_supports32BitFloatFiltering :: #force_inline proc(self: ^Device) -> BOOL { +Device_supports32BitFloatFiltering :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supports32BitFloatFiltering") } @(objc_type=Device, objc_name="supports32BitMSAA") -Device_supports32BitMSAA :: #force_inline proc(self: ^Device) -> BOOL { +Device_supports32BitMSAA :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supports32BitMSAA") } @(objc_type=Device, objc_name="supportsBCTextureCompression") -Device_supportsBCTextureCompression :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsBCTextureCompression :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsBCTextureCompression") } @(objc_type=Device, objc_name="supportsCounterSampling") -Device_supportsCounterSampling :: #force_inline proc(self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL { +Device_supportsCounterSampling :: #force_inline proc "c" (self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL { return msgSend(BOOL, self, "supportsCounterSampling:", samplingPoint) } @(objc_type=Device, objc_name="supportsDynamicLibraries") -Device_supportsDynamicLibraries :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsDynamicLibraries :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsDynamicLibraries") } @(objc_type=Device, objc_name="supportsFamily") -Device_supportsFamily :: #force_inline proc(self: ^Device, gpuFamily: GPUFamily) -> BOOL { +Device_supportsFamily :: #force_inline proc "c" (self: ^Device, gpuFamily: GPUFamily) -> BOOL { return msgSend(BOOL, self, "supportsFamily:", gpuFamily) } @(objc_type=Device, objc_name="supportsFeatureSet") -Device_supportsFeatureSet :: #force_inline proc(self: ^Device, featureSet: FeatureSet) -> BOOL { +Device_supportsFeatureSet :: #force_inline proc "c" (self: ^Device, featureSet: FeatureSet) -> BOOL { return msgSend(BOOL, self, "supportsFeatureSet:", featureSet) } @(objc_type=Device, objc_name="supportsFunctionPointers") -Device_supportsFunctionPointers :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsFunctionPointers :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsFunctionPointers") } @(objc_type=Device, objc_name="supportsPullModelInterpolation") -Device_supportsPullModelInterpolation :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsPullModelInterpolation :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsPullModelInterpolation") } @(objc_type=Device, objc_name="supportsQueryTextureLOD") -Device_supportsQueryTextureLOD :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsQueryTextureLOD :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsQueryTextureLOD") } @(objc_type=Device, objc_name="supportsRasterizationRateMapWithLayerCount") -Device_supportsRasterizationRateMapWithLayerCount :: #force_inline proc(self: ^Device, layerCount: NS.UInteger) -> BOOL { +Device_supportsRasterizationRateMapWithLayerCount :: #force_inline proc "c" (self: ^Device, layerCount: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsRasterizationRateMapWithLayerCount:", layerCount) } @(objc_type=Device, objc_name="supportsRaytracing") -Device_supportsRaytracing :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsRaytracing :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsRaytracing") } @(objc_type=Device, objc_name="supportsShaderBarycentricCoordinates") -Device_supportsShaderBarycentricCoordinates :: #force_inline proc(self: ^Device) -> BOOL { +Device_supportsShaderBarycentricCoordinates :: #force_inline proc "c" (self: ^Device) -> BOOL { return msgSend(BOOL, self, "supportsShaderBarycentricCoordinates") } @(objc_type=Device, objc_name="supportsTextureSampleCount") -Device_supportsTextureSampleCount :: #force_inline proc(self: ^Device, sampleCount: NS.UInteger) -> BOOL { +Device_supportsTextureSampleCount :: #force_inline proc "c" (self: ^Device, sampleCount: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsTextureSampleCount:", sampleCount) } @(objc_type=Device, objc_name="supportsVertexAmplificationCount") -Device_supportsVertexAmplificationCount :: #force_inline proc(self: ^Device, count: NS.UInteger) -> BOOL { +Device_supportsVertexAmplificationCount :: #force_inline proc "c" (self: ^Device, count: NS.UInteger) -> BOOL { return msgSend(BOOL, self, "supportsVertexAmplificationCount:", count) } @(objc_type=Device, objc_name="newRenderPipelineStateWithMeshDescriptor") -Device_newRenderPipelineStateWithMeshDescriptor :: #force_inline proc(self: ^Device, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (state: ^RenderPipelineState, error: ^NS.Error) { +Device_newRenderPipelineStateWithMeshDescriptor :: #force_inline proc "contextless" (self: ^Device, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection) -> (state: ^RenderPipelineState, error: ^NS.Error) { state = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithMeshDescriptor:options:reflection:error:", options, reflection, &error) return } @(objc_type=Device, objc_name="newRenderPipelineStateWithMeshDescriptorAndCompletionHandler") -Device_newRenderPipelineStateWithMeshDescriptorAndCompletionHandler :: #force_inline proc(self: ^Device, options: PipelineOption, completionHandler: ^NewRenderPipelineStateWithReflectionCompletionHandler) -> (state: ^RenderPipelineState) { +Device_newRenderPipelineStateWithMeshDescriptorAndCompletionHandler :: #force_inline proc "c" (self: ^Device, options: PipelineOption, completionHandler: ^NewRenderPipelineStateWithReflectionCompletionHandler) -> (state: ^RenderPipelineState) { state = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithMeshDescriptor:options:completionHandler:", options, completionHandler) return } @(objc_type=Device, objc_name="newIOHandle") -Device_newIOHandle :: #force_inline proc(self: ^Device, url: ^NS.URL) -> (handle: ^IOFileHandle, err: ^NS.Error) { +Device_newIOHandle :: #force_inline proc "contextless" (self: ^Device, url: ^NS.URL) -> (handle: ^IOFileHandle, err: ^NS.Error) { handle = msgSend(^IOFileHandle, self, "newIOHandleWithURL:error:", url, &err) return } @(objc_type=Device, objc_name="newIOHandleWithCompressionMethod") -Device_newIOHandleWithCompressionMethod :: #force_inline proc(self: ^Device, url: ^NS.URL, compressionMethod: IOCompressionMethod) -> (handle: ^IOFileHandle, err: ^NS.Error) { +Device_newIOHandleWithCompressionMethod :: #force_inline proc "contextless" (self: ^Device, url: ^NS.URL, compressionMethod: IOCompressionMethod) -> (handle: ^IOFileHandle, err: ^NS.Error) { handle = msgSend(^IOFileHandle, self, "newIOHandleWithURL:compressionMethod:error:", url, compressionMethod, &err) return } @(objc_type=Device, objc_name="newIOCommandQueue") -Device_newIOCommandQueue :: #force_inline proc(self: ^Device, descriptor: ^IOCommandQueueDescriptor) -> (handle: ^IOCommandQueue, err: ^NS.Error) { +Device_newIOCommandQueue :: #force_inline proc "contextless" (self: ^Device, descriptor: ^IOCommandQueueDescriptor) -> (handle: ^IOCommandQueue, err: ^NS.Error) { handle = msgSend(^IOCommandQueue, self, "newIOCommandQueueWithDescriptor:error:", descriptor, &err) return } @@ -7335,27 +7335,27 @@ Methods: Drawable :: struct { using _: NS.Object } @(objc_type=Drawable, objc_name="addPresentedHandler") -Drawable_addPresentedHandler :: #force_inline proc(self: ^Drawable, block: DrawablePresentedHandler) { +Drawable_addPresentedHandler :: #force_inline proc "c" (self: ^Drawable, block: DrawablePresentedHandler) { msgSend(nil, self, "addPresentedHandler:", block) } @(objc_type=Drawable, objc_name="drawableID") -Drawable_drawableID :: #force_inline proc(self: ^Drawable) -> NS.UInteger { +Drawable_drawableID :: #force_inline proc "c" (self: ^Drawable) -> NS.UInteger { return msgSend(NS.UInteger, self, "drawableID") } @(objc_type=Drawable, objc_name="present") -Drawable_present :: #force_inline proc(self: ^Drawable) { +Drawable_present :: #force_inline proc "c" (self: ^Drawable) { msgSend(nil, self, "present") } @(objc_type=Drawable, objc_name="presentAfterMinimumDuration") -Drawable_presentAfterMinimumDuration :: #force_inline proc(self: ^Drawable, duration: CFTimeInterval) { +Drawable_presentAfterMinimumDuration :: #force_inline proc "c" (self: ^Drawable, duration: CFTimeInterval) { msgSend(nil, self, "presentAfterMinimumDuration:", duration) } @(objc_type=Drawable, objc_name="presentAtTime") -Drawable_presentAtTime :: #force_inline proc(self: ^Drawable, presentationTime: CFTimeInterval) { +Drawable_presentAtTime :: #force_inline proc "c" (self: ^Drawable, presentationTime: CFTimeInterval) { msgSend(nil, self, "presentAtTime:", presentationTime) } @(objc_type=Drawable, objc_name="presentedTime") -Drawable_presentedTime :: #force_inline proc(self: ^Drawable) -> CFTimeInterval { +Drawable_presentedTime :: #force_inline proc "c" (self: ^Drawable) -> CFTimeInterval { return msgSend(CFTimeInterval, self, "presentedTime") } @@ -7376,24 +7376,24 @@ Methods: DynamicLibrary :: struct { using _: NS.Object } @(objc_type=DynamicLibrary, objc_name="device") -DynamicLibrary_device :: #force_inline proc(self: ^DynamicLibrary) -> ^Device { +DynamicLibrary_device :: #force_inline proc "c" (self: ^DynamicLibrary) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=DynamicLibrary, objc_name="installName") -DynamicLibrary_installName :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String { +DynamicLibrary_installName :: #force_inline proc "c" (self: ^DynamicLibrary) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=DynamicLibrary, objc_name="label") -DynamicLibrary_label :: #force_inline proc(self: ^DynamicLibrary) -> ^NS.String { +DynamicLibrary_label :: #force_inline proc "c" (self: ^DynamicLibrary) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=DynamicLibrary, objc_name="serializeToURL") -DynamicLibrary_serializeToURL :: #force_inline proc(self: ^DynamicLibrary, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { +DynamicLibrary_serializeToURL :: #force_inline proc "contextless" (self: ^DynamicLibrary, url: ^NS.URL) -> (ok: BOOL, error: ^NS.Error) { ok = msgSend(BOOL, self, "serializeToURL:error:", url, &error) return } @(objc_type=DynamicLibrary, objc_name="setLabel") -DynamicLibrary_setLabel :: #force_inline proc(self: ^DynamicLibrary, label: ^NS.String) { +DynamicLibrary_setLabel :: #force_inline proc "c" (self: ^DynamicLibrary, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -7412,15 +7412,15 @@ Methods: Event :: struct { using _: NS.Object } @(objc_type=Event, objc_name="device") -Event_device :: #force_inline proc(self: ^Event) -> ^Device { +Event_device :: #force_inline proc "c" (self: ^Event) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Event, objc_name="label") -Event_label :: #force_inline proc(self: ^Event) -> ^NS.String { +Event_label :: #force_inline proc "c" (self: ^Event) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Event, objc_name="setLabel") -Event_setLabel :: #force_inline proc(self: ^Event, label: ^NS.String) { +Event_setLabel :: #force_inline proc "c" (self: ^Event, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -7439,15 +7439,15 @@ Methods: Fence :: struct { using _: NS.Object } @(objc_type=Fence, objc_name="device") -Fence_device :: #force_inline proc(self: ^Fence) -> ^Device { +Fence_device :: #force_inline proc "c" (self: ^Fence) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Fence, objc_name="label") -Fence_label :: #force_inline proc(self: ^Fence) -> ^NS.String { +Fence_label :: #force_inline proc "c" (self: ^Fence) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Fence, objc_name="setLabel") -Fence_setLabel :: #force_inline proc(self: ^Fence, label: ^NS.String) { +Fence_setLabel :: #force_inline proc "c" (self: ^Fence, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -7476,55 +7476,55 @@ Methods: Function :: struct { using _: NS.Object } @(objc_type=Function, objc_name="device") -Function_device :: #force_inline proc(self: ^Function) -> ^Device { +Function_device :: #force_inline proc "c" (self: ^Function) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Function, objc_name="functionConstantsDictionary") -Function_functionConstantsDictionary :: #force_inline proc(self: ^Function) -> ^NS.Dictionary { +Function_functionConstantsDictionary :: #force_inline proc "c" (self: ^Function) -> ^NS.Dictionary { return msgSend(^NS.Dictionary, self, "functionConstantsDictionary") } @(objc_type=Function, objc_name="functionType") -Function_functionType :: #force_inline proc(self: ^Function) -> FunctionType { +Function_functionType :: #force_inline proc "c" (self: ^Function) -> FunctionType { return msgSend(FunctionType, self, "functionType") } @(objc_type=Function, objc_name="label") -Function_label :: #force_inline proc(self: ^Function) -> ^NS.String { +Function_label :: #force_inline proc "c" (self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Function, objc_name="name") -Function_name :: #force_inline proc(self: ^Function) -> ^NS.String { +Function_name :: #force_inline proc "c" (self: ^Function) -> ^NS.String { return msgSend(^NS.String, self, "name") } @(objc_type=Function, objc_name="newArgumentEncoder") -Function_newArgumentEncoder :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger) -> ^ArgumentEncoder { +Function_newArgumentEncoder :: #force_inline proc "c" (self: ^Function, bufferIndex: NS.UInteger) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithBufferIndex:", bufferIndex) } @(objc_type=Function, objc_name="newArgumentEncoderWithReflection") -Function_newArgumentEncoderWithReflection :: #force_inline proc(self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^ArgumentEncoder { +Function_newArgumentEncoderWithReflection :: #force_inline proc "c" (self: ^Function, bufferIndex: NS.UInteger, reflection: ^AutoreleasedArgument) -> ^ArgumentEncoder { return msgSend(^ArgumentEncoder, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection) } @(objc_type=Function, objc_name="options") -Function_options :: #force_inline proc(self: ^Function) -> FunctionOptions { +Function_options :: #force_inline proc "c" (self: ^Function) -> FunctionOptions { return msgSend(FunctionOptions, self, "options") } @(objc_type=Function, objc_name="patchControlPointCount") -Function_patchControlPointCount :: #force_inline proc(self: ^Function) -> NS.UInteger { +Function_patchControlPointCount :: #force_inline proc "c" (self: ^Function) -> NS.UInteger { return msgSend(NS.UInteger, self, "patchControlPointCount") } @(objc_type=Function, objc_name="patchType") -Function_patchType :: #force_inline proc(self: ^Function) -> PatchType { +Function_patchType :: #force_inline proc "c" (self: ^Function) -> PatchType { return msgSend(PatchType, self, "patchType") } @(objc_type=Function, objc_name="setLabel") -Function_setLabel :: #force_inline proc(self: ^Function, label: ^NS.String) { +Function_setLabel :: #force_inline proc "c" (self: ^Function, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Function, objc_name="stageInputAttributes") -Function_stageInputAttributes :: #force_inline proc(self: ^Function) -> ^NS.Array { +Function_stageInputAttributes :: #force_inline proc "c" (self: ^Function) -> ^NS.Array { return msgSend(^NS.Array, self, "stageInputAttributes") } @(objc_type=Function, objc_name="vertexAttributes") -Function_vertexAttributes :: #force_inline proc(self: ^Function) -> ^NS.Array { +Function_vertexAttributes :: #force_inline proc "c" (self: ^Function) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexAttributes") } @@ -7543,15 +7543,15 @@ Methods: FunctionHandle :: struct { using _: NS.Object } @(objc_type=FunctionHandle, objc_name="device") -FunctionHandle_device :: #force_inline proc(self: ^FunctionHandle) -> ^Device { +FunctionHandle_device :: #force_inline proc "c" (self: ^FunctionHandle) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=FunctionHandle, objc_name="functionType") -FunctionHandle_functionType :: #force_inline proc(self: ^FunctionHandle) -> FunctionType { +FunctionHandle_functionType :: #force_inline proc "c" (self: ^FunctionHandle) -> FunctionType { return msgSend(FunctionType, self, "functionType") } @(objc_type=FunctionHandle, objc_name="name") -FunctionHandle_name :: #force_inline proc(self: ^FunctionHandle) -> ^NS.String { +FunctionHandle_name :: #force_inline proc "c" (self: ^FunctionHandle) -> ^NS.String { return msgSend(^NS.String, self, "name") } @@ -7581,19 +7581,19 @@ Methods: FunctionLog :: struct { using _: NS.Object } @(objc_type=FunctionLog, objc_name="debugLocation") -FunctionLog_debugLocation :: #force_inline proc(self: ^FunctionLog) -> ^FunctionLog { +FunctionLog_debugLocation :: #force_inline proc "c" (self: ^FunctionLog) -> ^FunctionLog { return msgSend(^FunctionLog, self, "debugLocation") } @(objc_type=FunctionLog, objc_name="encoderLabel") -FunctionLog_encoderLabel :: #force_inline proc(self: ^FunctionLog) -> ^NS.String { +FunctionLog_encoderLabel :: #force_inline proc "c" (self: ^FunctionLog) -> ^NS.String { return msgSend(^NS.String, self, "encoderLabel") } @(objc_type=FunctionLog, objc_name="function") -FunctionLog_function :: #force_inline proc(self: ^FunctionLog) -> ^FunctionLog { +FunctionLog_function :: #force_inline proc "c" (self: ^FunctionLog) -> ^FunctionLog { return msgSend(^FunctionLog, self, "function") } @(objc_type=FunctionLog, objc_name="type") -FunctionLog_type :: #force_inline proc(self: ^FunctionLog) -> FunctionLogType { +FunctionLog_type :: #force_inline proc "c" (self: ^FunctionLog) -> FunctionLogType { return msgSend(FunctionLogType, self, "type") } @@ -7613,19 +7613,19 @@ Methods: FunctionLogDebugLocation :: struct { using _: NS.Object } @(objc_type=FunctionLogDebugLocation, objc_name="URL") -FunctionLogDebugLocation_URL :: #force_inline proc(self: ^FunctionLogDebugLocation) -> ^NS.URL { +FunctionLogDebugLocation_URL :: #force_inline proc "c" (self: ^FunctionLogDebugLocation) -> ^NS.URL { return msgSend(^NS.URL, self, "URL") } @(objc_type=FunctionLogDebugLocation, objc_name="column") -FunctionLogDebugLocation_column :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.UInteger { +FunctionLogDebugLocation_column :: #force_inline proc "c" (self: ^FunctionLogDebugLocation) -> NS.UInteger { return msgSend(NS.UInteger, self, "column") } @(objc_type=FunctionLogDebugLocation, objc_name="functionName") -FunctionLogDebugLocation_functionName :: #force_inline proc(self: ^FunctionLogDebugLocation) -> ^NS.String { +FunctionLogDebugLocation_functionName :: #force_inline proc "c" (self: ^FunctionLogDebugLocation) -> ^NS.String { return msgSend(^NS.String, self, "functionName") } @(objc_type=FunctionLogDebugLocation, objc_name="line") -FunctionLogDebugLocation_line :: #force_inline proc(self: ^FunctionLogDebugLocation) -> NS.UInteger { +FunctionLogDebugLocation_line :: #force_inline proc "c" (self: ^FunctionLogDebugLocation) -> NS.UInteger { return msgSend(NS.UInteger, self, "line") } @@ -7658,35 +7658,35 @@ Methods: Heap :: struct { using _: NS.Object } @(objc_type=Heap, objc_name="cpuCacheMode") -Heap_cpuCacheMode :: #force_inline proc(self: ^Heap) -> CPUCacheMode { +Heap_cpuCacheMode :: #force_inline proc "c" (self: ^Heap) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Heap, objc_name="currentAllocatedSize") -Heap_currentAllocatedSize :: #force_inline proc(self: ^Heap) -> NS.UInteger { +Heap_currentAllocatedSize :: #force_inline proc "c" (self: ^Heap) -> NS.UInteger { return msgSend(NS.UInteger, self, "currentAllocatedSize") } @(objc_type=Heap, objc_name="device") -Heap_device :: #force_inline proc(self: ^Heap) -> ^Device { +Heap_device :: #force_inline proc "c" (self: ^Heap) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Heap, objc_name="hazardTrackingMode") -Heap_hazardTrackingMode :: #force_inline proc(self: ^Heap) -> HazardTrackingMode { +Heap_hazardTrackingMode :: #force_inline proc "c" (self: ^Heap) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=Heap, objc_name="label") -Heap_label :: #force_inline proc(self: ^Heap) -> ^NS.String { +Heap_label :: #force_inline proc "c" (self: ^Heap) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Heap, objc_name="maxAvailableSizeWithAlignment") -Heap_maxAvailableSizeWithAlignment :: #force_inline proc(self: ^Heap, alignment: NS.UInteger) -> NS.UInteger { +Heap_maxAvailableSizeWithAlignment :: #force_inline proc "c" (self: ^Heap, alignment: NS.UInteger) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxAvailableSizeWithAlignment:", alignment) } @(objc_type=Heap, objc_name="newBufferWithLength") -Heap_newBufferWithLength :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { +Heap_newBufferWithLength :: #force_inline proc "c" (self: ^Heap, length: NS.UInteger, options: ResourceOptions) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:", length, options) } @(objc_type=Heap, objc_name="newBufferWithOptions") -Heap_newBufferWithOptions :: #force_inline proc(self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Buffer { +Heap_newBufferWithOptions :: #force_inline proc "c" (self: ^Heap, length: NS.UInteger, options: ResourceOptions, offset: NS.UInteger) -> ^Buffer { return msgSend(^Buffer, self, "newBufferWithLength:options:offset:", length, options, offset) } @(objc_type=Heap, objc_name="newBuffer") @@ -7696,11 +7696,11 @@ Heap_newBuffer :: proc{ } @(objc_type=Heap, objc_name="newTextureWithDescriptor") -Heap_newTextureWithDescriptor :: #force_inline proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Texture { +Heap_newTextureWithDescriptor :: #force_inline proc "c" (self: ^Heap, desc: ^TextureDescriptor) -> ^Texture { return msgSend(^Texture, self, "newTextureWithDescriptor:", desc) } @(objc_type=Heap, objc_name="newTextureWithDescriptorAndOffset") -Heap_newTextureWithDescriptorAndOffset :: #force_inline proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Texture { +Heap_newTextureWithDescriptorAndOffset :: #force_inline proc "c" (self: ^Heap, descriptor: ^TextureDescriptor, offset: NS.UInteger) -> ^Texture { return msgSend(^Texture, self, "newTextureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="newTexture") @@ -7710,19 +7710,19 @@ Heap_newTexture :: proc{ } @(objc_type=Heap, objc_name="newAccelerationStructureWithSize") -Heap_newAccelerationStructureWithSize :: #force_inline proc(self: ^Heap, size: NS.UInteger) -> ^AccelerationStructure { +Heap_newAccelerationStructureWithSize :: #force_inline proc "c" (self: ^Heap, size: NS.UInteger) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithSize:", size) } @(objc_type=Heap, objc_name="newAccelerationStructureWithDescriptor") -Heap_newAccelerationStructureWithDescriptor :: #force_inline proc(self: ^Heap, descriptor: ^AccelerationStructureDescriptor) -> ^AccelerationStructure { +Heap_newAccelerationStructureWithDescriptor :: #force_inline proc "c" (self: ^Heap, descriptor: ^AccelerationStructureDescriptor) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithDescriptor:", descriptor) } @(objc_type=Heap, objc_name="newAccelerationStructureWithSizeAndOffset") -Heap_newAccelerationStructureWithSizeAndOffset :: #force_inline proc(self: ^Heap, size, offset: NS.UInteger) -> ^AccelerationStructure { +Heap_newAccelerationStructureWithSizeAndOffset :: #force_inline proc "c" (self: ^Heap, size, offset: NS.UInteger) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithSize:offset:", size, offset) } @(objc_type=Heap, objc_name="newAccelerationStructureWithDescriptorAndOffset") -Heap_newAccelerationStructureWithDescriptorAndOffset :: #force_inline proc(self: ^Heap, descriptor: ^AccelerationStructureDescriptor, offset: NS.UInteger) -> ^AccelerationStructure { +Heap_newAccelerationStructureWithDescriptorAndOffset :: #force_inline proc "c" (self: ^Heap, descriptor: ^AccelerationStructureDescriptor, offset: NS.UInteger) -> ^AccelerationStructure { return msgSend(^AccelerationStructure, self, "newAccelerationStructureWithDescriptor:offset:", descriptor, offset) } @(objc_type=Heap, objc_name="newAccelerationStructure") @@ -7734,31 +7734,31 @@ Heap_newAccelerationStructure :: proc{ } @(objc_type=Heap, objc_name="resourceOptions") -Heap_resourceOptions :: #force_inline proc(self: ^Heap) -> ResourceOptions { +Heap_resourceOptions :: #force_inline proc "c" (self: ^Heap) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=Heap, objc_name="setLabel") -Heap_setLabel :: #force_inline proc(self: ^Heap, label: ^NS.String) { +Heap_setLabel :: #force_inline proc "c" (self: ^Heap, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Heap, objc_name="setPurgeableState") -Heap_setPurgeableState :: #force_inline proc(self: ^Heap, state: PurgeableState) -> PurgeableState { +Heap_setPurgeableState :: #force_inline proc "c" (self: ^Heap, state: PurgeableState) -> PurgeableState { return msgSend(PurgeableState, self, "setPurgeableState:", state) } @(objc_type=Heap, objc_name="size") -Heap_size :: #force_inline proc(self: ^Heap) -> NS.UInteger { +Heap_size :: #force_inline proc "c" (self: ^Heap) -> NS.UInteger { return msgSend(NS.UInteger, self, "size") } @(objc_type=Heap, objc_name="storageMode") -Heap_storageMode :: #force_inline proc(self: ^Heap) -> StorageMode { +Heap_storageMode :: #force_inline proc "c" (self: ^Heap) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @(objc_type=Heap, objc_name="type") -Heap_type :: #force_inline proc(self: ^Heap) -> FunctionLogType { +Heap_type :: #force_inline proc "c" (self: ^Heap) -> FunctionLogType { return msgSend(FunctionLogType, self, "type") } @(objc_type=Heap, objc_name="usedSize") -Heap_usedSize :: #force_inline proc(self: ^Heap) -> NS.UInteger { +Heap_usedSize :: #force_inline proc "c" (self: ^Heap) -> NS.UInteger { return msgSend(NS.UInteger, self, "usedSize") } @@ -7778,33 +7778,33 @@ Methods: IndirectCommandBuffer :: struct { using _: Resource } @(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommand") -IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectComputeCommand { +IndirectCommandBuffer_indirectComputeCommand :: #force_inline proc "c" (self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectComputeCommand { return msgSend(^IndirectComputeCommand, self, "indirectComputeCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommand") -IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc(self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectRenderCommand { +IndirectCommandBuffer_indirectRenderCommand :: #force_inline proc "c" (self: ^IndirectCommandBuffer, commandIndex: NS.UInteger) -> ^IndirectRenderCommand { return msgSend(^IndirectRenderCommand, self, "indirectRenderCommandAtIndex:", commandIndex) } @(objc_type=IndirectCommandBuffer, objc_name="resetWithRange") -IndirectCommandBuffer_resetWithRange :: #force_inline proc(self: ^IndirectCommandBuffer, range: NS.Range) { +IndirectCommandBuffer_resetWithRange :: #force_inline proc "c" (self: ^IndirectCommandBuffer, range: NS.Range) { msgSend(nil, self, "resetWithRange:", range) } @(objc_type=IndirectCommandBuffer, objc_name="size") -IndirectCommandBuffer_size :: #force_inline proc(self: ^IndirectCommandBuffer) -> NS.UInteger { +IndirectCommandBuffer_size :: #force_inline proc "c" (self: ^IndirectCommandBuffer) -> NS.UInteger { return msgSend(NS.UInteger, self, "size") } @(objc_type=IndirectCommandBuffer, objc_name="supportRayTracing") -IndirectCommandBuffer_supportRayTracing :: #force_inline proc(self: ^IndirectCommandBuffer) -> BOOL { +IndirectCommandBuffer_supportRayTracing :: #force_inline proc "c" (self: ^IndirectCommandBuffer) -> BOOL { return msgSend(BOOL, self, "supportRayTracing") } @(objc_type=IndirectCommandBuffer, objc_name="setSupportRayTracing") -IndirectCommandBuffer_setSupportRayTracing :: #force_inline proc(self: ^IndirectCommandBuffer, supportRayTracing: BOOL) { +IndirectCommandBuffer_setSupportRayTracing :: #force_inline proc "c" (self: ^IndirectCommandBuffer, supportRayTracing: BOOL) { msgSend(nil, self, "setSupportRayTracing:", supportRayTracing) } @(objc_type=IndirectCommandBuffer, objc_name="gpuResourceID") -IndirectCommandBuffer_gpuResourceID :: #force_inline proc(self: ^IndirectCommandBuffer) -> ResourceID { +IndirectCommandBuffer_gpuResourceID :: #force_inline proc "c" (self: ^IndirectCommandBuffer) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } @@ -7831,43 +7831,43 @@ Methods: IndirectComputeCommand :: struct { using _: NS.Object } @(objc_type=IndirectComputeCommand, objc_name="clearBarrier") -IndirectComputeCommand_clearBarrier :: #force_inline proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_clearBarrier :: #force_inline proc "c" (self: ^IndirectComputeCommand) { msgSend(nil, self, "clearBarrier") } @(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreadgroups") -IndirectComputeCommand_concurrentDispatchThreadgroups :: #force_inline proc(self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { +IndirectComputeCommand_concurrentDispatchThreadgroups :: #force_inline proc "c" (self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "concurrentDispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup) } @(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreads") -IndirectComputeCommand_concurrentDispatchThreads :: #force_inline proc(self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) { +IndirectComputeCommand_concurrentDispatchThreads :: #force_inline proc "c" (self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) { msgSend(nil, self, "concurrentDispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup) } @(objc_type=IndirectComputeCommand, objc_name="reset") -IndirectComputeCommand_reset :: #force_inline proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_reset :: #force_inline proc "c" (self: ^IndirectComputeCommand) { msgSend(nil, self, "reset") } @(objc_type=IndirectComputeCommand, objc_name="setBarrier") -IndirectComputeCommand_setBarrier :: #force_inline proc(self: ^IndirectComputeCommand) { +IndirectComputeCommand_setBarrier :: #force_inline proc "c" (self: ^IndirectComputeCommand) { msgSend(nil, self, "setBarrier") } @(objc_type=IndirectComputeCommand, objc_name="setComputePipelineState") -IndirectComputeCommand_setComputePipelineState :: #force_inline proc(self: ^IndirectComputeCommand, pipelineState: ^ComputePipelineState) { +IndirectComputeCommand_setComputePipelineState :: #force_inline proc "c" (self: ^IndirectComputeCommand, pipelineState: ^ComputePipelineState) { msgSend(nil, self, "setComputePipelineState:", pipelineState) } @(objc_type=IndirectComputeCommand, objc_name="setImageblockWidth") -IndirectComputeCommand_setImageblockWidth :: #force_inline proc(self: ^IndirectComputeCommand, width: NS.UInteger, height: NS.UInteger) { +IndirectComputeCommand_setImageblockWidth :: #force_inline proc "c" (self: ^IndirectComputeCommand, width: NS.UInteger, height: NS.UInteger) { msgSend(nil, self, "setImageblockWidth:height:", width, height) } @(objc_type=IndirectComputeCommand, objc_name="setKernelBuffer") -IndirectComputeCommand_setKernelBuffer :: #force_inline proc(self: ^IndirectComputeCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +IndirectComputeCommand_setKernelBuffer :: #force_inline proc "c" (self: ^IndirectComputeCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setKernelBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectComputeCommand, objc_name="setStageInRegion") -IndirectComputeCommand_setStageInRegion :: #force_inline proc(self: ^IndirectComputeCommand, region: Region) { +IndirectComputeCommand_setStageInRegion :: #force_inline proc "c" (self: ^IndirectComputeCommand, region: Region) { msgSend(nil, self, "setStageInRegion:", region) } @(objc_type=IndirectComputeCommand, objc_name="setThreadgroupMemoryLength") -IndirectComputeCommand_setThreadgroupMemoryLength :: #force_inline proc(self: ^IndirectComputeCommand, length: NS.UInteger, index: NS.UInteger) { +IndirectComputeCommand_setThreadgroupMemoryLength :: #force_inline proc "c" (self: ^IndirectComputeCommand, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index) } @@ -7891,35 +7891,35 @@ Methods: IndirectRenderCommand :: struct { using _: NS.Object } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches") -IndirectRenderCommand_drawIndexedPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { +IndirectRenderCommand_drawIndexedPatches :: #force_inline proc "c" (self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives") -IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { +IndirectRenderCommand_drawIndexedPrimitives :: #force_inline proc "c" (self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="drawPatches") -IndirectRenderCommand_drawPatches :: #force_inline proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { +IndirectRenderCommand_drawPatches :: #force_inline proc "c" (self: ^IndirectRenderCommand, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride) } @(objc_type=IndirectRenderCommand, objc_name="drawPrimitives") -IndirectRenderCommand_drawPrimitives :: #force_inline proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger = 0) { +IndirectRenderCommand_drawPrimitives :: #force_inline proc "c" (self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger = 0) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=IndirectRenderCommand, objc_name="reset") -IndirectRenderCommand_reset :: #force_inline proc(self: ^IndirectRenderCommand) { +IndirectRenderCommand_reset :: #force_inline proc "c" (self: ^IndirectRenderCommand) { msgSend(nil, self, "reset") } @(objc_type=IndirectRenderCommand, objc_name="setFragmentBuffer") -IndirectRenderCommand_setFragmentBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +IndirectRenderCommand_setFragmentBuffer :: #force_inline proc "c" (self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IndirectRenderCommand, objc_name="setRenderPipelineState") -IndirectRenderCommand_setRenderPipelineState :: #force_inline proc(self: ^IndirectRenderCommand, pipelineState: ^RenderPipelineState) { +IndirectRenderCommand_setRenderPipelineState :: #force_inline proc "c" (self: ^IndirectRenderCommand, pipelineState: ^RenderPipelineState) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=IndirectRenderCommand, objc_name="setVertexBuffer") -IndirectRenderCommand_setVertexBuffer :: #force_inline proc(self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +IndirectRenderCommand_setVertexBuffer :: #force_inline proc "c" (self: ^IndirectRenderCommand, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @@ -7943,35 +7943,35 @@ Methods: IntersectionFunctionTable :: struct { using _: Resource } @(objc_type=IntersectionFunctionTable, objc_name="setBuffer") -IntersectionFunctionTable_setBuffer :: #force_inline proc(self: ^IntersectionFunctionTable, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +IntersectionFunctionTable_setBuffer :: #force_inline proc "c" (self: ^IntersectionFunctionTable, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=IntersectionFunctionTable, objc_name="setBuffers") -IntersectionFunctionTable_setBuffers :: #force_inline proc(self: ^IntersectionFunctionTable, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +IntersectionFunctionTable_setBuffers :: #force_inline proc "c" (self: ^IntersectionFunctionTable, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { msgSend(nil, self, "setBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=IntersectionFunctionTable, objc_name="setFunction") -IntersectionFunctionTable_setFunction :: #force_inline proc(self: ^IntersectionFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { +IntersectionFunctionTable_setFunction :: #force_inline proc "c" (self: ^IntersectionFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=IntersectionFunctionTable, objc_name="setFunctions") -IntersectionFunctionTable_setFunctions :: #force_inline proc(self: ^IntersectionFunctionTable, functions: []^FunctionHandle, range: NS.Range) { +IntersectionFunctionTable_setFunctions :: #force_inline proc "c" (self: ^IntersectionFunctionTable, functions: []^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature :: #force_inline proc "c" (self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: NS.UInteger) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index) } @(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureWithRange") -IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureWithRange :: #force_inline proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { +IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureWithRange :: #force_inline proc "c" (self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) { msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:", signature, range) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTable") -IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { +IntersectionFunctionTable_setVisibleFunctionTable :: #force_inline proc "c" (self: ^IntersectionFunctionTable, visibleFunctionTable: ^VisibleFunctionTable, bufferIndex: NS.UInteger) { msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex) } @(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables") -IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^IntersectionFunctionTable, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { +IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc "c" (self: ^IntersectionFunctionTable, visibleFunctionTables: []^VisibleFunctionTable, range: NS.Range) { msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", raw_data(visibleFunctionTables), range) } @@ -7981,23 +7981,23 @@ IntersectionFunctionTable_setVisibleFunctionTables :: #force_inline proc(self: ^ IOCommandQueue :: struct { using _: NS.Object } @(objc_type=IOCommandQueue, objc_name="enqueueBarrier") -IOCommandQueue_enqueueBarrier :: #force_inline proc(self: ^IOCommandQueue) { +IOCommandQueue_enqueueBarrier :: #force_inline proc "c" (self: ^IOCommandQueue) { msgSend(nil, self, "enqueueBarrier") } @(objc_type=IOCommandQueue, objc_name="commandBuffer") -IOCommandQueue_commandBuffer :: #force_inline proc(self: ^IOCommandQueue) -> ^IOCommandBuffer { +IOCommandQueue_commandBuffer :: #force_inline proc "c" (self: ^IOCommandQueue) -> ^IOCommandBuffer { return msgSend(^IOCommandBuffer, self, "commandBuffer") } @(objc_type=IOCommandQueue, objc_name="commandBufferWithUnretainedReferences") -IOCommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc(self: ^IOCommandQueue) -> ^IOCommandBuffer { +IOCommandQueue_commandBufferWithUnretainedReferences :: #force_inline proc "c" (self: ^IOCommandQueue) -> ^IOCommandBuffer { return msgSend(^IOCommandBuffer, self, "commandBufferWithUnretainedReferences") } @(objc_type=IOCommandQueue, objc_name="label") -IOCommandQueue_label :: #force_inline proc(self: ^IOCommandQueue) -> ^NS.String { +IOCommandQueue_label :: #force_inline proc "c" (self: ^IOCommandQueue) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=IOCommandQueue, objc_name="setLabel") -IOCommandQueue_setLabel :: #force_inline proc(self: ^IOCommandQueue, label: ^NS.String) { +IOCommandQueue_setLabel :: #force_inline proc "c" (self: ^IOCommandQueue, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -8007,7 +8007,7 @@ IOCommandQueue_setLabel :: #force_inline proc(self: ^IOCommandQueue, label: ^NS. IOScratchBuffer :: struct { using _: NS.Object } @(objc_type=IOScratchBuffer, objc_name="buffer") -IOScratchBuffer_buffer :: #force_inline proc(self: ^IOCommandQueue) -> ^Buffer { +IOScratchBuffer_buffer :: #force_inline proc "c" (self: ^IOCommandQueue) -> ^Buffer { return msgSend(^Buffer, self, "buffer") } @@ -8017,7 +8017,7 @@ IOScratchBuffer_buffer :: #force_inline proc(self: ^IOCommandQueue) -> ^Buffer { IOScratchBufferAllocator :: struct { using _: NS.Object } @(objc_type=IOScratchBufferAllocator, objc_name="newScratchBuffer") -IOScratchBufferAllocator_newScratchBuffer :: #force_inline proc(self: ^IOCommandQueue, minimumSize: NS.UInteger) -> ^IOScratchBuffer { +IOScratchBufferAllocator_newScratchBuffer :: #force_inline proc "c" (self: ^IOCommandQueue, minimumSize: NS.UInteger) -> ^IOScratchBuffer { return msgSend(^IOScratchBuffer, self, "newScratchBufferWithMinimumSize:", minimumSize) } @@ -8028,16 +8028,16 @@ IOCommandQueueDescriptor :: struct { using _: NS.Copying(IOCommandQueueDescripto @(objc_type=IOCommandQueueDescriptor, objc_name="alloc", objc_is_class_method=true) -IOCommandQueueDescriptor_alloc :: #force_inline proc() -> ^IOCommandQueueDescriptor { +IOCommandQueueDescriptor_alloc :: #force_inline proc "c" () -> ^IOCommandQueueDescriptor { return msgSend(^IOCommandQueueDescriptor, IOCommandQueueDescriptor, "alloc") } @(objc_type=IOCommandQueueDescriptor, objc_name="init") -IOCommandQueueDescriptor_init :: #force_inline proc(self: ^IOCommandQueueDescriptor) -> ^IOCommandQueueDescriptor { +IOCommandQueueDescriptor_init :: #force_inline proc "c" (self: ^IOCommandQueueDescriptor) -> ^IOCommandQueueDescriptor { return msgSend(^IOCommandQueueDescriptor, self, "init") } @(objc_type=IOCommandQueueDescriptor, objc_name="maxCommandBufferCount") -IOCommandQueueDescriptor_maxCommandBufferCount :: #force_inline proc(self: ^IOCommandQueueDescriptor) -> NS.UInteger { +IOCommandQueueDescriptor_maxCommandBufferCount :: #force_inline proc "c" (self: ^IOCommandQueueDescriptor) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxCommandBufferCount") } @@ -8047,11 +8047,11 @@ IOCommandQueueDescriptor_maxCommandBufferCount :: #force_inline proc(self: ^IOCo IOFileHandle :: struct { using _: NS.Object } @(objc_type=IOFileHandle, objc_name="label") -IOFileHandle_label :: #force_inline proc(self: ^IOFileHandle) -> ^NS.String { +IOFileHandle_label :: #force_inline proc "c" (self: ^IOFileHandle) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=IOFileHandle, objc_name="setLabel") -IOFileHandle_setLabel :: #force_inline proc(self: ^IOFileHandle, label: ^NS.String) { +IOFileHandle_setLabel :: #force_inline proc "c" (self: ^IOFileHandle, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @@ -8061,82 +8061,82 @@ IOFileHandle_setLabel :: #force_inline proc(self: ^IOFileHandle, label: ^NS.Stri IOCommandBuffer :: struct { using _: NS.Object } @(objc_type=IOCommandBuffer, objc_name="addCompletedHandler") -IOCommandBuffer_addCompletedHandler :: #force_inline proc(self: ^IOCommandBuffer, block: ^NS.Block) { +IOCommandBuffer_addCompletedHandler :: #force_inline proc "c" (self: ^IOCommandBuffer, block: ^NS.Block) { msgSend(nil, self, "addCompletedHandler:", block) } @(objc_type=IOCommandBuffer, objc_name="loadBytes") -IOCommandBuffer_loadBytes :: #force_inline proc(self: ^IOCommandBuffer, pointer: rawptr, size: NS.UInteger, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { +IOCommandBuffer_loadBytes :: #force_inline proc "c" (self: ^IOCommandBuffer, pointer: rawptr, size: NS.UInteger, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { msgSend(nil, self, "loadBytes:size:sourceHandle:sourceHandleOffset:", pointer, size, sourceHandle, sourceHandleOffset) } @(objc_type=IOCommandBuffer, objc_name="loadBuffer") -IOCommandBuffer_loadBuffer :: #force_inline proc(self: ^IOCommandBuffer, buffer: ^Buffer, offset: NS.UInteger, size: NS.UInteger, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { +IOCommandBuffer_loadBuffer :: #force_inline proc "c" (self: ^IOCommandBuffer, buffer: ^Buffer, offset: NS.UInteger, size: NS.UInteger, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { msgSend(nil, self, "loadBuffer:offset:sourceHandle:sourceHandleOffset:", buffer, offset, size, sourceHandle, sourceHandleOffset) } @(objc_type=IOCommandBuffer, objc_name="loadTexture") -IOCommandBuffer_loadTexture :: #force_inline proc(self: ^IOCommandBuffer, texture: ^Texture, slice: NS.UInteger, level, size, sourceBytesPerRow, sourceBytesPerImage: NS.UInteger, destinationOrigin: Origin, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { +IOCommandBuffer_loadTexture :: #force_inline proc "c" (self: ^IOCommandBuffer, texture: ^Texture, slice: NS.UInteger, level, size, sourceBytesPerRow, sourceBytesPerImage: NS.UInteger, destinationOrigin: Origin, sourceHandle: ^IOFileHandle, sourceHandleOffset: NS.UInteger) { msgSend(nil, self, "loadTexture:slice:level:size:sourceBytesPerRow:sourceBytesPerImage:destinationOrigin:sourceHandle:sourceHandleOffset:", texture, slice, level, size, sourceBytesPerRow, sourceBytesPerImage, destinationOrigin, sourceHandle, sourceHandleOffset) } @(objc_type=IOCommandBuffer, objc_name="copyStatusToBuffer") -IOCommandBuffer_copyStatusToBuffer :: #force_inline proc(self: ^IOCommandBuffer, buffer: ^Buffer, offset: NS.UInteger) { +IOCommandBuffer_copyStatusToBuffer :: #force_inline proc "c" (self: ^IOCommandBuffer, buffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "copyStatusToBuffer:offset:", buffer, offset) } @(objc_type=IOCommandBuffer, objc_name="commit") -IOCommandBuffer_commit :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_commit :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "commit") } @(objc_type=IOCommandBuffer, objc_name="waitUntilCompleted") -IOCommandBuffer_waitUntilCompleted :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_waitUntilCompleted :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "waitUntilCompleted") } @(objc_type=IOCommandBuffer, objc_name="tryCancel") -IOCommandBuffer_tryCancel :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_tryCancel :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "tryCancel") } @(objc_type=IOCommandBuffer, objc_name="addBarrier") -IOCommandBuffer_addBarrier :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_addBarrier :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "addBarrier") } @(objc_type=IOCommandBuffer, objc_name="enqueue") -IOCommandBuffer_enqueue :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_enqueue :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "enqueue") } @(objc_type=IOCommandBuffer, objc_name="waitForEvent") -IOCommandBuffer_waitForEvent :: #force_inline proc(self: ^IOCommandBuffer, event: ^SharedEvent, value: u64) { +IOCommandBuffer_waitForEvent :: #force_inline proc "c" (self: ^IOCommandBuffer, event: ^SharedEvent, value: u64) { msgSend(nil, self, "waitForEvent:value", event, value) } @(objc_type=IOCommandBuffer, objc_name="signalEvent") -IOCommandBuffer_signalEvent :: #force_inline proc(self: ^IOCommandBuffer, event: ^SharedEvent, value: u64) { +IOCommandBuffer_signalEvent :: #force_inline proc "c" (self: ^IOCommandBuffer, event: ^SharedEvent, value: u64) { msgSend(nil, self, "signalEvent:value", event, value) } @(objc_type=IOCommandBuffer, objc_name="pushDebugGroup") -IOCommandBuffer_pushDebugGroup :: #force_inline proc(self: ^IOCommandBuffer, name: ^NS.String) { +IOCommandBuffer_pushDebugGroup :: #force_inline proc "c" (self: ^IOCommandBuffer, name: ^NS.String) { msgSend(nil, self, "pushDebugGroup:", name) } @(objc_type=IOCommandBuffer, objc_name="popDebugGroup") -IOCommandBuffer_popDebugGroup :: #force_inline proc(self: ^IOCommandBuffer) { +IOCommandBuffer_popDebugGroup :: #force_inline proc "c" (self: ^IOCommandBuffer) { msgSend(nil, self, "popDebugGroup") } @(objc_type=IOCommandBuffer, objc_name="label") -IOCommandBuffer_label :: #force_inline proc(self: ^IOCommandBuffer) -> ^NS.String { +IOCommandBuffer_label :: #force_inline proc "c" (self: ^IOCommandBuffer) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=IOCommandBuffer, objc_name="setLabel") -IOCommandBuffer_setLabel :: #force_inline proc(self: ^IOCommandBuffer, label: ^NS.String) { +IOCommandBuffer_setLabel :: #force_inline proc "c" (self: ^IOCommandBuffer, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=IOCommandBuffer, objc_name="status") -IOCommandBuffer_status :: #force_inline proc(self: ^IOCommandBuffer) -> IOStatus { +IOCommandBuffer_status :: #force_inline proc "c" (self: ^IOCommandBuffer) -> IOStatus { return msgSend(IOStatus, self, "status") } @(objc_type=IOCommandBuffer, objc_name="error") -IOCommandBuffer_error :: #force_inline proc(self: ^IOCommandBuffer) -> ^NS.Error { +IOCommandBuffer_error :: #force_inline proc "c" (self: ^IOCommandBuffer) -> ^NS.Error { return msgSend(^NS.Error, self, "error") } @@ -8170,40 +8170,40 @@ Methods: Library :: struct { using _: NS.Object } @(objc_type=Library, objc_name="device") -Library_device :: #force_inline proc(self: ^Library) -> ^Device { +Library_device :: #force_inline proc "c" (self: ^Library) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Library, objc_name="functionNames") -Library_functionNames :: #force_inline proc(self: ^Library) -> ^NS.Array { +Library_functionNames :: #force_inline proc "c" (self: ^Library) -> ^NS.Array { return msgSend(^NS.Array, self, "functionNames") } @(objc_type=Library, objc_name="installName") -Library_installName :: #force_inline proc(self: ^Library) -> ^NS.String { +Library_installName :: #force_inline proc "c" (self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "installName") } @(objc_type=Library, objc_name="label") -Library_label :: #force_inline proc(self: ^Library) -> ^NS.String { +Library_label :: #force_inline proc "c" (self: ^Library) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Library, objc_name="newFunctionWithCompletionHandler") -Library_newFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: ^NS.Block) -> ^Function { +Library_newFunctionWithCompletionHandler :: #force_inline proc "c" (self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: ^NS.Block) -> ^Function { return msgSend(^Function, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithDescriptor") -Library_newFunctionWithDescriptor :: #force_inline proc(self: ^Library, descriptor: ^FunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { +Library_newFunctionWithDescriptor :: #force_inline proc "contextless" (self: ^Library, descriptor: ^FunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { function = msgSend(^Function, self, "newFunctionWithDescriptor:error:", descriptor, &error) return } @(objc_type=Library, objc_name="newFunctionWithName") -Library_newFunctionWithName :: #force_inline proc(self: ^Library, functionName: ^NS.String) -> ^Function { +Library_newFunctionWithName :: #force_inline proc "c" (self: ^Library, functionName: ^NS.String) -> ^Function { return msgSend(^Function, self, "newFunctionWithName:", functionName) } @(objc_type=Library, objc_name="newFunctionWithConstantValuesAndCompletionHandler") -Library_newFunctionWithConstantValuesAndCompletionHandler :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: ^NS.Block) -> ^Function { +Library_newFunctionWithConstantValuesAndCompletionHandler :: #force_inline proc "c" (self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: ^NS.Block) -> ^Function { return msgSend(^Function, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler) } @(objc_type=Library, objc_name="newFunctionWithConstantValues") -Library_newFunctionWithConstantValues :: #force_inline proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (function: ^Function, error: ^NS.Error) { +Library_newFunctionWithConstantValues :: #force_inline proc "contextless" (self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues) -> (function: ^Function, error: ^NS.Error) { function = msgSend(^Function, self, "newFunctionWithName:constantValues:error:", name, constantValues, &error) return } @@ -8217,20 +8217,20 @@ Library_newFunction :: proc{ } @(objc_type=Library, objc_name="newIntersectionFunctionWithCompletionHandler") -Library_newIntersectionFunctionWithCompletionHandler :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: ^NS.Block) -> ^Function { +Library_newIntersectionFunctionWithCompletionHandler :: #force_inline proc "c" (self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: ^NS.Block) -> ^Function { return msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler) } @(objc_type=Library, objc_name="newIntersectionFunction") -Library_newIntersectionFunction :: #force_inline proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { +Library_newIntersectionFunction :: #force_inline proc "contextless" (self: ^Library, descriptor: ^IntersectionFunctionDescriptor) -> (function: ^Function, error: ^NS.Error) { function = msgSend(^Function, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, &error) return } @(objc_type=Library, objc_name="setLabel") -Library_setLabel :: #force_inline proc(self: ^Library, label: ^NS.String) { +Library_setLabel :: #force_inline proc "c" (self: ^Library, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Library, objc_name="type") -Library_type :: #force_inline proc(self: ^Library) -> LibraryType { +Library_type :: #force_inline proc "c" (self: ^Library) -> LibraryType { return msgSend(LibraryType, self, "type") } @@ -8253,31 +8253,31 @@ Methods: ParallelRenderCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder") -ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc(self: ^ParallelRenderCommandEncoder) -> ^RenderCommandEncoder { +ParallelRenderCommandEncoder_renderCommandEncoder :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder) -> ^RenderCommandEncoder { return msgSend(^RenderCommandEncoder, self, "renderCommandEncoder") } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction") -ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { +ParallelRenderCommandEncoder_setColorStoreAction :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreActionOptions") -ParallelRenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { +ParallelRenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreAction") -ParallelRenderCommandEncoder_setDepthStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { +ParallelRenderCommandEncoder_setDepthStoreAction :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setDepthStoreAction:", storeAction) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreActionOptions") -ParallelRenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { +ParallelRenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreAction") -ParallelRenderCommandEncoder_setStencilStoreAction :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { +ParallelRenderCommandEncoder_setStencilStoreAction :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setStencilStoreAction:", storeAction) } @(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreActionOptions") -ParallelRenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { +ParallelRenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc "c" (self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) } @@ -8303,44 +8303,44 @@ Methods: RasterizationRateMap :: struct { using _: NS.Object } @(objc_type=RasterizationRateMap, objc_name="copyParameterDataToBuffer") -RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc(self: ^RasterizationRateMap, buffer: ^Buffer, offset: NS.UInteger) { +RasterizationRateMap_copyParameterDataToBuffer :: #force_inline proc "c" (self: ^RasterizationRateMap, buffer: ^Buffer, offset: NS.UInteger) { msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset) } @(objc_type=RasterizationRateMap, objc_name="device") -RasterizationRateMap_device :: #force_inline proc(self: ^RasterizationRateMap) -> ^Device { +RasterizationRateMap_device :: #force_inline proc "c" (self: ^RasterizationRateMap) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=RasterizationRateMap, objc_name="label") -RasterizationRateMap_label :: #force_inline proc(self: ^RasterizationRateMap) -> ^NS.String { +RasterizationRateMap_label :: #force_inline proc "c" (self: ^RasterizationRateMap) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RasterizationRateMap, objc_name="layerCount") -RasterizationRateMap_layerCount :: #force_inline proc(self: ^RasterizationRateMap) -> NS.UInteger { +RasterizationRateMap_layerCount :: #force_inline proc "c" (self: ^RasterizationRateMap) -> NS.UInteger { return msgSend(NS.UInteger, self, "layerCount") } @(objc_type=RasterizationRateMap, objc_name="mapPhysicalToScreenCoordinates") -RasterizationRateMap_mapPhysicalToScreenCoordinates :: #force_inline proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { +RasterizationRateMap_mapPhysicalToScreenCoordinates :: #force_inline proc "c" (self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapPhysicalToScreenCoordinates:forLayer:", physicalCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="mapScreenToPhysicalCoordinates") -RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { +RasterizationRateMap_mapScreenToPhysicalCoordinates :: #force_inline proc "c" (self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: NS.UInteger) -> Coordinate2D { return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex) } @(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign") -RasterizationRateMap_parameterBufferSizeAndAlign :: #force_inline proc(self: ^RasterizationRateMap) -> (size, align: NS.UInteger) { +RasterizationRateMap_parameterBufferSizeAndAlign :: #force_inline proc "c" (self: ^RasterizationRateMap) -> (size, align: NS.UInteger) { res := msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign") return res.size, res.align } @(objc_type=RasterizationRateMap, objc_name="physicalGranularity") -RasterizationRateMap_physicalGranularity :: #force_inline proc(self: ^RasterizationRateMap) -> Size { +RasterizationRateMap_physicalGranularity :: #force_inline proc "c" (self: ^RasterizationRateMap) -> Size { return msgSend(Size, self, "physicalGranularity") } @(objc_type=RasterizationRateMap, objc_name="physicalSizeForLayer") -RasterizationRateMap_physicalSizeForLayer :: #force_inline proc(self: ^RasterizationRateMap, layerIndex: NS.UInteger) -> Size { +RasterizationRateMap_physicalSizeForLayer :: #force_inline proc "c" (self: ^RasterizationRateMap, layerIndex: NS.UInteger) -> Size { return msgSend(Size, self, "physicalSizeForLayer:", layerIndex) } @(objc_type=RasterizationRateMap, objc_name="screenSize") -RasterizationRateMap_screenSize :: #force_inline proc(self: ^RasterizationRateMap) -> Size { +RasterizationRateMap_screenSize :: #force_inline proc "c" (self: ^RasterizationRateMap) -> Size { return msgSend(Size, self, "screenSize") } @@ -8442,447 +8442,447 @@ Methods: RenderCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=RenderCommandEncoder, objc_name="dispatchThreadsPerTile") -RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc(self: ^RenderCommandEncoder, threadsPerTile: Size) { +RenderCommandEncoder_dispatchThreadsPerTile :: #force_inline proc "c" (self: ^RenderCommandEncoder, threadsPerTile: Size) { msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatchesWihtIndirect") -RenderCommandEncoder_drawIndexedPatchesWihtIndirect :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +RenderCommandEncoder_drawIndexedPatchesWihtIndirect :: #force_inline proc "c" (self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexPatchesWithInstances") -RenderCommandEncoder_drawIndexPatchesWithInstance :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawIndexPatchesWithInstance :: #force_inline proc "c" (self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, controlPointIndexBuffer: ^Buffer, controlPointIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives") -RenderCommandEncoder_drawIndexedPrimitives :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger) { +RenderCommandEncoder_drawIndexedPrimitives :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitivesWithInstanceCount") -RenderCommandEncoder_drawIndexedPrimitivesWithInstanceCount :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger) { +RenderCommandEncoder_drawIndexedPrimitivesWithInstanceCount :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexPrimitivesWithBaseVertex") -RenderCommandEncoder_drawIndexPrimitivesWithBaseVertex :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawIndexPrimitivesWithBaseVertex :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: NS.UInteger, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseVertex: NS.Integer, baseInstance: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawIndexPrimitivesWithIndirect") -RenderCommandEncoder_drawIndexPrimitivesWithIndirect :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +RenderCommandEncoder_drawIndexPrimitivesWithIndirect :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^Buffer, indexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatches") -RenderCommandEncoder_drawPatches :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +RenderCommandEncoder_drawPatches :: #force_inline proc "c" (self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPatchesWithInstances") -RenderCommandEncoder_drawPatchesWithInstance :: #force_inline proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawPatchesWithInstance :: #force_inline proc "c" (self: ^RenderCommandEncoder, numberOfPatchControlPoints: NS.UInteger, patchStart, patchCount: NS.UInteger, patchIndexBuffer: ^Buffer, patchIndexBufferOffset: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithIndirect") -RenderCommandEncoder_drawPrimitivesWithIndirect :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +RenderCommandEncoder_drawPrimitivesWithIndirect :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitives") -RenderCommandEncoder_drawPrimitives :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger) { +RenderCommandEncoder_drawPrimitives :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithInstanceCount") -RenderCommandEncoder_drawPrimitivesWithInstanceCount :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger) { +RenderCommandEncoder_drawPrimitivesWithInstanceCount :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount) } @(objc_type=RenderCommandEncoder, objc_name="drawPrimitivesWithInstances") -RenderCommandEncoder_drawPrimitivesWithInstances :: #force_inline proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { +RenderCommandEncoder_drawPrimitivesWithInstances :: #force_inline proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: NS.UInteger, vertexCount: NS.UInteger, instanceCount: NS.UInteger, baseInstance: NS.UInteger) { msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance) } @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer") -RenderCommandEncoder_executeCommandsInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +RenderCommandEncoder_executeCommandsInBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset) } @(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBufferWithRange") -RenderCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { +RenderCommandEncoder_executeCommandsInBufferWithRange :: #force_inline proc "c" (self: ^RenderCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: NS.Range) { msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources") -RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, after: RenderStages, before: RenderStages) { +RenderCommandEncoder_memoryBarrierWithResources :: #force_inline proc "c" (self: ^RenderCommandEncoder, resources: []^Resource, after: RenderStages, before: RenderStages) { msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", raw_data(resources), NS.UInteger(len(resources)), after, before) } @(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope") -RenderCommandEncoder_memoryBarrierWithScope :: #force_inline proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { +RenderCommandEncoder_memoryBarrierWithScope :: #force_inline proc "c" (self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) { msgSend(nil, self, "memoryBarrierWithScope:afterStages:beforeStages:", scope, after, before) } @(objc_type=RenderCommandEncoder, objc_name="sampleCountersInBuffer") -RenderCommandEncoder_sampleCountersInBuffer :: #force_inline proc(self: ^RenderCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { +RenderCommandEncoder_sampleCountersInBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: NS.UInteger, barrier: BOOL) { msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier) } @(objc_type=RenderCommandEncoder, objc_name="setBlendColorRed") -RenderCommandEncoder_setBlendColorRed :: #force_inline proc(self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) { +RenderCommandEncoder_setBlendColorRed :: #force_inline proc "c" (self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) { msgSend(nil, self, "setBlendColorRed:green:blue:alpha:", red, green, blue, alpha) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreAction") -RenderCommandEncoder_setColorStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { +RenderCommandEncoder_setColorStoreAction :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setColorStoreActionOptions") -RenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { +RenderCommandEncoder_setColorStoreActionOptions :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: NS.UInteger) { msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex) } @(objc_type=RenderCommandEncoder, objc_name="setCullMode") -RenderCommandEncoder_setCullMode :: #force_inline proc(self: ^RenderCommandEncoder, cullMode: CullMode) { +RenderCommandEncoder_setCullMode :: #force_inline proc "c" (self: ^RenderCommandEncoder, cullMode: CullMode) { msgSend(nil, self, "setCullMode:", cullMode) } @(objc_type=RenderCommandEncoder, objc_name="setDepthBias") -RenderCommandEncoder_setDepthBias :: #force_inline proc(self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) { +RenderCommandEncoder_setDepthBias :: #force_inline proc "c" (self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) { msgSend(nil, self, "setDepthBias:slopeScale:clamp:", depthBias, slopeScale, clamp) } @(objc_type=RenderCommandEncoder, objc_name="setDepthClipMode") -RenderCommandEncoder_setDepthClipMode :: #force_inline proc(self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) { +RenderCommandEncoder_setDepthClipMode :: #force_inline proc "c" (self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) { msgSend(nil, self, "setDepthClipMode:", depthClipMode) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStencilState") -RenderCommandEncoder_setDepthStencilState :: #force_inline proc(self: ^RenderCommandEncoder, depthStencilState: ^DepthStencilState) { +RenderCommandEncoder_setDepthStencilState :: #force_inline proc "c" (self: ^RenderCommandEncoder, depthStencilState: ^DepthStencilState) { msgSend(nil, self, "setDepthStencilState:", depthStencilState) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStoreAction") -RenderCommandEncoder_setDepthStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { +RenderCommandEncoder_setDepthStoreAction :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setDepthStoreAction:", storeAction) } @(objc_type=RenderCommandEncoder, objc_name="setDepthStoreActionOptions") -RenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { +RenderCommandEncoder_setDepthStoreActionOptions :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffer") -RenderCommandEncoder_setFragmentBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setFragmentBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBufferOffset") -RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setFragmentBufferOffset :: #force_inline proc "c" (self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers") -RenderCommandEncoder_setFragmentBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +RenderCommandEncoder_setFragmentBuffers :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes") -RenderCommandEncoder_setFragmentBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { +RenderCommandEncoder_setFragmentBytes :: #force_inline proc "c" (self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { msgSend(nil, self, "setFragmentBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState") -RenderCommandEncoder_setFragmentSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +RenderCommandEncoder_setFragmentSamplerState :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStateWithLod") -RenderCommandEncoder_setFragmentSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +RenderCommandEncoder_setFragmentSamplerStateWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithLod") -RenderCommandEncoder_setFragmentSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { +RenderCommandEncoder_setFragmentSamplerStatesWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStatesWithRange") -RenderCommandEncoder_setFragmentSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { +RenderCommandEncoder_setFragmentSamplerStatesWithRange :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { msgSend(nil, self, "setFragmentSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture") -RenderCommandEncoder_setFragmentTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { +RenderCommandEncoder_setFragmentTexture :: #force_inline proc "c" (self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures") -RenderCommandEncoder_setFragmentTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { +RenderCommandEncoder_setFragmentTextures :: #force_inline proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { msgSend(nil, self, "setFragmentTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding") -RenderCommandEncoder_setFrontFacingWinding :: #force_inline proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) { +RenderCommandEncoder_setFrontFacingWinding :: #force_inline proc "c" (self: ^RenderCommandEncoder, frontFacingWinding: Winding) { msgSend(nil, self, "setFrontFacingWinding:", frontFacingWinding) } @(objc_type=RenderCommandEncoder, objc_name="setRenderPipelineState") -RenderCommandEncoder_setRenderPipelineState :: #force_inline proc(self: ^RenderCommandEncoder, pipelineState: ^RenderPipelineState) { +RenderCommandEncoder_setRenderPipelineState :: #force_inline proc "c" (self: ^RenderCommandEncoder, pipelineState: ^RenderPipelineState) { msgSend(nil, self, "setRenderPipelineState:", pipelineState) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRect") -RenderCommandEncoder_setScissorRect :: #force_inline proc(self: ^RenderCommandEncoder, rect: ScissorRect) { +RenderCommandEncoder_setScissorRect :: #force_inline proc "c" (self: ^RenderCommandEncoder, rect: ScissorRect) { msgSend(nil, self, "setScissorRect:", rect) } @(objc_type=RenderCommandEncoder, objc_name="setScissorRects") -RenderCommandEncoder_setScissorRects :: #force_inline proc(self: ^RenderCommandEncoder, scissorRects: []ScissorRect) { +RenderCommandEncoder_setScissorRects :: #force_inline proc "c" (self: ^RenderCommandEncoder, scissorRects: []ScissorRect) { msgSend(nil, self, "setScissorRects:count:", raw_data(scissorRects), NS.UInteger(len(scissorRects))) } @(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue") -RenderCommandEncoder_setStencilFrontReferenceValue :: #force_inline proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { +RenderCommandEncoder_setStencilFrontReferenceValue :: #force_inline proc "c" (self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) { msgSend(nil, self, "setStencilFrontReferenceValue:backReferenceValue:", frontReferenceValue, backReferenceValue) } @(objc_type=RenderCommandEncoder, objc_name="setStencilReferenceValue") -RenderCommandEncoder_setStencilReferenceValue :: #force_inline proc(self: ^RenderCommandEncoder, referenceValue: u32) { +RenderCommandEncoder_setStencilReferenceValue :: #force_inline proc "c" (self: ^RenderCommandEncoder, referenceValue: u32) { msgSend(nil, self, "setStencilReferenceValue:", referenceValue) } @(objc_type=RenderCommandEncoder, objc_name="setStencilStoreAction") -RenderCommandEncoder_setStencilStoreAction :: #force_inline proc(self: ^RenderCommandEncoder, storeAction: StoreAction) { +RenderCommandEncoder_setStencilStoreAction :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction) { msgSend(nil, self, "setStencilStoreAction:", storeAction) } @(objc_type=RenderCommandEncoder, objc_name="setStencilStoreActionOptions") -RenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { +RenderCommandEncoder_setStencilStoreActionOptions :: #force_inline proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) { msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorBuffer") -RenderCommandEncoder_setTessellationFactorBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { +RenderCommandEncoder_setTessellationFactorBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, instanceStride: NS.UInteger) { msgSend(nil, self, "setTessellationFactorBuffer:offset:instanceStride:", buffer, offset, instanceStride) } @(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorScale") -RenderCommandEncoder_setTessellationFactorScale :: #force_inline proc(self: ^RenderCommandEncoder, scale: f32) { +RenderCommandEncoder_setTessellationFactorScale :: #force_inline proc "c" (self: ^RenderCommandEncoder, scale: f32) { msgSend(nil, self, "setTessellationFactorScale:", scale) } @(objc_type=RenderCommandEncoder, objc_name="setThreadgroupMemoryLength") -RenderCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc(self: ^RenderCommandEncoder, length: NS.UInteger, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setThreadgroupMemoryLength :: #force_inline proc "c" (self: ^RenderCommandEncoder, length: NS.UInteger, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setThreadgroupMemoryLength:offset:atIndex:", length, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffer") -RenderCommandEncoder_setTileBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setTileBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setTileBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBufferOffset") -RenderCommandEncoder_setTileBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setTileBufferOffset :: #force_inline proc "c" (self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileBuffers") -RenderCommandEncoder_setTileBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +RenderCommandEncoder_setTileBuffers :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { msgSend(nil, self, "setTileBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileBytes") -RenderCommandEncoder_setTileBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { +RenderCommandEncoder_setTileBytes :: #force_inline proc "c" (self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { msgSend(nil, self, "setTileBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState") -RenderCommandEncoder_setTileSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +RenderCommandEncoder_setTileSamplerState :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStateWithLod") -RenderCommandEncoder_setTileSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +RenderCommandEncoder_setTileSamplerStateWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStatesWithLod") -RenderCommandEncoder_setTileSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { +RenderCommandEncoder_setTileSamplerStatesWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStatesWithRange") -RenderCommandEncoder_setTileSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { +RenderCommandEncoder_setTileSamplerStatesWithRange :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { msgSend(nil, self, "setTileSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setTileTexture") -RenderCommandEncoder_setTileTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { +RenderCommandEncoder_setTileTexture :: #force_inline proc "c" (self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setTileTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setTileTextures") -RenderCommandEncoder_setTileTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { +RenderCommandEncoder_setTileTextures :: #force_inline proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { msgSend(nil, self, "setTileTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode") -RenderCommandEncoder_setTriangleFillMode :: #force_inline proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { +RenderCommandEncoder_setTriangleFillMode :: #force_inline proc "c" (self: ^RenderCommandEncoder, fillMode: TriangleFillMode) { msgSend(nil, self, "setTriangleFillMode:", fillMode) } @(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount") -RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc(self: ^RenderCommandEncoder, viewMappings: []VertexAmplificationViewMapping) { +RenderCommandEncoder_setVertexAmplificationCount :: #force_inline proc "c" (self: ^RenderCommandEncoder, viewMappings: []VertexAmplificationViewMapping) { msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", NS.UInteger(len(viewMappings)), raw_data(viewMappings)) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer") -RenderCommandEncoder_setVertexBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setVertexBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBufferOffset") -RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setVertexBufferOffset :: #force_inline proc "c" (self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers") -RenderCommandEncoder_setVertexBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { +RenderCommandEncoder_setVertexBuffers :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffers: []^Buffer, offsets: []NS.UInteger, range: NS.Range) { msgSend(nil, self, "setVertexBuffers:offsets:withRange:", raw_data(buffers), raw_data(offsets), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexBytes") -RenderCommandEncoder_setVertexBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { +RenderCommandEncoder_setVertexBytes :: #force_inline proc "c" (self: ^RenderCommandEncoder, bytes: []byte, index: NS.UInteger) { msgSend(nil, self, "setVertexBytes:length:atIndex:", raw_data(bytes), NS.UInteger(len(bytes)), index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState") -RenderCommandEncoder_setVertexSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +RenderCommandEncoder_setVertexSamplerState :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStateWithLod") -RenderCommandEncoder_setVertexSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { +RenderCommandEncoder_setVertexSamplerStateWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStatesWithLod") -RenderCommandEncoder_setVertexSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { +RenderCommandEncoder_setVertexSamplerStatesWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", raw_data(samplers), raw_data(lodMinClamps), raw_data(lodMaxClamps), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStatesWithRange") -RenderCommandEncoder_setVertexSamplerStatesWithRange :: #force_inline proc(self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { +RenderCommandEncoder_setVertexSamplerStatesWithRange :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: NS.Range) { msgSend(nil, self, "setVertexSamplerStates:withRange:", raw_data(samplers), range) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTexture") -RenderCommandEncoder_setVertexTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { +RenderCommandEncoder_setVertexTexture :: #force_inline proc "c" (self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setVertexTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setVertexTextures") -RenderCommandEncoder_setVertexTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { +RenderCommandEncoder_setVertexTextures :: #force_inline proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: NS.Range) { msgSend(nil, self, "setVertexTextures:withRange:", raw_data(textures), range) } @(objc_type=RenderCommandEncoder, objc_name="setViewport") -RenderCommandEncoder_setViewport :: #force_inline proc(self: ^RenderCommandEncoder, viewport: Viewport) { +RenderCommandEncoder_setViewport :: #force_inline proc "c" (self: ^RenderCommandEncoder, viewport: Viewport) { msgSend(nil, self, "setViewport:", viewport) } @(objc_type=RenderCommandEncoder, objc_name="setViewports") -RenderCommandEncoder_setViewports :: #force_inline proc(self: ^RenderCommandEncoder, viewports: []Viewport) { +RenderCommandEncoder_setViewports :: #force_inline proc "c" (self: ^RenderCommandEncoder, viewports: []Viewport) { msgSend(nil, self, "setViewports:count:", raw_data(viewports), NS.UInteger(len(viewports))) } @(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode") -RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: NS.UInteger) { +RenderCommandEncoder_setVisibilityResultMode :: #force_inline proc "c" (self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: NS.UInteger) { msgSend(nil, self, "setVisibilityResultMode:offset:", mode, offset) } @(objc_type=RenderCommandEncoder, objc_name="textureBarrier") -RenderCommandEncoder_textureBarrier :: #force_inline proc(self: ^RenderCommandEncoder) { +RenderCommandEncoder_textureBarrier :: #force_inline proc "c" (self: ^RenderCommandEncoder) { msgSend(nil, self, "textureBarrier") } @(objc_type=RenderCommandEncoder, objc_name="tileHeight") -RenderCommandEncoder_tileHeight :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.UInteger { +RenderCommandEncoder_tileHeight :: #force_inline proc "c" (self: ^RenderCommandEncoder) -> NS.UInteger { return msgSend(NS.UInteger, self, "tileHeight") } @(objc_type=RenderCommandEncoder, objc_name="tileWidth") -RenderCommandEncoder_tileWidth :: #force_inline proc(self: ^RenderCommandEncoder) -> NS.UInteger { +RenderCommandEncoder_tileWidth :: #force_inline proc "c" (self: ^RenderCommandEncoder) -> NS.UInteger { return msgSend(NS.UInteger, self, "tileWidth") } @(objc_type=RenderCommandEncoder, objc_name="updateFence") -RenderCommandEncoder_updateFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { +RenderCommandEncoder_updateFence :: #force_inline proc "c" (self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { msgSend(nil, self, "updateFence:afterStages:", fence, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeap") -RenderCommandEncoder_useHeap :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap) { +RenderCommandEncoder_useHeap :: #force_inline proc "c" (self: ^RenderCommandEncoder, heap: ^Heap) { msgSend(nil, self, "useHeap:", heap) } @(objc_type=RenderCommandEncoder, objc_name="useHeapWithStages") -RenderCommandEncoder_useHeapWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heap: ^Heap, stages: RenderStages) { +RenderCommandEncoder_useHeapWithStages :: #force_inline proc "c" (self: ^RenderCommandEncoder, heap: ^Heap, stages: RenderStages) { msgSend(nil, self, "useHeap:stages:", heap, stages) } @(objc_type=RenderCommandEncoder, objc_name="useHeaps") -RenderCommandEncoder_useHeaps :: #force_inline proc(self: ^RenderCommandEncoder, heaps: []^Heap) { +RenderCommandEncoder_useHeaps :: #force_inline proc "c" (self: ^RenderCommandEncoder, heaps: []^Heap) { msgSend(nil, self, "useHeaps:count:", raw_data(heaps), NS.UInteger(len(heaps))) } @(objc_type=RenderCommandEncoder, objc_name="useHeapsWithStages") -RenderCommandEncoder_useHeapsWithStages :: #force_inline proc(self: ^RenderCommandEncoder, heaps: []^Heap, stages: RenderStages) { +RenderCommandEncoder_useHeapsWithStages :: #force_inline proc "c" (self: ^RenderCommandEncoder, heaps: []^Heap, stages: RenderStages) { msgSend(nil, self, "useHeaps:count:stages:", raw_data(heaps), NS.UInteger(len(heaps)), stages) } @(objc_type=RenderCommandEncoder, objc_name="useResource") -RenderCommandEncoder_useResource :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage) { +RenderCommandEncoder_useResource :: #force_inline proc "c" (self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResource:usage:", resource, usage) } @(objc_type=RenderCommandEncoder, objc_name="useResourceWithStages") -RenderCommandEncoder_useResourceWithStages :: #force_inline proc(self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResourceWithStages :: #force_inline proc "c" (self: ^RenderCommandEncoder, resource: ^Resource, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="useResources") -RenderCommandEncoder_useResources :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage) { +RenderCommandEncoder_useResources :: #force_inline proc "c" (self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage) { msgSend(nil, self, "useResources:count:usage:", raw_data(resources), NS.UInteger(len(resources)), usage) } @(objc_type=RenderCommandEncoder, objc_name="useResourcesStages") -RenderCommandEncoder_useResourcesStages :: #force_inline proc(self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage, stages: RenderStages) { +RenderCommandEncoder_useResourcesStages :: #force_inline proc "c" (self: ^RenderCommandEncoder, resources: []^Resource, usage: ResourceUsage, stages: RenderStages) { msgSend(nil, self, "useResources:count:usage:stages:", raw_data(resources), NS.UInteger(len(resources)), usage, stages) } @(objc_type=RenderCommandEncoder, objc_name="waitForFence") -RenderCommandEncoder_waitForFence :: #force_inline proc(self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { +RenderCommandEncoder_waitForFence :: #force_inline proc "c" (self: ^RenderCommandEncoder, fence: ^Fence, stages: RenderStages) { msgSend(nil, self, "waitForFence:beforeStages:", fence, stages) } @(objc_type=RenderCommandEncoder, objc_name="setObjectBytes") -RenderCommandEncoder_setObjectBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setObjectBytes :: #force_inline proc "c" (self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setObjectBytes:length:atIndex:", bytes, length, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectBuffer") -RenderCommandEncoder_setObjectBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setObjectBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setObjectBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectBufferOffset") -RenderCommandEncoder_setObjectBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setObjectBufferOffset :: #force_inline proc "c" (self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setObjectBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectBuffers") -RenderCommandEncoder_setObjectBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { +RenderCommandEncoder_setObjectBuffers :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setObjectBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setObjectTexture") -RenderCommandEncoder_setObjectTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { +RenderCommandEncoder_setObjectTexture :: #force_inline proc "c" (self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setObjectTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectTextures") -RenderCommandEncoder_setObjectTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { +RenderCommandEncoder_setObjectTextures :: #force_inline proc "c" (self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setObjectTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setObjectSamplerState") -RenderCommandEncoder_setObjectSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +RenderCommandEncoder_setObjectSamplerState :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setObjectSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectSamplerStates") -RenderCommandEncoder_setObjectSamplerStates :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { +RenderCommandEncoder_setObjectSamplerStates :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setObjectSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setObjectSamplerStateWithLod") -RenderCommandEncoder_setObjectSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp, lodMaxClamp: f32, index: NS.UInteger) { +RenderCommandEncoder_setObjectSamplerStateWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setObjectSamplerStatesWithLod") -RenderCommandEncoder_setObjectSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: NS.Range) { +RenderCommandEncoder_setObjectSamplerStatesWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: NS.Range) { msgSend(nil, self, "setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=RenderCommandEncoder, objc_name="setObjectThreadgroupMemoryLength") -RenderCommandEncoder_setObjectThreadgroupMemoryLength :: #force_inline proc(self: ^RenderCommandEncoder, length: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setObjectThreadgroupMemoryLength :: #force_inline proc "c" (self: ^RenderCommandEncoder, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setObjectThreadgroupMemoryLength:atIndex:", length, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshBytes") -RenderCommandEncoder_setMeshBytes :: #force_inline proc(self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setMeshBytes :: #force_inline proc "c" (self: ^RenderCommandEncoder, bytes: rawptr, length: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setMeshBytes:atIndex:", bytes, length, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshBuffer") -RenderCommandEncoder_setMeshBuffer :: #force_inline proc(self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setMeshBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setMeshBuffer:offset:atIndex:", buffer, offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshBufferOffset") -RenderCommandEncoder_setMeshBufferOffset :: #force_inline proc(self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { +RenderCommandEncoder_setMeshBufferOffset :: #force_inline proc "c" (self: ^RenderCommandEncoder, offset: NS.UInteger, index: NS.UInteger) { msgSend(nil, self, "setMeshBufferOffset:atIndex:", offset, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshBuffers") -RenderCommandEncoder_setMeshBuffers :: #force_inline proc(self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { +RenderCommandEncoder_setMeshBuffers :: #force_inline proc "c" (self: ^RenderCommandEncoder, buffers: [^]^Buffer, offsets: [^]NS.UInteger, range: NS.Range) { msgSend(nil, self, "setMeshBuffers:offsets:withRange:", buffers, offsets, range) } @(objc_type=RenderCommandEncoder, objc_name="setMeshTexture") -RenderCommandEncoder_setMeshTexture :: #force_inline proc(self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { +RenderCommandEncoder_setMeshTexture :: #force_inline proc "c" (self: ^RenderCommandEncoder, texture: ^Texture, index: NS.UInteger) { msgSend(nil, self, "setMeshTexture:atIndex:", texture, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshTextures") -RenderCommandEncoder_setMeshTextures :: #force_inline proc(self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { +RenderCommandEncoder_setMeshTextures :: #force_inline proc "c" (self: ^RenderCommandEncoder, textures: [^]^Texture, range: NS.Range) { msgSend(nil, self, "setMeshTextures:withRange:", textures, range) } @(objc_type=RenderCommandEncoder, objc_name="setMeshSamplerState") -RenderCommandEncoder_setMeshSamplerState :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { +RenderCommandEncoder_setMeshSamplerState :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, index: NS.UInteger) { msgSend(nil, self, "setMeshSamplerState:atIndex:", sampler, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshSamplerStates") -RenderCommandEncoder_setMeshSamplerStates :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { +RenderCommandEncoder_setMeshSamplerStates :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: NS.Range) { msgSend(nil, self, "setMeshSamplerStates:withRange:", samplers, range) } @(objc_type=RenderCommandEncoder, objc_name="setMeshSamplerStateWithLod") -RenderCommandEncoder_setMeshSamplerStateWithLod :: #force_inline proc(self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp, lodMaxClamp: f32, index: NS.UInteger) { +RenderCommandEncoder_setMeshSamplerStateWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp, lodMaxClamp: f32, index: NS.UInteger) { msgSend(nil, self, "setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index) } @(objc_type=RenderCommandEncoder, objc_name="setMeshSamplerStatesWithLod") -RenderCommandEncoder_setMeshSamplerStatesWithLod :: #force_inline proc(self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: NS.Range) { +RenderCommandEncoder_setMeshSamplerStatesWithLod :: #force_inline proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: NS.Range) { msgSend(nil, self, "setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range) } @(objc_type=RenderCommandEncoder, objc_name="drawMeshThreadgroups") -RenderCommandEncoder_drawMeshThreadgroups :: #force_inline proc(self: ^RenderCommandEncoder, threadgroupsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { +RenderCommandEncoder_drawMeshThreadgroups :: #force_inline proc "c" (self: ^RenderCommandEncoder, threadgroupsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { msgSend(nil, self, "drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:", threadgroupsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup) } @(objc_type=RenderCommandEncoder, objc_name="drawMeshThreads") -RenderCommandEncoder_drawMeshThreads :: #force_inline proc(self: ^RenderCommandEncoder, threadsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { +RenderCommandEncoder_drawMeshThreads :: #force_inline proc "c" (self: ^RenderCommandEncoder, threadsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { msgSend(nil, self, "drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:", threadsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup) } @(objc_type=RenderCommandEncoder, objc_name="drawMeshThreadgroupsWithIndirectBuffer") -RenderCommandEncoder_drawMeshThreadgroupsWithIndirectBuffer :: #force_inline proc(self: ^RenderCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { +RenderCommandEncoder_drawMeshThreadgroupsWithIndirectBuffer :: #force_inline proc "c" (self: ^RenderCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) { msgSend(nil, self, "drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:", indirectBuffer, indirectBufferOffset, threadPerObjectThreadgroup, threadsPerMeshThreadgroup) } @@ -8898,38 +8898,38 @@ Class: RenderPipelineFunctionsDescriptor :: struct { using _: NS.Copying(RenderPipelineFunctionsDescriptor) } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="alloc", objc_is_class_method=true) -RenderPipelineFunctionsDescriptor_alloc :: #force_inline proc() -> ^RenderPipelineFunctionsDescriptor { +RenderPipelineFunctionsDescriptor_alloc :: #force_inline proc "c" () -> ^RenderPipelineFunctionsDescriptor { return msgSend(^RenderPipelineFunctionsDescriptor, RenderPipelineFunctionsDescriptor, "alloc") } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="init") -RenderPipelineFunctionsDescriptor_init :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^RenderPipelineFunctionsDescriptor { +RenderPipelineFunctionsDescriptor_init :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^RenderPipelineFunctionsDescriptor { return msgSend(^RenderPipelineFunctionsDescriptor, self, "init") } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="vertexAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_vertexAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { +RenderPipelineFunctionsDescriptor_vertexAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "vertexAdditionalBinaryFunctions") } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="fragmentAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_fragmentAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { +RenderPipelineFunctionsDescriptor_fragmentAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "fragmentAdditionalBinaryFunctions") } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="tileAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_tileAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { +RenderPipelineFunctionsDescriptor_tileAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^NS.Array { return msgSend(^NS.Array, self, "tileAdditionalBinaryFunctions") } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setVertexAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_setVertexAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { +RenderPipelineFunctionsDescriptor_setVertexAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { msgSend(nil, self, "setVertexAdditionalBinaryFunctions:", binaryFunctions) } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setFragmentAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_setFragmentAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { +RenderPipelineFunctionsDescriptor_setFragmentAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { msgSend(nil, self, "setFragmentAdditionalBinaryFunctions:", binaryFunctions) } @(objc_type=RenderPipelineFunctionsDescriptor, objc_name="setTileAdditionalBinaryFunctions") -RenderPipelineFunctionsDescriptor_setTileAdditionalBinaryFunctions :: #force_inline proc(self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { +RenderPipelineFunctionsDescriptor_setTileAdditionalBinaryFunctions :: #force_inline proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^NS.Array) { msgSend(nil, self, "tileAdditionalBinaryFunctions:", binaryFunctions) } @@ -8952,78 +8952,78 @@ Methods: RenderPipelineState :: struct { using _: NS.Object } @(objc_type=RenderPipelineState, objc_name="device") -RenderPipelineState_device :: #force_inline proc(self: ^RenderPipelineState) -> ^Device { +RenderPipelineState_device :: #force_inline proc "c" (self: ^RenderPipelineState) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions") -RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> NS.UInteger { +RenderPipelineState_imageblockMemoryLengthForDimensions :: #force_inline proc "c" (self: ^RenderPipelineState, imageblockDimensions: Size) -> NS.UInteger { return msgSend(NS.UInteger, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions) } @(objc_type=RenderPipelineState, objc_name="imageblockSampleLength") -RenderPipelineState_imageblockSampleLength :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_imageblockSampleLength :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "imageblockSampleLength") } @(objc_type=RenderPipelineState, objc_name="label") -RenderPipelineState_label :: #force_inline proc(self: ^RenderPipelineState) -> ^NS.String { +RenderPipelineState_label :: #force_inline proc "c" (self: ^RenderPipelineState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerThreadgroup") -RenderPipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_maxTotalThreadsPerThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerThreadgroup") } @(objc_type=RenderPipelineState, objc_name="supportIndirectCommandBuffers") -RenderPipelineState_supportIndirectCommandBuffers :: #force_inline proc(self: ^RenderPipelineState) -> BOOL { +RenderPipelineState_supportIndirectCommandBuffers :: #force_inline proc "c" (self: ^RenderPipelineState) -> BOOL { return msgSend(BOOL, self, "supportIndirectCommandBuffers") } @(objc_type=RenderPipelineState, objc_name="threadgroupSizeMatchesTileSize") -RenderPipelineState_threadgroupSizeMatchesTileSize :: #force_inline proc(self: ^RenderPipelineState) -> BOOL { +RenderPipelineState_threadgroupSizeMatchesTileSize :: #force_inline proc "c" (self: ^RenderPipelineState) -> BOOL { return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize") } @(objc_type=RenderPipelineState, objc_name="functionHandle") -RenderPipelineState_functionHandle :: #force_inline proc(self: ^RenderPipelineState, function: ^Function, stage: RenderStages) -> ^FunctionHandle { +RenderPipelineState_functionHandle :: #force_inline proc "c" (self: ^RenderPipelineState, function: ^Function, stage: RenderStages) -> ^FunctionHandle { return msgSend(^FunctionHandle, self, "functionHandleWithFunction:stage:", function, stage) } @(objc_type=RenderPipelineState, objc_name="newVisibleFunctionTable") -RenderPipelineState_newVisibleFunctionTable :: #force_inline proc(self: ^RenderPipelineState, descriptor: ^VisibleFunctionTableDescriptor, stage: RenderStages) -> ^VisibleFunctionTable { +RenderPipelineState_newVisibleFunctionTable :: #force_inline proc "c" (self: ^RenderPipelineState, descriptor: ^VisibleFunctionTableDescriptor, stage: RenderStages) -> ^VisibleFunctionTable { return msgSend(^VisibleFunctionTable, self, "newVisibleFunctionTableWithDescriptor:stage:", descriptor, stage) } @(objc_type=RenderPipelineState, objc_name="newIntersectionFunctionTable") -RenderPipelineState_newIntersectionFunctionTable :: #force_inline proc(self: ^RenderPipelineState, descriptor: ^IntersectionFunctionTableDescriptor, stage: RenderStages) -> ^IntersectionFunctionTable { +RenderPipelineState_newIntersectionFunctionTable :: #force_inline proc "c" (self: ^RenderPipelineState, descriptor: ^IntersectionFunctionTableDescriptor, stage: RenderStages) -> ^IntersectionFunctionTable { return msgSend(^IntersectionFunctionTable, self, "newIntersectionFunctionTable:stage:", descriptor, stage) } @(objc_type=RenderPipelineState, objc_name="newRenderPipelineState") -RenderPipelineState_newRenderPipelineState :: #force_inline proc(self: ^RenderPipelineState, additionalBinaryFunctions: ^RenderPipelineFunctionsDescriptor) -> (state: ^RenderPipelineState, error: ^NS.Error) { +RenderPipelineState_newRenderPipelineState :: #force_inline proc "contextless" (self: ^RenderPipelineState, additionalBinaryFunctions: ^RenderPipelineFunctionsDescriptor) -> (state: ^RenderPipelineState, error: ^NS.Error) { state = msgSend(^RenderPipelineState, self, "newRenderPipelineStateWithAdditionalBinaryFunctions:error:", additionalBinaryFunctions, &error) return } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerObjectThreadgroup") -RenderPipelineState_maxTotalThreadsPerObjectThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_maxTotalThreadsPerObjectThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerObjectThreadgroup") } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerMeshThreadgroup") -RenderPipelineState_maxTotalThreadsPerMeshThreadgroup :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_maxTotalThreadsPerMeshThreadgroup :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadsPerMeshThreadgroup") } @(objc_type=RenderPipelineState, objc_name="objectThreadExecutionWidth") -RenderPipelineState_objectThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_objectThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "objectThreadExecutionWidth") } @(objc_type=RenderPipelineState, objc_name="meshThreadExecutionWidth") -RenderPipelineState_meshThreadExecutionWidth :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_meshThreadExecutionWidth :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "meshThreadExecutionWidth") } @(objc_type=RenderPipelineState, objc_name="maxTotalThreadgroupsPerMeshGrid") -RenderPipelineState_maxTotalThreadgroupsPerMeshGrid :: #force_inline proc(self: ^RenderPipelineState) -> NS.UInteger { +RenderPipelineState_maxTotalThreadgroupsPerMeshGrid :: #force_inline proc "c" (self: ^RenderPipelineState) -> NS.UInteger { return msgSend(NS.UInteger, self, "maxTotalThreadgroupsPerMeshGrid") } @(objc_type=RenderPipelineState, objc_name="gpuResourceID") -RenderPipelineState_gpuResourceID :: #force_inline proc(self: ^RenderPipelineState) -> ResourceID { +RenderPipelineState_gpuResourceID :: #force_inline proc "c" (self: ^RenderPipelineState) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } @@ -9054,55 +9054,55 @@ Methods: Resource :: struct { using _: NS.Object } @(objc_type=Resource, objc_name="allocatedSize") -Resource_allocatedSize :: #force_inline proc(self: ^Resource) -> NS.UInteger { +Resource_allocatedSize :: #force_inline proc "c" (self: ^Resource) -> NS.UInteger { return msgSend(NS.UInteger, self, "allocatedSize") } @(objc_type=Resource, objc_name="cpuCacheMode") -Resource_cpuCacheMode :: #force_inline proc(self: ^Resource) -> CPUCacheMode { +Resource_cpuCacheMode :: #force_inline proc "c" (self: ^Resource) -> CPUCacheMode { return msgSend(CPUCacheMode, self, "cpuCacheMode") } @(objc_type=Resource, objc_name="device") -Resource_device :: #force_inline proc(self: ^Resource) -> ^Device { +Resource_device :: #force_inline proc "c" (self: ^Resource) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=Resource, objc_name="hazardTrackingMode") -Resource_hazardTrackingMode :: #force_inline proc(self: ^Resource) -> HazardTrackingMode { +Resource_hazardTrackingMode :: #force_inline proc "c" (self: ^Resource) -> HazardTrackingMode { return msgSend(HazardTrackingMode, self, "hazardTrackingMode") } @(objc_type=Resource, objc_name="heap") -Resource_heap :: #force_inline proc(self: ^Resource) -> ^Heap { +Resource_heap :: #force_inline proc "c" (self: ^Resource) -> ^Heap { return msgSend(^Heap, self, "heap") } @(objc_type=Resource, objc_name="heapOffset") -Resource_heapOffset :: #force_inline proc(self: ^Resource) -> NS.UInteger { +Resource_heapOffset :: #force_inline proc "c" (self: ^Resource) -> NS.UInteger { return msgSend(NS.UInteger, self, "heapOffset") } @(objc_type=Resource, objc_name="isAliasable") -Resource_isAliasable :: #force_inline proc(self: ^Resource) -> BOOL { +Resource_isAliasable :: #force_inline proc "c" (self: ^Resource) -> BOOL { return msgSend(BOOL, self, "isAliasable") } @(objc_type=Resource, objc_name="label") -Resource_label :: #force_inline proc(self: ^Resource) -> ^NS.String { +Resource_label :: #force_inline proc "c" (self: ^Resource) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=Resource, objc_name="makeAliasable") -Resource_makeAliasable :: #force_inline proc(self: ^Resource) { +Resource_makeAliasable :: #force_inline proc "c" (self: ^Resource) { msgSend(nil, self, "makeAliasable") } @(objc_type=Resource, objc_name="resourceOptions") -Resource_resourceOptions :: #force_inline proc(self: ^Resource) -> ResourceOptions { +Resource_resourceOptions :: #force_inline proc "c" (self: ^Resource) -> ResourceOptions { return msgSend(ResourceOptions, self, "resourceOptions") } @(objc_type=Resource, objc_name="setLabel") -Resource_setLabel :: #force_inline proc(self: ^Resource, label: ^NS.String) { +Resource_setLabel :: #force_inline proc "c" (self: ^Resource, label: ^NS.String) { msgSend(nil, self, "setLabel:", label) } @(objc_type=Resource, objc_name="setPurgeableState") -Resource_setPurgeableState :: #force_inline proc(self: ^Resource, state: PurgeableState) -> PurgeableState { +Resource_setPurgeableState :: #force_inline proc "c" (self: ^Resource, state: PurgeableState) -> PurgeableState { return msgSend(PurgeableState, self, "setPurgeableState:", state) } @(objc_type=Resource, objc_name="storageMode") -Resource_storageMode :: #force_inline proc(self: ^Resource) -> StorageMode { +Resource_storageMode :: #force_inline proc "c" (self: ^Resource) -> StorageMode { return msgSend(StorageMode, self, "storageMode") } @@ -9123,28 +9123,28 @@ Methods: ResourceStateCommandEncoder :: struct { using _: CommandEncoder } @(objc_type=ResourceStateCommandEncoder, objc_name="updateFence") -ResourceStateCommandEncoder_updateFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { +ResourceStateCommandEncoder_updateFence :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, fence: ^Fence) { msgSend(nil, self, "updateFence:", fence) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappingIndirect") -ResourceStateCommandEncoder_updateTextureMappingIndirect :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { +ResourceStateCommandEncoder_updateTextureMappingIndirect :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, indirectBuffer: ^Buffer, indirectBufferOffset: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping") -ResourceStateCommandEncoder_updateTextureMapping :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { +ResourceStateCommandEncoder_updateTextureMapping :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice) } @(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings") -ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc(self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, regions: []Region, mipLevels: []NS.UInteger, slices: NS.UInteger) { +ResourceStateCommandEncoder_updateTextureMappings :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, texture: ^Texture, mode: SparseTextureMappingMode, regions: []Region, mipLevels: []NS.UInteger, slices: NS.UInteger) { msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, raw_data(regions), raw_data(mipLevels), slices, NS.UInteger(len(regions))) } @(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence") -ResourceStateCommandEncoder_waitForFence :: #force_inline proc(self: ^ResourceStateCommandEncoder, fence: ^Fence) { +ResourceStateCommandEncoder_waitForFence :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, fence: ^Fence) { msgSend(nil, self, "waitForFence:", fence) } @(objc_type=ResourceStateCommandEncoder, objc_name="moveTextureMappingsFromTexture") -ResourceStateCommandEncoder_moveTextureMappingsFromTexture :: #force_inline proc(self: ^ResourceStateCommandEncoder, +ResourceStateCommandEncoder_moveTextureMappingsFromTexture :: #force_inline proc "c" (self: ^ResourceStateCommandEncoder, sourceTexture: ^Texture, sourceSlice, sourceLevel: NS.UInteger, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^Texture, destinationSlice, destinationLevel: NS.UInteger, destinationOrigin: Origin, ) { @@ -9169,15 +9169,15 @@ Methods: SamplerState :: struct { using _: NS.Object } @(objc_type=SamplerState, objc_name="device") -SamplerState_device :: #force_inline proc(self: ^SamplerState) -> ^Device { +SamplerState_device :: #force_inline proc "c" (self: ^SamplerState) -> ^Device { return msgSend(^Device, self, "device") } @(objc_type=SamplerState, objc_name="label") -SamplerState_label :: #force_inline proc(self: ^SamplerState) -> ^NS.String { +SamplerState_label :: #force_inline proc "c" (self: ^SamplerState) -> ^NS.String { return msgSend(^NS.String, self, "label") } @(objc_type=SamplerState, objc_name="gpuResourceID") -SamplerState_gpuResourceID :: #force_inline proc(self: ^SamplerState) -> ResourceID { +SamplerState_gpuResourceID :: #force_inline proc "c" (self: ^SamplerState) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } @@ -9197,19 +9197,19 @@ Methods: SharedEvent :: struct { using _: Event } @(objc_type=SharedEvent, objc_name="newSharedEventHandle") -SharedEvent_newSharedEventHandle :: #force_inline proc(self: ^SharedEvent) -> ^SharedEventHandle { +SharedEvent_newSharedEventHandle :: #force_inline proc "c" (self: ^SharedEvent) -> ^SharedEventHandle { return msgSend(^SharedEventHandle, self, "newSharedEventHandle") } @(objc_type=SharedEvent, objc_name="notifyListener") -SharedEvent_notifyListener :: #force_inline proc(self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) { +SharedEvent_notifyListener :: #force_inline proc "c" (self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) { msgSend(nil, self, "notifyListener:atValue:block:", listener, value, block) } @(objc_type=SharedEvent, objc_name="setSignaledValue") -SharedEvent_setSignaledValue :: #force_inline proc(self: ^SharedEvent, signaledValue: u64) { +SharedEvent_setSignaledValue :: #force_inline proc "c" (self: ^SharedEvent, signaledValue: u64) { msgSend(nil, self, "setSignaledValue:", signaledValue) } @(objc_type=SharedEvent, objc_name="signaledValue") -SharedEvent_signaledValue :: #force_inline proc(self: ^SharedEvent) -> u64 { +SharedEvent_signaledValue :: #force_inline proc "c" (self: ^SharedEvent) -> u64 { return msgSend(u64, self, "signaledValue") } @@ -9260,88 +9260,88 @@ Methods: Texture :: struct { using _: Resource } @(objc_type=Texture, objc_name="allowGPUOptimizedContents") -Texture_allowGPUOptimizedContents :: #force_inline proc(self: ^Texture) -> BOOL { +Texture_allowGPUOptimizedContents :: #force_inline proc "c" (self: ^Texture) -> BOOL { return msgSend(BOOL, self, "allowGPUOptimizedContents") } @(objc_type=Texture, objc_name="arrayLength") -Texture_arrayLength :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_arrayLength :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "arrayLength") } @(objc_type=Texture, objc_name="buffer") -Texture_buffer :: #force_inline proc(self: ^Texture) -> ^Buffer { +Texture_buffer :: #force_inline proc "c" (self: ^Texture) -> ^Buffer { return msgSend(^Buffer, self, "buffer") } @(objc_type=Texture, objc_name="bufferBytesPerRow") -Texture_bufferBytesPerRow :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_bufferBytesPerRow :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferBytesPerRow") } @(objc_type=Texture, objc_name="bufferOffset") -Texture_bufferOffset :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_bufferOffset :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "bufferOffset") } @(objc_type=Texture, objc_name="depth") -Texture_depth :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_depth :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "depth") } @(objc_type=Texture, objc_name="firstMipmapInTail") -Texture_firstMipmapInTail :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_firstMipmapInTail :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "firstMipmapInTail") } @(objc_type=Texture, objc_name="getBytesWithLevel") -Texture_getBytesWithLevel :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger, region: Region, level: NS.UInteger, slice: NS.UInteger) { +Texture_getBytesWithLevel :: #force_inline proc "c" (self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger, region: Region, level: NS.UInteger, slice: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice) } @(objc_type=Texture, objc_name="getBytes") -Texture_getBytes :: #force_inline proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, region: Region, level: NS.UInteger) { +Texture_getBytes :: #force_inline proc "c" (self: ^Texture, pixelBytes: rawptr, bytesPerRow: NS.UInteger, region: Region, level: NS.UInteger) { msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level) } @(objc_type=Texture, objc_name="height") -Texture_height :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_height :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "height") } @(objc_type=Texture, objc_name="iosurface") -Texture_iosurface :: #force_inline proc(self: ^Texture) -> IOSurfaceRef { +Texture_iosurface :: #force_inline proc "c" (self: ^Texture) -> IOSurfaceRef { return msgSend(IOSurfaceRef, self, "iosurface") } @(objc_type=Texture, objc_name="iosurfacePlane") -Texture_iosurfacePlane :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_iosurfacePlane :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "iosurfacePlane") } @(objc_type=Texture, objc_name="isFramebufferOnly") -Texture_isFramebufferOnly :: #force_inline proc(self: ^Texture) -> BOOL { +Texture_isFramebufferOnly :: #force_inline proc "c" (self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isFramebufferOnly") } @(objc_type=Texture, objc_name="isShareable") -Texture_isShareable :: #force_inline proc(self: ^Texture) -> BOOL { +Texture_isShareable :: #force_inline proc "c" (self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isShareable") } @(objc_type=Texture, objc_name="isSparse") -Texture_isSparse :: #force_inline proc(self: ^Texture) -> BOOL { +Texture_isSparse :: #force_inline proc "c" (self: ^Texture) -> BOOL { return msgSend(BOOL, self, "isSparse") } @(objc_type=Texture, objc_name="mipmapLevelCount") -Texture_mipmapLevelCount :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_mipmapLevelCount :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "mipmapLevelCount") } @(objc_type=Texture, objc_name="newRemoteTextureViewForDevice") -Texture_newRemoteTextureViewForDevice :: #force_inline proc(self: ^Texture, device: ^Device) -> ^Texture { +Texture_newRemoteTextureViewForDevice :: #force_inline proc "c" (self: ^Texture, device: ^Device) -> ^Texture { return msgSend(^Texture, self, "newRemoteTextureViewForDevice:", device) } @(objc_type=Texture, objc_name="newSharedTextureHandle") -Texture_newSharedTextureHandle :: #force_inline proc(self: ^Texture) -> ^SharedTextureHandle { +Texture_newSharedTextureHandle :: #force_inline proc "c" (self: ^Texture) -> ^SharedTextureHandle { return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle") } @(objc_type=Texture, objc_name="newTextureViewWithPixelFormat") -Texture_newTextureViewWithPixelFormat :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { +Texture_newTextureViewWithPixelFormat :: #force_inline proc "c" (self: ^Texture, pixelFormat: PixelFormat) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat) } @(objc_type=Texture, objc_name="newTextureViewWithLevels") -Texture_newTextureViewWithLevels :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { +Texture_newTextureViewWithLevels :: #force_inline proc "c" (self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:", pixelFormat, textureType, levelRange, sliceRange) } @(objc_type=Texture, objc_name="newTextureViewWithLevelsAndSwizzle") -Texture_newTextureViewWithLevelsAndSwizzle :: #force_inline proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { +Texture_newTextureViewWithLevelsAndSwizzle :: #force_inline proc "c" (self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture { return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle) } @(objc_type=Texture, objc_name="newTextureView") @@ -9352,68 +9352,68 @@ Texture_newTextureView :: proc{ } @(objc_type=Texture, objc_name="parentRelativeLevel") -Texture_parentRelativeLevel :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_parentRelativeLevel :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "parentRelativeLevel") } @(objc_type=Texture, objc_name="parentRelativeSlice") -Texture_parentRelativeSlice :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_parentRelativeSlice :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "parentRelativeSlice") } @(objc_type=Texture, objc_name="parentTexture") -Texture_parentTexture :: #force_inline proc(self: ^Texture) -> ^Texture { +Texture_parentTexture :: #force_inline proc "c" (self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "parentTexture") } @(objc_type=Texture, objc_name="pixelFormat") -Texture_pixelFormat :: #force_inline proc(self: ^Texture) -> PixelFormat { +Texture_pixelFormat :: #force_inline proc "c" (self: ^Texture) -> PixelFormat { return msgSend(PixelFormat, self, "pixelFormat") } @(objc_type=Texture, objc_name="remoteStorageTexture") -Texture_remoteStorageTexture :: #force_inline proc(self: ^Texture) -> ^Texture { +Texture_remoteStorageTexture :: #force_inline proc "c" (self: ^Texture) -> ^Texture { return msgSend(^Texture, self, "remoteStorageTexture") } @(objc_type=Texture, objc_name="replaceRegionWithLevel") -Texture_replaceRegionWithLevel :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, slice: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger) { +Texture_replaceRegionWithLevel :: #force_inline proc "c" (self: ^Texture, region: Region, level: NS.UInteger, slice: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger, bytesPerImage: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage) } @(objc_type=Texture, objc_name="replaceRegion") -Texture_replaceRegion :: #force_inline proc(self: ^Texture, region: Region, level: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger) { +Texture_replaceRegion :: #force_inline proc "c" (self: ^Texture, region: Region, level: NS.UInteger, pixelBytes: rawptr, bytesPerRow: NS.UInteger) { msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow) } @(objc_type=Texture, objc_name="rootResource") -Texture_rootResource :: #force_inline proc(self: ^Texture) -> ^Resource { +Texture_rootResource :: #force_inline proc "c" (self: ^Texture) -> ^Resource { return msgSend(^Resource, self, "rootResource") } @(objc_type=Texture, objc_name="sampleCount") -Texture_sampleCount :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_sampleCount :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=Texture, objc_name="swizzle") -Texture_swizzle :: #force_inline proc(self: ^Texture) -> TextureSwizzleChannels { +Texture_swizzle :: #force_inline proc "c" (self: ^Texture) -> TextureSwizzleChannels { return msgSend(TextureSwizzleChannels, self, "swizzle") } @(objc_type=Texture, objc_name="tailSizeInBytes") -Texture_tailSizeInBytes :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_tailSizeInBytes :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "tailSizeInBytes") } @(objc_type=Texture, objc_name="textureType") -Texture_textureType :: #force_inline proc(self: ^Texture) -> TextureType { +Texture_textureType :: #force_inline proc "c" (self: ^Texture) -> TextureType { return msgSend(TextureType, self, "textureType") } @(objc_type=Texture, objc_name="usage") -Texture_usage :: #force_inline proc(self: ^Texture) -> TextureUsage { +Texture_usage :: #force_inline proc "c" (self: ^Texture) -> TextureUsage { return msgSend(TextureUsage, self, "usage") } @(objc_type=Texture, objc_name="width") -Texture_width :: #force_inline proc(self: ^Texture) -> NS.UInteger { +Texture_width :: #force_inline proc "c" (self: ^Texture) -> NS.UInteger { return msgSend(NS.UInteger, self, "width") } @(objc_type=Texture, objc_name="compressionType") -Texture_compressionType :: #force_inline proc(self: ^Texture) -> TextureCompressionType { +Texture_compressionType :: #force_inline proc "c" (self: ^Texture) -> TextureCompressionType { return msgSend(TextureCompressionType, self, "compressionType") } @(objc_type=Texture, objc_name="gpuResourceID") -Texture_gpuResourceID :: #force_inline proc(self: ^Texture) -> ResourceID { +Texture_gpuResourceID :: #force_inline proc "c" (self: ^Texture) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } @@ -9431,16 +9431,16 @@ Methods: VisibleFunctionTable :: struct { using _: Resource } @(objc_type=VisibleFunctionTable, objc_name="setFunction") -VisibleFunctionTable_setFunction :: #force_inline proc(self: ^VisibleFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { +VisibleFunctionTable_setFunction :: #force_inline proc "c" (self: ^VisibleFunctionTable, function: ^FunctionHandle, index: NS.UInteger) { msgSend(nil, self, "setFunction:atIndex:", function, index) } @(objc_type=VisibleFunctionTable, objc_name="setFunctions") -VisibleFunctionTable_setFunctions :: #force_inline proc(self: ^VisibleFunctionTable, functions: []^FunctionHandle, range: NS.Range) { +VisibleFunctionTable_setFunctions :: #force_inline proc "c" (self: ^VisibleFunctionTable, functions: []^FunctionHandle, range: NS.Range) { msgSend(nil, self, "setFunctions:withRange:", raw_data(functions), range) } @(objc_type=VisibleFunctionTable, objc_name="gpuResourceID") -VisibleFunctionTable_gpuResourceID :: #force_inline proc(self: ^VisibleFunctionTable) -> ResourceID { +VisibleFunctionTable_gpuResourceID :: #force_inline proc "c" (self: ^VisibleFunctionTable) -> ResourceID { return msgSend(ResourceID, self, "gpuResourceID") } diff --git a/vendor/darwin/MetalKit/MetalKit.odin b/vendor/darwin/MetalKit/MetalKit.odin index 90d147983..eb09410d1 100644 --- a/vendor/darwin/MetalKit/MetalKit.odin +++ b/vendor/darwin/MetalKit/MetalKit.odin @@ -24,34 +24,34 @@ ViewDelegate :: struct { View :: struct {using _: NS.View} @(objc_type=View, objc_name="alloc", objc_is_class_method=true) -View_alloc :: proc() -> ^View { +View_alloc :: proc "c" () -> ^View { return msgSend(^View, View, "alloc") } @(objc_type=View, objc_name="initWithFrame") -View_initWithFrame :: proc(self: ^View, frame: NS.Rect, device: ^MTL.Device) -> ^View { +View_initWithFrame :: proc "c" (self: ^View, frame: NS.Rect, device: ^MTL.Device) -> ^View { return msgSend(^View, self, "initWithFrame:device:", frame, device) } @(objc_type=View, objc_name="initWithCoder") -View_initWithCoder :: proc(self: ^View, coder: ^NS.Coder) -> ^View { +View_initWithCoder :: proc "c" (self: ^View, coder: ^NS.Coder) -> ^View { return msgSend(^View, self, "initWithCoder:", coder) } @(objc_type=View, objc_name="setDevice") -View_setDevice :: proc(self: ^View, device: ^MTL.Device) { +View_setDevice :: proc "c" (self: ^View, device: ^MTL.Device) { msgSend(nil, self, "setDevice:", device) } @(objc_type=View, objc_name="device") -View_device :: proc(self: ^View) -> ^MTL.Device { +View_device :: proc "c" (self: ^View) -> ^MTL.Device { return msgSend(^MTL.Device, self, "device") } @(objc_type=View, objc_name="draw") -View_draw :: proc(self: ^View) { +View_draw :: proc "c" (self: ^View) { msgSend(nil, self, "draw") } @(objc_type=View, objc_name="setDelegate") -View_setDelegate :: proc(self: ^View, delegate: ^ViewDelegate) { +View_setDelegate :: proc "c" (self: ^View, delegate: ^ViewDelegate) { drawDispatch :: proc "c" (self: ^NS.Value, cmd: NS.SEL, view: ^View) { del := (^ViewDelegate)(self->pointerValue()) del->drawInMTKView(view) @@ -72,7 +72,7 @@ View_setDelegate :: proc(self: ^View, delegate: ^ViewDelegate) { } @(objc_type=View, objc_name="delegate") -View_delegate :: proc(self: ^View) -> ^ViewDelegate { +View_delegate :: proc "c" (self: ^View) -> ^ViewDelegate { wrapper := msgSend(^NS.Value, self, "delegate") if wrapper != nil { return (^ViewDelegate)(wrapper->pointerValue()) @@ -81,179 +81,179 @@ View_delegate :: proc(self: ^View) -> ^ViewDelegate { } @(objc_type=View, objc_name="currentDrawable") -View_currentDrawable :: proc(self: ^View) -> ^CA.MetalDrawable { +View_currentDrawable :: proc "c" (self: ^View) -> ^CA.MetalDrawable { return msgSend(^CA.MetalDrawable, self, "currentDrawable") } @(objc_type=View, objc_name="setFramebufferOnly") -View_setFramebufferOnly :: proc(self: ^View, framebufferOnly: bool) { +View_setFramebufferOnly :: proc "c" (self: ^View, framebufferOnly: bool) { msgSend(nil, self, "setFramebufferOnly:", framebufferOnly) } @(objc_type=View, objc_name="framebufferOnly") -View_framebufferOnly :: proc(self: ^View) -> bool { +View_framebufferOnly :: proc "c" (self: ^View) -> bool { return msgSend(bool, self, "framebufferOnly") } @(objc_type=View, objc_name="setDepthStencilAttachmentTextureUsage") -View_setDepthStencilAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) { +View_setDepthStencilAttachmentTextureUsage :: proc "c" (self: ^View, textureUsage: MTL.TextureUsage) { msgSend(nil, self, "setDepthStencilAttachmentTextureUsage:", textureUsage) } @(objc_type=View, objc_name="depthStencilAttachmentTextureUsage") -View_depthStencilAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage { +View_depthStencilAttachmentTextureUsage :: proc "c" (self: ^View) -> MTL.TextureUsage { return msgSend(MTL.TextureUsage, self, "depthStencilAttachmentTextureUsage") } @(objc_type=View, objc_name="setMultisampleColorAttachmentTextureUsage") -View_setMultisampleColorAttachmentTextureUsage :: proc(self: ^View, textureUsage: MTL.TextureUsage) { +View_setMultisampleColorAttachmentTextureUsage :: proc "c" (self: ^View, textureUsage: MTL.TextureUsage) { msgSend(nil, self, "setMultisampleColorAttachmentTextureUsage:", textureUsage) } @(objc_type=View, objc_name="multisampleColorAttachmentTextureUsage") -View_multisampleColorAttachmentTextureUsage :: proc(self: ^View) -> MTL.TextureUsage { +View_multisampleColorAttachmentTextureUsage :: proc "c" (self: ^View) -> MTL.TextureUsage { return msgSend(MTL.TextureUsage, self, "multisampleColorAttachmentTextureUsage") } @(objc_type=View, objc_name="setPresentsWithTransaction") -View_setPresentsWithTransaction :: proc(self: ^View, presentsWithTransaction: bool) { +View_setPresentsWithTransaction :: proc "c" (self: ^View, presentsWithTransaction: bool) { msgSend(nil, self, "setPresentsWithTransaction:", presentsWithTransaction) } @(objc_type=View, objc_name="presentsWithTransaction") -View_presentsWithTransaction :: proc(self: ^View) -> bool { +View_presentsWithTransaction :: proc "c" (self: ^View) -> bool { return msgSend(bool, self, "presentsWithTransaction") } @(objc_type=View, objc_name="setColorPixelFormat") -View_setColorPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) { +View_setColorPixelFormat :: proc "c" (self: ^View, colorPixelFormat: MTL.PixelFormat) { msgSend(nil, self, "setColorPixelFormat:", colorPixelFormat) } @(objc_type=View, objc_name="colorPixelFormat") -View_colorPixelFormat :: proc(self: ^View) -> MTL.PixelFormat { +View_colorPixelFormat :: proc "c" (self: ^View) -> MTL.PixelFormat { return msgSend(MTL.PixelFormat, self, "colorPixelFormat") } @(objc_type=View, objc_name="setDepthStencilPixelFormat") -View_setDepthStencilPixelFormat :: proc(self: ^View, colorPixelFormat: MTL.PixelFormat) { +View_setDepthStencilPixelFormat :: proc "c" (self: ^View, colorPixelFormat: MTL.PixelFormat) { msgSend(nil, self, "setDepthStencilPixelFormat:", colorPixelFormat) } @(objc_type=View, objc_name="depthStencilPixelFormat") -View_depthStencilPixelFormat :: proc(self: ^View) -> MTL.PixelFormat { +View_depthStencilPixelFormat :: proc "c" (self: ^View) -> MTL.PixelFormat { return msgSend(MTL.PixelFormat, self, "depthStencilPixelFormat") } @(objc_type=View, objc_name="setSampleCount") -View_setSampleCount :: proc(self: ^View, sampleCount: NS.UInteger) { +View_setSampleCount :: proc "c" (self: ^View, sampleCount: NS.UInteger) { msgSend(nil, self, "setSampleCount:", sampleCount) } @(objc_type=View, objc_name="sampleCount") -View_sampleCount :: proc(self: ^View) -> NS.UInteger { +View_sampleCount :: proc "c" (self: ^View) -> NS.UInteger { return msgSend(NS.UInteger, self, "sampleCount") } @(objc_type=View, objc_name="setClearColor") -View_setClearColor :: proc(self: ^View, clearColor: MTL.ClearColor) { +View_setClearColor :: proc "c" (self: ^View, clearColor: MTL.ClearColor) { msgSend(nil, self, "setClearColor:", clearColor) } @(objc_type=View, objc_name="clearColor") -View_clearColor :: proc(self: ^View) -> MTL.ClearColor { +View_clearColor :: proc "c" (self: ^View) -> MTL.ClearColor { return msgSend(MTL.ClearColor, self, "clearColor") } @(objc_type=View, objc_name="setClearDepth") -View_setClearDepth :: proc(self: ^View, clearDepth: f64) { +View_setClearDepth :: proc "c" (self: ^View, clearDepth: f64) { msgSend(nil, self, "setClearDepth:", clearDepth) } @(objc_type=View, objc_name="clearDepth") -View_clearDepth :: proc(self: ^View) -> f64 { +View_clearDepth :: proc "c" (self: ^View) -> f64 { return msgSend(f64, self, "clearDepth") } @(objc_type=View, objc_name="setClearStencil") -View_setClearStencil :: proc(self: ^View, clearStencil: u32) { +View_setClearStencil :: proc "c" (self: ^View, clearStencil: u32) { msgSend(nil, self, "setClearStencil:", clearStencil) } @(objc_type=View, objc_name="clearStencil") -View_clearStencil :: proc(self: ^View) -> u32 { +View_clearStencil :: proc "c" (self: ^View) -> u32 { return msgSend(u32, self, "clearStencil") } @(objc_type=View, objc_name="depthStencilTexture") -View_depthStencilTexture :: proc(self: ^View) -> ^MTL.Texture { +View_depthStencilTexture :: proc "c" (self: ^View) -> ^MTL.Texture { return msgSend(^MTL.Texture, self, "depthStencilTexture") } @(objc_type=View, objc_name="multisampleColorTexture") -View_multisampleColorTexture :: proc(self: ^View) -> ^MTL.Texture { +View_multisampleColorTexture :: proc "c" (self: ^View) -> ^MTL.Texture { return msgSend(^MTL.Texture, self, "multisampleColorTexture") } @(objc_type=View, objc_name="releaseDrawables") -View_releaseDrawables :: proc(self: ^View) { +View_releaseDrawables :: proc "c" (self: ^View) { msgSend(nil, self, "releaseDrawables") } @(objc_type=View, objc_name="currentRenderPassDescriptor") -View_currentRenderPassDescriptor :: proc(self: ^View) -> ^MTL.RenderPassDescriptor { +View_currentRenderPassDescriptor :: proc "c" (self: ^View) -> ^MTL.RenderPassDescriptor { return msgSend(^MTL.RenderPassDescriptor, self, "currentRenderPassDescriptor") } @(objc_type=View, objc_name="setPreferredFramesPerSecond") -View_setPreferredFramesPerSecond :: proc(self: ^View, preferredFramesPerSecond: NS.Integer) { +View_setPreferredFramesPerSecond :: proc "c" (self: ^View, preferredFramesPerSecond: NS.Integer) { msgSend(nil, self, "setPreferredFramesPerSecond:", preferredFramesPerSecond) } @(objc_type=View, objc_name="preferredFramesPerSecond") -View_preferredFramesPerSecond :: proc(self: ^View) -> NS.Integer { +View_preferredFramesPerSecond :: proc "c" (self: ^View) -> NS.Integer { return msgSend(NS.Integer, self, "preferredFramesPerSecond") } @(objc_type=View, objc_name="setEnableSetNeedsDisplay") -View_setEnableSetNeedsDisplay :: proc(self: ^View, enableSetNeedsDisplay: bool) { +View_setEnableSetNeedsDisplay :: proc "c" (self: ^View, enableSetNeedsDisplay: bool) { msgSend(nil, self, "setEnableSetNeedsDisplay:", enableSetNeedsDisplay) } @(objc_type=View, objc_name="enableSetNeedsDisplay") -View_enableSetNeedsDisplay :: proc(self: ^View) -> bool { +View_enableSetNeedsDisplay :: proc "c" (self: ^View) -> bool { return msgSend(bool, self, "enableSetNeedsDisplay") } @(objc_type=View, objc_name="setAutoresizeDrawable") -View_setAutoresizeDrawable :: proc(self: ^View, autoresizeDrawable: bool) { +View_setAutoresizeDrawable :: proc "c" (self: ^View, autoresizeDrawable: bool) { msgSend(nil, self, "setAutoresizeDrawable:", autoresizeDrawable) } @(objc_type=View, objc_name="autoresizeDrawable") -View_autoresizeDrawable :: proc(self: ^View) -> bool { +View_autoresizeDrawable :: proc "c" (self: ^View) -> bool { return msgSend(bool, self, "autoresizeDrawable") } @(objc_type=View, objc_name="setDrawableSize") -View_setDrawableSize :: proc(self: ^View, drawableSize: NS.Size) { +View_setDrawableSize :: proc "c" (self: ^View, drawableSize: NS.Size) { msgSend(nil, self, "setDrawableSize:", drawableSize) } @(objc_type=View, objc_name="drawableSize") -View_drawableSize :: proc(self: ^View) -> NS.Size { +View_drawableSize :: proc "c" (self: ^View) -> NS.Size { return msgSend(NS.Size, self, "drawableSize") } @(objc_type=View, objc_name="preferredDrawableSize") -View_preferredDrawableSize :: proc(self: ^View) -> NS.Size { +View_preferredDrawableSize :: proc "c" (self: ^View) -> NS.Size { return msgSend(NS.Size, self, "preferredDrawableSize") } @(objc_type=View, objc_name="preferredDevice") -View_preferredDevice :: proc(self: ^View) -> ^MTL.Device { +View_preferredDevice :: proc "c" (self: ^View) -> ^MTL.Device { return msgSend(^MTL.Device, self, "preferredDevice") } @(objc_type=View, objc_name="setPaused") -View_setPaused :: proc(self: ^View, isPaused: bool) { +View_setPaused :: proc "c" (self: ^View, isPaused: bool) { msgSend(nil, self, "setPaused:", isPaused) } @(objc_type=View, objc_name="isPaused") -View_isPaused :: proc(self: ^View) -> bool { +View_isPaused :: proc "c" (self: ^View) -> bool { return msgSend(bool, self, "isPaused") } @(objc_type=View, objc_name="setColorSpace") -View_setColorSpace :: proc(self: ^View, colorSpace: ColorSpaceRef) { +View_setColorSpace :: proc "c" (self: ^View, colorSpace: ColorSpaceRef) { msgSend(nil, self, "setColorSpace:", colorSpace) } @(objc_type=View, objc_name="colorSpace") -View_colorSpace :: proc(self: ^View) -> ColorSpaceRef { +View_colorSpace :: proc "c" (self: ^View) -> ColorSpaceRef { return msgSend(ColorSpaceRef, self, "colorSpace") } diff --git a/vendor/darwin/QuartzCore/QuartzCore.odin b/vendor/darwin/QuartzCore/QuartzCore.odin index 2a14fc345..53dde3e94 100644 --- a/vendor/darwin/QuartzCore/QuartzCore.odin +++ b/vendor/darwin/QuartzCore/QuartzCore.odin @@ -11,74 +11,74 @@ msgSend :: intrinsics.objc_send MetalLayer :: struct{ using _: NS.Layer} @(objc_type=MetalLayer, objc_name="layer", objc_is_class_method=true) -MetalLayer_layer :: proc() -> ^MetalLayer { +MetalLayer_layer :: proc "c" () -> ^MetalLayer { return msgSend(^MetalLayer, MetalLayer, "layer") } @(objc_type=MetalLayer, objc_name="device") -MetalLayer_device :: proc(self: ^MetalLayer) -> ^MTL.Device { +MetalLayer_device :: proc "c" (self: ^MetalLayer) -> ^MTL.Device { return msgSend(^MTL.Device, self, "device") } @(objc_type=MetalLayer, objc_name="setDevice") -MetalLayer_setDevice :: proc(self: ^MetalLayer, device: ^MTL.Device) { +MetalLayer_setDevice :: proc "c" (self: ^MetalLayer, device: ^MTL.Device) { msgSend(nil, self, "setDevice:", device) } @(objc_type=MetalLayer, objc_name="opaque") -MetalLayer_opaque :: proc(self: ^MetalLayer) -> NS.BOOL { +MetalLayer_opaque :: proc "c" (self: ^MetalLayer) -> NS.BOOL { return msgSend(NS.BOOL, self, "opaque") } @(objc_type=MetalLayer, objc_name="setOpaque") -MetalLayer_setOpaque :: proc(self: ^MetalLayer, opaque: NS.BOOL) { +MetalLayer_setOpaque :: proc "c" (self: ^MetalLayer, opaque: NS.BOOL) { msgSend(nil, self, "setOpaque:", opaque) } @(objc_type=MetalLayer, objc_name="preferredDevice") -MetalLayer_preferredDevice :: proc(self: ^MetalLayer) -> ^MTL.Device { +MetalLayer_preferredDevice :: proc "c" (self: ^MetalLayer) -> ^MTL.Device { return msgSend(^MTL.Device, self, "preferredDevice") } @(objc_type=MetalLayer, objc_name="pixelFormat") -MetalLayer_pixelFormat :: proc(self: ^MetalLayer) -> MTL.PixelFormat { +MetalLayer_pixelFormat :: proc "c" (self: ^MetalLayer) -> MTL.PixelFormat { return msgSend(MTL.PixelFormat, self, "pixelFormat") } @(objc_type=MetalLayer, objc_name="setPixelFormat") -MetalLayer_setPixelFormat :: proc(self: ^MetalLayer, pixelFormat: MTL.PixelFormat) { +MetalLayer_setPixelFormat :: proc "c" (self: ^MetalLayer, pixelFormat: MTL.PixelFormat) { msgSend(nil, self, "setPixelFormat:", pixelFormat) } @(objc_type=MetalLayer, objc_name="framebufferOnly") -MetalLayer_framebufferOnly :: proc(self: ^MetalLayer) -> NS.BOOL { +MetalLayer_framebufferOnly :: proc "c" (self: ^MetalLayer) -> NS.BOOL { return msgSend(NS.BOOL, self, "framebufferOnly") } @(objc_type=MetalLayer, objc_name="setFramebufferOnly") -MetalLayer_setFramebufferOnly :: proc(self: ^MetalLayer, ok: NS.BOOL) { +MetalLayer_setFramebufferOnly :: proc "c" (self: ^MetalLayer, ok: NS.BOOL) { msgSend(nil, self, "setFramebufferOnly:", ok) } @(objc_type=MetalLayer, objc_name="drawableSize") -MetalLayer_drawableSize :: proc(self: ^MetalLayer) -> NS.Size { +MetalLayer_drawableSize :: proc "c" (self: ^MetalLayer) -> NS.Size { return msgSend(NS.Size, self, "drawableSize") } @(objc_type=MetalLayer, objc_name="setDrawableSize") -MetalLayer_setDrawableSize :: proc(self: ^MetalLayer, drawableSize: NS.Size) { +MetalLayer_setDrawableSize :: proc "c" (self: ^MetalLayer, drawableSize: NS.Size) { msgSend(nil, self, "setDrawableSize:", drawableSize) } @(objc_type=MetalLayer, objc_name="frame") -MetalLayer_frame :: proc(self: ^MetalLayer) -> NS.Rect { +MetalLayer_frame :: proc "c" (self: ^MetalLayer) -> NS.Rect { return msgSend(NS.Rect, self, "frame") } @(objc_type=MetalLayer, objc_name="setFrame") -MetalLayer_setFrame :: proc(self: ^MetalLayer, frame: NS.Rect) { +MetalLayer_setFrame :: proc "c" (self: ^MetalLayer, frame: NS.Rect) { msgSend(nil, self, "setFrame:", frame) } @(objc_type=MetalLayer, objc_name="nextDrawable") -MetalLayer_nextDrawable :: proc(self: ^MetalLayer) -> ^MetalDrawable { +MetalLayer_nextDrawable :: proc "c" (self: ^MetalLayer) -> ^MetalDrawable { return msgSend(^MetalDrawable, self, "nextDrawable") } @@ -88,11 +88,11 @@ MetalLayer_nextDrawable :: proc(self: ^MetalLayer) -> ^MetalDrawable { MetalDrawable :: struct { using _: MTL.Drawable } @(objc_type=MetalDrawable, objc_name="layer") -MetalDrawable_layer :: proc(self: ^MetalDrawable) -> ^MetalLayer { +MetalDrawable_layer :: proc "c" (self: ^MetalDrawable) -> ^MetalLayer { return msgSend(^MetalLayer, self, "layer") } @(objc_type=MetalDrawable, objc_name="texture") -MetalDrawable_texture :: proc(self: ^MetalDrawable) -> ^MTL.Texture { +MetalDrawable_texture :: proc "c" (self: ^MetalDrawable) -> ^MTL.Texture { return msgSend(^MTL.Texture, self, "texture") } \ No newline at end of file From b76fc585431e7d10338bb175334945294b4a57ac Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 15:23:24 +0100 Subject: [PATCH 058/108] Inline `are_types_identical_unique_tuples` to improve `odin_doc_type` performance --- src/docs_writer.cpp | 41 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 7488e955a..3c27552f5 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -471,6 +471,8 @@ gb_internal OdinDocArray odin_doc_add_entity_as_slice(OdinDo return odin_write_item_as_slice(w, index); } + + gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { if (type == nullptr) { return 0; @@ -481,12 +483,41 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { } for (auto const &entry : w->type_cache) { // NOTE(bill): THIS IS SLOW - Type *other = entry.key; - if (are_types_identical_unique_tuples(type, other)) { - OdinDocTypeIndex index = entry.value; - map_set(&w->type_cache, type, index); - return index; + Type *x = type; + Type *y = entry.key; + + if (x == y) { + goto do_set; } + + if (!x | !y) { + continue; + } + + if (x->kind == Type_Named) { + Entity *e = x->Named.type_name; + if (e->TypeName.is_type_alias) { + x = x->Named.base; + } + } + if (y->kind == Type_Named) { + Entity *e = y->Named.type_name; + if (e->TypeName.is_type_alias) { + y = y->Named.base; + } + } + if (x->kind != y->kind) { + continue; + } + + if (!are_types_identical_internal(x, y, true)) { + continue; + } + + do_set: + OdinDocTypeIndex index = entry.value; + map_set(&w->type_cache, type, index); + return index; } From 248f14a1efe95294fe20b4f930be4a948396ff44 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 15:29:01 +0100 Subject: [PATCH 059/108] Correct entity flag generation --- src/docs_writer.cpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 3c27552f5..1e34faa8b 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -887,13 +887,12 @@ gb_internal OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) break; } - if (e->flags & EntityFlag_Param) { - if (e->flags & EntityFlag_Using) { flags |= OdinDocEntityFlag_Param_Using; } - if (e->flags & EntityFlag_ConstInput) { flags |= OdinDocEntityFlag_Param_Const; } - if (e->flags & EntityFlag_Ellipsis) { flags |= OdinDocEntityFlag_Param_Ellipsis; } - if (e->flags & EntityFlag_NoAlias) { flags |= OdinDocEntityFlag_Param_NoAlias; } - if (e->flags & EntityFlag_AnyInt) { flags |= OdinDocEntityFlag_Param_AnyInt; } - } + if (e->flags & EntityFlag_Using) { flags |= OdinDocEntityFlag_Param_Using; } + if (e->flags & EntityFlag_ConstInput) { flags |= OdinDocEntityFlag_Param_Const; } + if (e->flags & EntityFlag_Ellipsis) { flags |= OdinDocEntityFlag_Param_Ellipsis; } + if (e->flags & EntityFlag_NoAlias) { flags |= OdinDocEntityFlag_Param_NoAlias; } + if (e->flags & EntityFlag_AnyInt) { flags |= OdinDocEntityFlag_Param_AnyInt; } + if (e->scope && (e->scope->flags & (ScopeFlag_File|ScopeFlag_Pkg)) && !is_entity_exported(e)) { flags |= OdinDocEntityFlag_Private; } From 5d54b710e7b90734ed352648c5c099b4e5d0701e Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Mon, 22 May 2023 17:22:33 +0200 Subject: [PATCH 060/108] fix #2550 json encoding should use surrogate pairs per RFC7159 --- core/encoding/json/marshal.odin | 6 ++-- core/encoding/json/parser.odin | 11 +++++++- core/io/util.odin | 29 ++++++++++++++------ core/unicode/utf8/utf8.odin | 5 ++++ tests/core/encoding/json/test_core_json.odin | 16 ++++++++++- 5 files changed, 54 insertions(+), 13 deletions(-) diff --git a/core/encoding/json/marshal.odin b/core/encoding/json/marshal.odin index 4cf9264c5..d25015ac7 100644 --- a/core/encoding/json/marshal.odin +++ b/core/encoding/json/marshal.odin @@ -153,7 +153,7 @@ marshal_to_writer :: proc(w: io.Writer, v: any, opt: ^Marshal_Options) -> (err: case complex128: r, i = f64(real(z)), f64(imag(z)) case: return .Unsupported_Type } - + io.write_byte(w, '[') or_return io.write_f64(w, r) or_return io.write_string(w, ", ") or_return @@ -165,8 +165,8 @@ marshal_to_writer :: proc(w: io.Writer, v: any, opt: ^Marshal_Options) -> (err: case runtime.Type_Info_String: switch s in a { - case string: io.write_quoted_string(w, s) or_return - case cstring: io.write_quoted_string(w, string(s)) or_return + case string: io.write_quoted_string(w, s, '"', nil, true) or_return + case cstring: io.write_quoted_string(w, string(s), '"', nil, true) or_return } case runtime.Type_Info_Boolean: diff --git a/core/encoding/json/parser.odin b/core/encoding/json/parser.odin index ed36ae33b..d007e16d7 100644 --- a/core/encoding/json/parser.odin +++ b/core/encoding/json/parser.odin @@ -2,6 +2,7 @@ package json import "core:mem" import "core:unicode/utf8" +import "core:unicode/utf16" import "core:strconv" Parser :: struct { @@ -403,11 +404,19 @@ unquote_string :: proc(token: Token, spec: Specification, allocator := context.a } i += 6 + // If this is a surrogate pair, decode as such by taking the next rune too. + if r >= utf8.SURROGATE_MIN && r <= utf8.SURROGATE_HIGH_MAX && len(s) > i + 2 && s[i:i+2] == "\\u" { + r2 := get_u4_rune(s[i:]) + if r2 >= utf8.SURROGATE_LOW_MIN && r2 <= utf8.SURROGATE_MAX { + i += 6 + r = utf16.decode_surrogate_pair(r, r2) + } + } + buf, buf_width := utf8.encode_rune(r) copy(b[w:], buf[:buf_width]) w += buf_width - case '0': if spec != .JSON { b[w] = '\x00' diff --git a/core/io/util.odin b/core/io/util.odin index 46aa97919..cfd7d3608 100644 --- a/core/io/util.odin +++ b/core/io/util.odin @@ -2,6 +2,7 @@ package io import "core:strconv" import "core:unicode/utf8" +import "core:unicode/utf16" read_ptr :: proc(r: Reader, p: rawptr, byte_size: int, n_read: ^int = nil) -> (n: int, err: Error) { return read(r, ([^]byte)(p)[:byte_size], n_read) @@ -146,7 +147,7 @@ write_encoded_rune :: proc(w: Writer, r: rune, write_quote := true, n_written: ^ return } -write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false, n_written: ^int = nil) -> (n: int, err: Error) { +write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false, n_written: ^int = nil, for_json := false) -> (n: int, err: Error) { is_printable :: proc(r: rune) -> bool { if r <= 0xff { switch r { @@ -163,7 +164,7 @@ write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false, defer if n_written != nil { n_written^ += n } - + if html_safe { switch r { case '<', '>', '&': @@ -211,17 +212,29 @@ write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false, write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return } case: - write_byte(w, '\\', &n) or_return - write_byte(w, 'U', &n) or_return - for s := 28; s >= 0; s -= 4 { - write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return + if for_json { + buf: [2]u16 + utf16.encode(buf[:], []rune{c}) + for bc in buf { + write_byte(w, '\\', &n) or_return + write_byte(w, 'u', &n) or_return + for s := 12; s >= 0; s -= 4 { + write_byte(w, DIGITS_LOWER[bc>>uint(s) & 0xf], &n) or_return + } + } + } else { + write_byte(w, '\\', &n) or_return + write_byte(w, 'U', &n) or_return + for s := 24; s >= 0; s -= 4 { + write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return + } } } } return } -write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"', n_written: ^int = nil) -> (n: int, err: Error) { +write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"', n_written: ^int = nil, for_json := false) -> (n: int, err: Error) { defer if n_written != nil { n_written^ += n } @@ -240,7 +253,7 @@ write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"', n_written continue } - n_wrapper(write_escaped_rune(w, r, quote), &n) or_return + n_wrapper(write_escaped_rune(w, r, quote, false, nil, for_json), &n) or_return } write_byte(w, quote, &n) or_return diff --git a/core/unicode/utf8/utf8.odin b/core/unicode/utf8/utf8.odin index a0da5c5d1..15c6c3650 100644 --- a/core/unicode/utf8/utf8.odin +++ b/core/unicode/utf8/utf8.odin @@ -10,6 +10,11 @@ UTF_MAX :: 4 SURROGATE_MIN :: 0xd800 SURROGATE_MAX :: 0xdfff +// A high/leading surrogate is in range SURROGATE_MIN..SURROGATE_HIGH_MAX, +// A low/trailing surrogate is in range SURROGATE_LOW_MIN..SURROGATE_MAX. +SURROGATE_HIGH_MAX :: 0xdbff +SURROGATE_LOW_MIN :: 0xdc00 + T1 :: 0b0000_0000 TX :: 0b1000_0000 T2 :: 0b1100_0000 diff --git a/tests/core/encoding/json/test_core_json.odin b/tests/core/encoding/json/test_core_json.odin index 0e6a6412f..937d1c738 100644 --- a/tests/core/encoding/json/test_core_json.odin +++ b/tests/core/encoding/json/test_core_json.odin @@ -32,6 +32,7 @@ main :: proc() { parse_json(&t) marshal_json(&t) unmarshal_json(&t) + surrogate(&t) fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count) if TEST_fail > 0 { @@ -344,4 +345,17 @@ unmarshal_json :: proc(t: ^testing.T) { for p, i in g.products { expect(t, p == original_data.products[i], "Producted unmarshaled improperly") } -} \ No newline at end of file +} + +@test +surrogate :: proc(t: ^testing.T) { + input := `+ + * 😃 - /` + + out, err := json.marshal(input) + expect(t, err == nil, fmt.tprintf("Expected `json.marshal(%q)` to return a nil error, got %v", input, err)) + + back: string + uerr := json.unmarshal(out, &back) + expect(t, uerr == nil, fmt.tprintf("Expected `json.unmarshal(%q)` to return a nil error, got %v", string(out), uerr)) + expect(t, back == input, fmt.tprintf("Expected `json.unmarshal(%q)` to return %q, got %v", string(out), input, uerr)) +} From 40a8ed535abe54602d6c58f03416681a6dec7faa Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 20:43:19 +0100 Subject: [PATCH 061/108] Add `@(require_results)` to `core:math/ease` --- core/math/ease/ease.odin | 99 +++++++++++++++++++++++++++------------- 1 file changed, 67 insertions(+), 32 deletions(-) diff --git a/core/math/ease/ease.odin b/core/math/ease/ease.odin index c3917707f..d5cb85dd8 100644 --- a/core/math/ease/ease.odin +++ b/core/math/ease/ease.odin @@ -11,11 +11,13 @@ import "core:time" // with additional enum based call // Modeled after the parabola y = x^2 +@(require_results) quadratic_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p * p } // Modeled after the parabola y = -x^2 + 2x +@(require_results) quadratic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return -(p * (p - 2)) } @@ -23,6 +25,7 @@ quadratic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float( // Modeled after the piecewise quadratic // y = (1/2)((2x)^2) ; [0, 0.5) // y = -(1/2)((2x-1)*(2x-3) - 1) ; [0.5, 1] +@(require_results) quadratic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 2 * p * p @@ -32,11 +35,13 @@ quadratic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_flo } // Modeled after the cubic y = x^3 +@(require_results) cubic_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p * p * p } // Modeled after the cubic y = (x - 1)^3 + 1 +@(require_results) cubic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { f := p - 1 return f * f * f + 1 @@ -45,6 +50,7 @@ cubic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { // Modeled after the piecewise cubic // y = (1/2)((2x)^3) ; [0, 0.5) // y = (1/2)((2x-2)^3 + 2) ; [0.5, 1] +@(require_results) cubic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 4 * p * p * p @@ -55,11 +61,13 @@ cubic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T } // Modeled after the quartic x^4 +@(require_results) quartic_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p * p * p * p } // Modeled after the quartic y = 1 - (x - 1)^4 +@(require_results) quartic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { f := p - 1 return f * f * f * (1 - p) + 1 @@ -68,6 +76,7 @@ quartic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) // Modeled after the piecewise quartic // y = (1/2)((2x)^4) ; [0, 0.5) // y = -(1/2)((2x-2)^4 - 2) ; [0.5, 1] +@(require_results) quartic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 8 * p * p * p * p @@ -78,11 +87,13 @@ quartic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float } // Modeled after the quintic y = x^5 +@(require_results) quintic_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p * p * p * p * p } // Modeled after the quintic y = (x - 1)^5 + 1 +@(require_results) quintic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { f := p - 1 return f * f * f * f * f + 1 @@ -91,6 +102,7 @@ quintic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) // Modeled after the piecewise quintic // y = (1/2)((2x)^5) ; [0, 0.5) // y = (1/2)((2x-2)^5 + 2) ; [0.5, 1] +@(require_results) quintic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 16 * p * p * p * p * p @@ -101,26 +113,31 @@ quintic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float } // Modeled after quarter-cycle of sine wave +@(require_results) sine_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return math.sin((p - 1) * PI_2) + 1 } // Modeled after quarter-cycle of sine wave (different phase) +@(require_results) sine_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return math.sin(p * PI_2) } // Modeled after half sine wave +@(require_results) sine_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return 0.5 * (1 - math.cos(p * math.PI)) } // Modeled after shifted quadrant IV of unit circle +@(require_results) circular_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return 1 - math.sqrt(1 - (p * p)) } // Modeled after shifted quadrant II of unit circle +@(require_results) circular_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return math.sqrt((2 - p) * p) } @@ -128,6 +145,7 @@ circular_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T // Modeled after the piecewise circular function // y = (1/2)(1 - sqrt(1 - 4x^2)) ; [0, 0.5) // y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1] +@(require_results) circular_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 0.5 * (1 - math.sqrt(1 - 4 * (p * p))) @@ -137,11 +155,13 @@ circular_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_floa } // Modeled after the exponential function y = 2^(10(x - 1)) +@(require_results) exponential_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p == 0.0 ? p : math.pow(2, 10 * (p - 1)) } // Modeled after the exponential function y = -2^(-10x) + 1 +@(require_results) exponential_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p == 1.0 ? p : 1 - math.pow(2, -10 * p) } @@ -149,6 +169,7 @@ exponential_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_floa // Modeled after the piecewise exponential // y = (1/2)2^(10(2x - 1)) ; [0,0.5) // y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1] +@(require_results) exponential_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p == 0.0 || p == 1.0 { return p @@ -162,11 +183,13 @@ exponential_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_f } // Modeled after the damped sine wave y = sin(13pi/2*x)*pow(2, 10 * (x - 1)) +@(require_results) elastic_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return math.sin(13 * PI_2 * p) * math.pow(2, 10 * (p - 1)) } // Modeled after the damped sine wave y = sin(-13pi/2*(x + 1))*pow(2, -10x) + 1 +@(require_results) elastic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return math.sin(-13 * PI_2 * (p + 1)) * math.pow(2, -10 * p) + 1 } @@ -174,6 +197,7 @@ elastic_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) // Modeled after the piecewise exponentially-damped sine wave: // y = (1/2)*sin(13pi/2*(2*x))*pow(2, 10 * ((2*x) - 1)) ; [0,0.5) // y = (1/2)*(sin(-13pi/2*((2x-1)+1))*pow(2,-10(2*x-1)) + 2) ; [0.5, 1] +@(require_results) elastic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 0.5 * math.sin(13 * PI_2 * (2 * p)) * math.pow(2, 10 * ((2 * p) - 1)) @@ -183,11 +207,13 @@ elastic_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float } // Modeled after the overshooting cubic y = x^3-x*sin(x*pi) +@(require_results) back_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return p * p * p - p * math.sin(p * math.PI) } // Modeled after overshooting cubic y = 1-((1-x)^3-(1-x)*sin((1-x)*pi)) +@(require_results) back_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { f := 1 - p return 1 - (f * f * f - f * math.sin(f * math.PI)) @@ -196,6 +222,7 @@ back_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { // Modeled after the piecewise overshooting cubic function: // y = (1/2)*((2x)^3-(2x)*sin(2*x*pi)) ; [0, 0.5) // y = (1/2)*(1-((1-x)^3-(1-x)*sin((1-x)*pi))+1) ; [0.5, 1] +@(require_results) back_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { f := 2 * p @@ -206,10 +233,12 @@ back_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) } } +@(require_results) bounce_in :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { return 1 - bounce_out(1 - p) } +@(require_results) bounce_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 4/11.0 { return (121 * p * p)/16.0 @@ -222,6 +251,7 @@ bounce_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) } } +@(require_results) bounce_in_out :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) { if p < 0.5 { return 0.5 * bounce_in(p*2) @@ -276,50 +306,51 @@ Ease :: enum { Bounce_In_Out, } +@(require_results) ease :: proc "contextless" (type: Ease, p: $T) -> T where intrinsics.type_is_float(T) { switch type { - case .Linear: return p - - case .Quadratic_In: return quadratic_in(p) - case .Quadratic_Out: return quadratic_out(p) - case .Quadratic_In_Out: return quadratic_in_out(p) + case .Linear: return p - case .Cubic_In: return cubic_in(p) - case .Cubic_Out: return cubic_out(p) - case .Cubic_In_Out: return cubic_in_out(p) + case .Quadratic_In: return quadratic_in(p) + case .Quadratic_Out: return quadratic_out(p) + case .Quadratic_In_Out: return quadratic_in_out(p) - case .Quartic_In: return quartic_in(p) - case .Quartic_Out: return quartic_out(p) - case .Quartic_In_Out: return quartic_in_out(p) + case .Cubic_In: return cubic_in(p) + case .Cubic_Out: return cubic_out(p) + case .Cubic_In_Out: return cubic_in_out(p) - case .Quintic_In: return quintic_in(p) - case .Quintic_Out: return quintic_out(p) - case .Quintic_In_Out: return quintic_in_out(p) + case .Quartic_In: return quartic_in(p) + case .Quartic_Out: return quartic_out(p) + case .Quartic_In_Out: return quartic_in_out(p) - case .Sine_In: return sine_in(p) - case .Sine_Out: return sine_out(p) - case .Sine_In_Out: return sine_in_out(p) + case .Quintic_In: return quintic_in(p) + case .Quintic_Out: return quintic_out(p) + case .Quintic_In_Out: return quintic_in_out(p) - case .Circular_In: return circular_in(p) - case .Circular_Out: return circular_out(p) - case .Circular_In_Out: return circular_in_out(p) + case .Sine_In: return sine_in(p) + case .Sine_Out: return sine_out(p) + case .Sine_In_Out: return sine_in_out(p) - case .Exponential_In: return exponential_in(p) - case .Exponential_Out: return exponential_out(p) - case .Exponential_In_Out: return exponential_in_out(p) + case .Circular_In: return circular_in(p) + case .Circular_Out: return circular_out(p) + case .Circular_In_Out: return circular_in_out(p) - case .Elastic_In: return elastic_in(p) - case .Elastic_Out: return elastic_out(p) - case .Elastic_In_Out: return elastic_in_out(p) + case .Exponential_In: return exponential_in(p) + case .Exponential_Out: return exponential_out(p) + case .Exponential_In_Out: return exponential_in_out(p) - case .Back_In: return back_in(p) - case .Back_Out: return back_out(p) - case .Back_In_Out: return back_in_out(p) + case .Elastic_In: return elastic_in(p) + case .Elastic_Out: return elastic_out(p) + case .Elastic_In_Out: return elastic_in_out(p) - case .Bounce_In: return bounce_in(p) - case .Bounce_Out: return bounce_out(p) - case .Bounce_In_Out: return bounce_in_out(p) + case .Back_In: return back_in(p) + case .Back_Out: return back_out(p) + case .Back_In_Out: return back_in_out(p) + + case .Bounce_In: return bounce_in(p) + case .Bounce_Out: return bounce_out(p) + case .Bounce_In_Out: return bounce_in_out(p) } // in case type was invalid @@ -353,6 +384,7 @@ Flux_Tween :: struct($T: typeid) { } // init flux map to a float type and a wanted cap +@(require_results) flux_init :: proc($T: typeid, value_capacity := 8) -> Flux_Map(T) where intrinsics.type_is_float(T) { return { values = make(map[^T]Flux_Tween(T), value_capacity), @@ -374,6 +406,7 @@ flux_clear :: proc(flux: ^Flux_Map($T)) where intrinsics.type_is_float(T) { // append / overwrite existing tween value to parameters // rest is initialized in flux_tween_init, inside update // return value can be used to set callbacks +@(require_results) flux_to :: proc( flux: ^Flux_Map($T), value: ^T, @@ -475,6 +508,7 @@ flux_update :: proc(flux: ^Flux_Map($T), dt: f64) where intrinsics.type_is_float // stop a specific key inside the map // returns true when it successfully removed the key +@(require_results) flux_stop :: proc(flux: ^Flux_Map($T), key: ^T) -> bool where intrinsics.type_is_float(T) { if key in flux.values { delete_key(&flux.values, key) @@ -486,6 +520,7 @@ flux_stop :: proc(flux: ^Flux_Map($T), key: ^T) -> bool where intrinsics.type_is // returns the amount of time left for the tween animation, if the key exists in the map // returns 0 if the tween doesnt exist on the map +@(require_results) flux_tween_time_left :: proc(flux: Flux_Map($T), key: ^T) -> f64 { if tween, ok := flux.values[key]; ok { return ((1 - tween.progress) * tween.rate) + tween.delay From 79587086414e084e9b6126f73e6afe9062769a8e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 20:43:41 +0100 Subject: [PATCH 062/108] Add missing class method to NS.Number --- vendor/darwin/Foundation/NSNumber.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/vendor/darwin/Foundation/NSNumber.odin b/vendor/darwin/Foundation/NSNumber.odin index ce31e30dc..99b281307 100644 --- a/vendor/darwin/Foundation/NSNumber.odin +++ b/vendor/darwin/Foundation/NSNumber.odin @@ -90,6 +90,7 @@ Number_init :: proc "c" (self: ^Number) -> ^Number { @(objc_type=Number, objc_name="numberWithF64", objc_is_class_method=true) Number_numberWithF64 :: proc "c" (value: f64) -> ^Number { return msgSend(^Number, Number, "numberWithDouble:", value) } @(objc_type=Number, objc_name="numberWithBool", objc_is_class_method=true) Number_numberWithBool :: proc "c" (value: BOOL) -> ^Number { return msgSend(^Number, Number, "numberWithBool:", value) } +@(objc_type=Number, objc_name="number", objc_is_class_method=true) Number_number :: proc{ Number_numberWithI8, Number_numberWithU8, From 418144473405e3221ec32e8ce7073eed15a0a2cc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 20:44:01 +0100 Subject: [PATCH 063/108] Add `vendor:darwin/MetalKit` to examples/all --- examples/all/all_vendor.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/all/all_vendor.odin b/examples/all/all_vendor.odin index f66e3cca1..9e67988f6 100644 --- a/examples/all/all_vendor.odin +++ b/examples/all/all_vendor.odin @@ -24,6 +24,7 @@ import vk "vendor:vulkan" import NS "vendor:darwin/Foundation" import MTL "vendor:darwin/Metal" +import MTK "vendor:darwin/MetalKit" import CA "vendor:darwin/QuartzCore" // NOTE(bill): only one can be checked at a time From 38b64dc5dfeb141cb7e9cca790f897e762374ead Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 20:48:13 +0100 Subject: [PATCH 064/108] Improve doc_writer.cpp performance --- src/docs_writer.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 1e34faa8b..7dab5a8b1 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -30,6 +30,7 @@ struct OdinDocWriter { PtrMap pkg_cache; PtrMap entity_cache; PtrMap type_cache; + PtrMap stable_type_cache; OdinDocWriterItemTracker files; OdinDocWriterItemTracker pkgs; @@ -59,6 +60,7 @@ gb_internal void odin_doc_writer_prepare(OdinDocWriter *w) { map_init(&w->pkg_cache); map_init(&w->entity_cache); map_init(&w->type_cache); + map_init(&w->stable_type_cache); odin_doc_writer_item_tracker_init(&w->files, 1); odin_doc_writer_item_tracker_init(&w->pkgs, 1); @@ -77,6 +79,7 @@ gb_internal void odin_doc_writer_destroy(OdinDocWriter *w) { map_destroy(&w->pkg_cache); map_destroy(&w->entity_cache); map_destroy(&w->type_cache); + map_destroy(&w->stable_type_cache); } @@ -477,6 +480,12 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { if (type == nullptr) { return 0; } + + Type **mapped_type = map_get(&w->stable_type_cache, type); // may map to itself + if (mapped_type && *mapped_type) { + type = *mapped_type; + } + OdinDocTypeIndex *found = map_get(&w->type_cache, type); if (found) { return *found; @@ -517,6 +526,7 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { do_set: OdinDocTypeIndex index = entry.value; map_set(&w->type_cache, type, index); + map_set(&w->stable_type_cache, type, entry.key); return index; } @@ -526,6 +536,7 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { OdinDocTypeIndex type_index = 0; type_index = odin_doc_write_item(w, &w->types, &doc_type, &dst); map_set(&w->type_cache, type, type_index); + map_set(&w->stable_type_cache, type, type); switch (type->kind) { case Type_Basic: From 24a1a8a62680d59afb56827771b49dee62d384b6 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 20:48:49 +0100 Subject: [PATCH 065/108] Keep `-vet` happy --- examples/all/all_vendor.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/all/all_vendor.odin b/examples/all/all_vendor.odin index 9e67988f6..22c55c14e 100644 --- a/examples/all/all_vendor.odin +++ b/examples/all/all_vendor.odin @@ -54,6 +54,7 @@ _ :: vk _ :: NS _ :: MTL +_ :: MTK _ :: CA _ :: lua_5_4 \ No newline at end of file From bdbbaf6c880c1ac481859160cb632b49ecbe6b46 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 21:34:20 +0100 Subject: [PATCH 066/108] Disable stable_type_cache for the time being --- src/docs_writer.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 7dab5a8b1..18178dd51 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -481,10 +481,10 @@ gb_internal OdinDocTypeIndex odin_doc_type(OdinDocWriter *w, Type *type) { return 0; } - Type **mapped_type = map_get(&w->stable_type_cache, type); // may map to itself - if (mapped_type && *mapped_type) { - type = *mapped_type; - } + // Type **mapped_type = map_get(&w->stable_type_cache, type); // may map to itself + // if (mapped_type && *mapped_type) { + // type = *mapped_type; + // } OdinDocTypeIndex *found = map_get(&w->type_cache, type); if (found) { From 3a61350f4b362ae9d3cd03940588f83b035ba33d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 21:48:32 +0100 Subject: [PATCH 067/108] Add debug messages to docs_writer.cpp --- src/docs_writer.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 18178dd51..2dd2f338b 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -52,6 +52,7 @@ gb_internal void odin_doc_writer_item_tracker_init(OdinDocWriterItemTracker * gb_internal void odin_doc_writer_prepare(OdinDocWriter *w) { + debugf("odin_doc_writer_prepare\n"); w->state = OdinDocWriterState_Preparing; string_map_init(&w->string_cache); @@ -72,6 +73,7 @@ gb_internal void odin_doc_writer_prepare(OdinDocWriter *w) { gb_internal void odin_doc_writer_destroy(OdinDocWriter *w) { + debugf("odin_doc_writer_destroy\n"); gb_free(heap_allocator(), w->data); string_map_destroy(&w->string_cache); @@ -105,6 +107,7 @@ gb_internal isize odin_doc_writer_calc_total_size(OdinDocWriter *w) { } gb_internal void odin_doc_writer_start_writing(OdinDocWriter *w) { + debugf("odin_doc_writer_start_writing\n"); w->state = OdinDocWriterState_Writing; string_map_clear(&w->string_cache); @@ -141,6 +144,7 @@ gb_internal void odin_doc_writer_assign_tracker(OdinDocArray *array, OdinDocW gb_internal void odin_doc_writer_end_writing(OdinDocWriter *w) { + debugf("odin_doc_writer_end_writing\n"); OdinDocHeader *h = w->header; gb_memmove(h->base.magic, OdinDocHeader_MagicString, gb_strlen(OdinDocHeader_MagicString)); @@ -951,6 +955,8 @@ gb_internal OdinDocEntityIndex odin_doc_add_entity(OdinDocWriter *w, Entity *e) } gb_internal void odin_doc_update_entities(OdinDocWriter *w) { + debugf("odin_doc_update_entities %s\n", w->state ? "preparing" : "writing"); + { // NOTE(bill): Double pass, just in case entities are created on odin_doc_type auto entities = array_make(heap_allocator(), 0, w->entity_cache.count); @@ -1015,6 +1021,8 @@ gb_internal OdinDocArray odin_doc_add_pkg_entries(OdinDocWrit return {}; } + debugf("odin_doc_add_pkg_entries %s -> package %.*s\n", w->state ? "preparing" : "writing", LIT(pkg->name)); + auto entries = array_make(heap_allocator(), 0, w->entity_cache.count); defer (array_free(&entries)); @@ -1058,6 +1066,8 @@ gb_internal OdinDocArray odin_doc_add_pkg_entries(OdinDocWrit gb_internal void odin_doc_write_docs(OdinDocWriter *w) { + debugf("odin_doc_write_docs %s", w->state ? "preparing" : "writing"); + auto pkgs = array_make(heap_allocator(), 0, w->info->packages.count); defer (array_free(&pkgs)); for (auto const &entry : w->info->packages) { @@ -1073,6 +1083,7 @@ gb_internal void odin_doc_write_docs(OdinDocWriter *w) { } } + debugf("odin_doc_update_entities sort pkgs %s\n", w->state ? "preparing" : "writing"); gb_sort_array(pkgs.data, pkgs.count, cmp_ast_package_by_name); for_array(i, pkgs) { @@ -1133,6 +1144,7 @@ gb_internal void odin_doc_write_docs(OdinDocWriter *w) { gb_internal void odin_doc_write_to_file(OdinDocWriter *w, char const *filename) { + debugf("odin_doc_write_to_file %s\n", filename); gbFile f = {}; gbFileError err = gb_file_open_mode(&f, gbFileMode_Write, filename); if (err != gbFileError_None) { @@ -1143,6 +1155,7 @@ gb_internal void odin_doc_write_to_file(OdinDocWriter *w, char const *filename) defer (gb_file_close(&f)); if (gb_file_write(&f, w->data, w->data_len)) { err = gb_file_truncate(&f, w->data_len); + debugf("Wrote .odin-doc file to: %s\n", filename); gb_printf("Wrote .odin-doc file to: %s\n", filename); } } @@ -1153,6 +1166,8 @@ gb_internal void odin_doc_write(CheckerInfo *info, char const *filename) { defer (odin_doc_writer_destroy(w)); w->info = info; + debugf("odin_doc_write %s\n", filename); + odin_doc_writer_prepare(w); odin_doc_write_docs(w); From 54b7cefb090f3ee23c57291c55bc369f0ea48696 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 24 May 2023 10:21:53 +0100 Subject: [PATCH 068/108] Fix `lua.MAXSTACK` --- vendor/lua/5.1/lua.odin | 2 +- vendor/lua/5.2/lua.odin | 2 +- vendor/lua/5.3/lua.odin | 2 +- vendor/lua/5.4/lua.odin | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/vendor/lua/5.1/lua.odin b/vendor/lua/5.1/lua.odin index 92660c534..5a0ae5bc7 100644 --- a/vendor/lua/5.1/lua.odin +++ b/vendor/lua/5.1/lua.odin @@ -38,7 +38,7 @@ GLOBALSINDEX :: -10002 ** space (and to reserve some numbers for pseudo-indices). ** (It must fit into max(size_t)/32.) */ -MAXSTACK :: 1000000 when size_of(rawptr) == 4 else 15000 +MAXSTACK :: 1000000 /* diff --git a/vendor/lua/5.2/lua.odin b/vendor/lua/5.2/lua.odin index c71c1925e..9770e95b9 100644 --- a/vendor/lua/5.2/lua.odin +++ b/vendor/lua/5.2/lua.odin @@ -44,7 +44,7 @@ REGISTRYINDEX :: -FIRSTPSEUDOIDX ** space (and to reserve some numbers for pseudo-indices). ** (It must fit into max(size_t)/32.) */ -MAXSTACK :: 1000000 when size_of(rawptr) == 4 else 15000 +MAXSTACK :: 1000000 /* diff --git a/vendor/lua/5.3/lua.odin b/vendor/lua/5.3/lua.odin index 718d52250..db7419d15 100644 --- a/vendor/lua/5.3/lua.odin +++ b/vendor/lua/5.3/lua.odin @@ -42,7 +42,7 @@ REGISTRYINDEX :: -MAXSTACK - 1000 ** space (and to reserve some numbers for pseudo-indices). ** (It must fit into max(size_t)/32.) */ -MAXSTACK :: 1000000 when size_of(rawptr) == 4 else 15000 +MAXSTACK :: 1000000 /* diff --git a/vendor/lua/5.4/lua.odin b/vendor/lua/5.4/lua.odin index 8aa274201..495786eb1 100644 --- a/vendor/lua/5.4/lua.odin +++ b/vendor/lua/5.4/lua.odin @@ -44,7 +44,7 @@ REGISTRYINDEX :: -MAXSTACK - 1000 ** space (and to reserve some numbers for pseudo-indices). ** (It must fit into max(size_t)/32.) */ -MAXSTACK :: 1000000 when size_of(rawptr) >= 4 else 15000 +MAXSTACK :: 1000000 /* From 8012e6fa43b280a62fbe503f938e66865046a564 Mon Sep 17 00:00:00 2001 From: Ryhor Spivak Date: Wed, 24 May 2023 15:14:30 +0300 Subject: [PATCH 069/108] Remove rcDevice field from WINDOWPLACEMENT. Add WaitMessage and SetWindowPlacement. rcDevice is under #ifdef _MAC in WinUser.h and _MAC is defined only for PowerPC Mac builds. --- core/sys/windows/user32.odin | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core/sys/windows/user32.odin b/core/sys/windows/user32.odin index e8499a67b..29fa4da17 100644 --- a/core/sys/windows/user32.odin +++ b/core/sys/windows/user32.odin @@ -52,6 +52,8 @@ foreign user32 { TranslateMessage :: proc(lpMsg: ^MSG) -> BOOL --- DispatchMessageW :: proc(lpMsg: ^MSG) -> LRESULT --- + WaitMessage :: proc() -> BOOL --- + PeekMessageA :: proc(lpMsg: ^MSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT) -> BOOL --- PeekMessageW :: proc(lpMsg: ^MSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT) -> BOOL --- @@ -222,6 +224,7 @@ foreign user32 { GetWindowInfo :: proc(hwnd: HWND, pwi: PWINDOWINFO) -> BOOL --- GetWindowPlacement :: proc(hWnd: HWND, lpwndpl: ^WINDOWPLACEMENT) -> BOOL --- + SetWindowPlacement :: proc(hwnd: HWND, lpwndpl: ^WINDOWPLACEMENT) -> BOOL --- SetWindowRgn :: proc(hWnd: HWND, hRgn: HRGN, bRedraw: BOOL) -> int --- CreateRectRgnIndirect :: proc(lprect: ^RECT) -> HRGN --- GetSystemMetricsForDpi :: proc(nIndex: int, dpi: UINT) -> int --- @@ -463,7 +466,6 @@ WINDOWPLACEMENT :: struct { ptMinPosition: POINT, ptMaxPosition: POINT, rcNormalPosition: RECT, - rcDevice: RECT, } WINDOWINFO :: struct { From 32ca50a097c09da8b2bbba4d809b84b419e4c04e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 24 May 2023 20:54:30 +0100 Subject: [PATCH 070/108] Fix special printing for certain named types with `fmt.printf` related procedures --- core/fmt/fmt.odin | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index 8a5f54516..b82789813 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -2647,18 +2647,10 @@ fmt_arg :: proc(fi: ^Info, arg: any, verb: rune) { } } - - custom_types: switch a in arg { - case runtime.Source_Code_Location: - if fi.hash && verb == 'v' { - io.write_string(fi.writer, a.file_path, &fi.n) - io.write_byte(fi.writer, '(', &fi.n) - io.write_i64(fi.writer, i64(a.line), 10, &fi.n) - io.write_byte(fi.writer, ':', &fi.n) - io.write_i64(fi.writer, i64(a.column), 10, &fi.n) - io.write_byte(fi.writer, ')', &fi.n) - return - } + arg_info := type_info_of(arg.id) + if info, ok := arg_info.variant.(runtime.Type_Info_Named); ok { + fmt_named(fi, arg, verb, info) + return } base_arg := arg From 762747273e0e1b8ff105288925f01de4e3a19f64 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 25 May 2023 11:58:02 +0100 Subject: [PATCH 071/108] Add mutex to `mem.Tracking_Allocator` --- core/mem/allocators.odin | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 8c19f1788..603c2a6c7 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -2,6 +2,7 @@ package mem import "core:intrinsics" import "core:runtime" +import "core:sync" nil_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, @@ -868,6 +869,7 @@ Tracking_Allocator :: struct { backing: Allocator, allocation_map: map[rawptr]Tracking_Allocator_Entry, bad_free_array: [dynamic]Tracking_Allocator_Bad_Free_Entry, + mutex: sync.Mutex, clear_on_free_all: bool, } @@ -888,8 +890,10 @@ tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) { tracking_allocator_clear :: proc(t: ^Tracking_Allocator) { + sync.mutex_lock(&t.mutex) clear(&t.allocation_map) clear(&t.bad_free_array) + sync.mutex_unlock(&t.mutex) } @@ -905,6 +909,9 @@ tracking_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, loc := #caller_location) -> (result: []byte, err: Allocator_Error) { data := (^Tracking_Allocator)(allocator_data) + + sync.mutex_guard(&data.mutex) + if mode == .Query_Info { info := (^Allocator_Query_Info)(old_memory) if info != nil && info.pointer != nil { From 39bff40a7554e244cc1d4d3b43bb7f71a9b6ff82 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 25 May 2023 11:58:42 +0100 Subject: [PATCH 072/108] Make many `core:unicode/utf8` procedures "contextless" --- core/unicode/utf8/utf8.odin | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/core/unicode/utf8/utf8.odin b/core/unicode/utf8/utf8.odin index 15c6c3650..3642b8078 100644 --- a/core/unicode/utf8/utf8.odin +++ b/core/unicode/utf8/utf8.odin @@ -59,7 +59,7 @@ accept_sizes := [256]u8{ 0xf5..=0xff = 0xf1, } -encode_rune :: proc(c: rune) -> ([4]u8, int) { +encode_rune :: proc "contextless" (c: rune) -> ([4]u8, int) { r := c buf: [4]u8 @@ -100,10 +100,10 @@ decode_rune :: proc{ decode_rune_in_string, decode_rune_in_bytes, } -decode_rune_in_string :: #force_inline proc(s: string) -> (rune, int) { +decode_rune_in_string :: #force_inline proc "contextless" (s: string) -> (rune, int) { return decode_rune_in_bytes(transmute([]u8)s) } -decode_rune_in_bytes :: proc(s: []u8) -> (rune, int) { +decode_rune_in_bytes :: proc "contextless" (s: []u8) -> (rune, int) { n := len(s) if n < 1 { return RUNE_ERROR, 0 @@ -140,7 +140,7 @@ decode_rune_in_bytes :: proc(s: []u8) -> (rune, int) { return rune(s0&MASK4)<<18 | rune(b1&MASKX)<<12 | rune(b2&MASKX)<<6 | rune(b3&MASKX), 4 } -string_to_runes :: proc(s: string, allocator := context.allocator) -> (runes: []rune) { +string_to_runes :: proc "odin" (s: string, allocator := context.allocator) -> (runes: []rune) { n := rune_count_in_string(s) runes = make([]rune, n, allocator) @@ -152,7 +152,7 @@ string_to_runes :: proc(s: string, allocator := context.allocator) -> (runes: [] return } -runes_to_string :: proc(runes: []rune, allocator := context.allocator) -> string { +runes_to_string :: proc "odin" (runes: []rune, allocator := context.allocator) -> string { byte_count := 0 for r in runes { _, w := encode_rune(r) @@ -176,10 +176,10 @@ decode_last_rune :: proc{ decode_last_rune_in_bytes, } -decode_last_rune_in_string :: #force_inline proc(s: string) -> (rune, int) { +decode_last_rune_in_string :: #force_inline proc "contextless" (s: string) -> (rune, int) { return decode_last_rune_in_bytes(transmute([]u8)s) } -decode_last_rune_in_bytes :: proc(s: []u8) -> (rune, int) { +decode_last_rune_in_bytes :: proc "contextless" (s: []u8) -> (rune, int) { r: rune size: int start, end, limit: int @@ -211,7 +211,7 @@ decode_last_rune_in_bytes :: proc(s: []u8) -> (rune, int) { return r, size } -rune_at_pos :: proc(s: string, pos: int) -> rune { +rune_at_pos :: proc "contextless" (s: string, pos: int) -> rune { if pos < 0 { return RUNE_ERROR } @@ -226,7 +226,7 @@ rune_at_pos :: proc(s: string, pos: int) -> rune { return RUNE_ERROR } -rune_string_at_pos :: proc(s: string, pos: int) -> string { +rune_string_at_pos :: proc "contextless" (s: string, pos: int) -> string { if pos < 0 { return "" } @@ -242,14 +242,14 @@ rune_string_at_pos :: proc(s: string, pos: int) -> string { return "" } -rune_at :: proc(s: string, byte_index: int) -> rune { +rune_at :: proc "contextless" (s: string, byte_index: int) -> rune { r, _ := decode_rune_in_string(s[byte_index:]) return r } // Returns the byte position of rune at position pos in s with an optional start byte position. // Returns -1 if it runs out of the string. -rune_offset :: proc(s: string, pos: int, start: int = 0) -> int { +rune_offset :: proc "contextless" (s: string, pos: int, start: int = 0) -> int { if pos < 0 { return -1 } @@ -264,7 +264,7 @@ rune_offset :: proc(s: string, pos: int, start: int = 0) -> int { return -1 } -valid_rune :: proc(r: rune) -> bool { +valid_rune :: proc "contextless" (r: rune) -> bool { if r < 0 { return false } else if SURROGATE_MIN <= r && r <= SURROGATE_MAX { @@ -275,7 +275,7 @@ valid_rune :: proc(r: rune) -> bool { return true } -valid_string :: proc(s: string) -> bool { +valid_string :: proc "contextless" (s: string) -> bool { n := len(s) for i := 0; i < n; { si := s[i] @@ -308,7 +308,7 @@ valid_string :: proc(s: string) -> bool { return true } -rune_start :: #force_inline proc(b: u8) -> bool { +rune_start :: #force_inline proc "contextless" (b: u8) -> bool { return b&0xc0 != 0x80 } @@ -320,7 +320,7 @@ rune_count :: proc{ rune_count_in_string :: #force_inline proc(s: string) -> int { return rune_count_in_bytes(transmute([]u8)s) } -rune_count_in_bytes :: proc(s: []u8) -> int { +rune_count_in_bytes :: proc "contextless" (s: []u8) -> int { count := 0 n := len(s) @@ -359,7 +359,7 @@ rune_count_in_bytes :: proc(s: []u8) -> int { } -rune_size :: proc(r: rune) -> int { +rune_size :: proc "contextless" (r: rune) -> int { switch { case r < 0: return -1 case r <= 1<<7 - 1: return 1 @@ -380,7 +380,7 @@ full_rune :: proc{ // full_rune_in_bytes reports if the bytes in b begin with a full utf-8 encoding of a rune or not // An invalid encoding is considered a full rune since it will convert as an error rune of width 1 (RUNE_ERROR) -full_rune_in_bytes :: proc(b: []byte) -> bool { +full_rune_in_bytes :: proc "contextless" (b: []byte) -> bool { n := len(b) if n == 0 { return false @@ -400,7 +400,7 @@ full_rune_in_bytes :: proc(b: []byte) -> bool { // full_rune_in_string reports if the bytes in s begin with a full utf-8 encoding of a rune or not // An invalid encoding is considered a full rune since it will convert as an error rune of width 1 (RUNE_ERROR) -full_rune_in_string :: proc(s: string) -> bool { +full_rune_in_string :: proc "contextless" (s: string) -> bool { return full_rune_in_bytes(transmute([]byte)s) } From 03b7194c97ee29e9883c135e75535fad1cda9071 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 25 May 2023 12:05:58 +0100 Subject: [PATCH 073/108] Remove `os` dependency for futex_openbsd.odin --- core/sync/futex_openbsd.odin | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/core/sync/futex_openbsd.odin b/core/sync/futex_openbsd.odin index e02221277..4883a0841 100644 --- a/core/sync/futex_openbsd.odin +++ b/core/sync/futex_openbsd.odin @@ -3,7 +3,6 @@ package sync import "core:c" -import "core:os" import "core:time" FUTEX_WAIT :: 1 @@ -14,11 +13,16 @@ FUTEX_PRIVATE_FLAG :: 128 FUTEX_WAIT_PRIVATE :: (FUTEX_WAIT | FUTEX_PRIVATE_FLAG) FUTEX_WAKE_PRIVATE :: (FUTEX_WAKE | FUTEX_PRIVATE_FLAG) +ETIMEDOUT :: 60 + + foreign import libc "system:c" foreign libc { @(link_name="futex") _unix_futex :: proc "c" (f: ^Futex, op: c.int, val: u32, timeout: rawptr) -> c.int --- + + @(link_name="__errno") __errno :: proc() -> ^int --- } _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { @@ -28,7 +32,7 @@ _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { return true } - if os.Errno(os.get_last_error()) == os.ETIMEDOUT { + if __errno()^ == ETIMEDOUT { return false } @@ -54,7 +58,7 @@ _futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, durati return true } - if os.Errno(os.get_last_error()) == os.ETIMEDOUT { + if __errno()^ == ETIMEDOUT { return false } From 2fda3cf9880cee1c9dfae4ac34b1c10aefbb5a8f Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 25 May 2023 12:17:39 +0100 Subject: [PATCH 074/108] Remove os dependency in primitives_openbsd.odin --- core/sync/primitives_openbsd.odin | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/core/sync/primitives_openbsd.odin b/core/sync/primitives_openbsd.odin index 4072a14e8..ff3ff837f 100644 --- a/core/sync/primitives_openbsd.odin +++ b/core/sync/primitives_openbsd.odin @@ -2,8 +2,14 @@ //+private package sync -import "core:os" +foreign import libc "system:c" + +@(default_calling_convention="c") +foreign libc { + @(link_name="getthrid", private="file") + _unix_getthrid :: proc() -> int --- +} _current_thread_id :: proc "contextless" () -> int { - return os.current_thread_id() + return _unix_getthrid() } From 9371325246e24380a9479a26fa405006fb873d7b Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 25 May 2023 12:19:41 +0100 Subject: [PATCH 075/108] Fix typo --- core/slice/slice.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/slice/slice.odin b/core/slice/slice.odin index a8f70e333..412c90fc8 100644 --- a/core/slice/slice.odin +++ b/core/slice/slice.odin @@ -56,7 +56,7 @@ to_bytes :: proc "contextless" (s: []$T) -> []byte { */ @(require_results) reinterpret :: proc "contextless" ($T: typeid/[]$U, s: []$V) -> []U { - when size_of(U) == 0 || size_of(B) == 0 { + when size_of(U) == 0 || size_of(V) == 0 { return nil } else { bytes := to_bytes(s) From 319a4654290b7f654b493c8adcdb20983e0136cb Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 27 May 2023 15:26:27 +0100 Subject: [PATCH 076/108] Correct `queue` usage of `runtime.Allocator_Error` --- core/container/queue/queue.odin | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/core/container/queue/queue.odin b/core/container/queue/queue.odin index b3a8ad43f..af44ef671 100644 --- a/core/container/queue/queue.odin +++ b/core/container/queue/queue.odin @@ -14,7 +14,7 @@ Queue :: struct($T: typeid) { DEFAULT_CAPACITY :: 16 // Procedure to initialize a queue -init :: proc(q: ^$Q/Queue($T), capacity := DEFAULT_CAPACITY, allocator := context.allocator) -> bool { +init :: proc(q: ^$Q/Queue($T), capacity := DEFAULT_CAPACITY, allocator := context.allocator) -> runtime.Allocator_Error { if q.data.allocator.procedure == nil { q.data.allocator = allocator } @@ -55,11 +55,11 @@ space :: proc(q: $Q/Queue($T)) -> int { } // Reserve enough space for at least the specified capacity -reserve :: proc(q: ^$Q/Queue($T), capacity: int) -> bool { +reserve :: proc(q: ^$Q/Queue($T), capacity: int) -> runtime.Allocator_Error { if uint(capacity) > q.len { return _grow(q, uint(capacity)) } - return true + return nil } @@ -112,25 +112,25 @@ peek_back :: proc(q: ^$Q/Queue($T), loc := #caller_location) -> ^T { } // Push an element to the back of the queue -push_back :: proc(q: ^$Q/Queue($T), elem: T) -> bool { +push_back :: proc(q: ^$Q/Queue($T), elem: T) -> (ok: bool, err: runtime.Allocator_Error) { if space(q^) == 0 { _grow(q) or_return } idx := (q.offset+uint(q.len))%builtin.len(q.data) q.data[idx] = elem q.len += 1 - return true + return true, nil } // Push an element to the front of the queue -push_front :: proc(q: ^$Q/Queue($T), elem: T) -> bool { +push_front :: proc(q: ^$Q/Queue($T), elem: T) -> (ok: bool, err: runtime.Allocator_Error) { if space(q^) == 0 { _grow(q) or_return } q.offset = uint(q.offset - 1 + builtin.len(q.data)) % builtin.len(q.data) q.len += 1 q.data[q.offset] = elem - return true + return true, nil } @@ -173,7 +173,7 @@ pop_front_safe :: proc(q: ^$Q/Queue($T)) -> (elem: T, ok: bool) { } // Push multiple elements to the front of the queue -push_back_elems :: proc(q: ^$Q/Queue($T), elems: ..T) -> bool { +push_back_elems :: proc(q: ^$Q/Queue($T), elems: ..T) -> (ok: bool, err: runtime.Allocator_Error) { n := uint(builtin.len(elems)) if space(q^) < int(n) { _grow(q, q.len + n) or_return @@ -188,7 +188,7 @@ push_back_elems :: proc(q: ^$Q/Queue($T), elems: ..T) -> bool { copy(q.data[insert_from:], elems[:insert_to]) copy(q.data[:insert_from], elems[insert_to:]) q.len += n - return true + return true, nil } // Consume `n` elements from the front of the queue @@ -225,7 +225,7 @@ clear :: proc(q: ^$Q/Queue($T)) { // Internal growinh procedure -_grow :: proc(q: ^$Q/Queue($T), min_capacity: uint = 0) -> bool { +_grow :: proc(q: ^$Q/Queue($T), min_capacity: uint = 0) -> runtime.Allocator_Error { new_capacity := max(min_capacity, uint(8), uint(builtin.len(q.data))*2) n := uint(builtin.len(q.data)) builtin.resize(&q.data, int(new_capacity)) or_return @@ -234,5 +234,5 @@ _grow :: proc(q: ^$Q/Queue($T), min_capacity: uint = 0) -> bool { copy(q.data[new_capacity-diff:], q.data[q.offset:][:diff]) q.offset += new_capacity - n } - return true + return nil } From e350c37e6f9fdbc3b6392dceb9d368facd8dba0f Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sat, 27 May 2023 21:49:39 +0200 Subject: [PATCH 077/108] fix weird errno returned on darwin --- core/os/os_darwin.odin | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin index ef85909c0..8999e867b 100644 --- a/core/os/os_darwin.odin +++ b/core/os/os_darwin.odin @@ -413,7 +413,7 @@ F_OK :: 0 // Test for file existance F_GETPATH :: 50 // return the full path of the fd foreign libc { - @(link_name="__error") __error :: proc() -> ^int --- + @(link_name="__error") __error :: proc() -> ^c.int --- @(link_name="open") _unix_open :: proc(path: cstring, flags: i32, mode: u16) -> Handle --- @(link_name="close") _unix_close :: proc(handle: Handle) -> c.int --- @@ -489,7 +489,7 @@ foreign dl { } get_last_error :: proc "contextless" () -> int { - return __error()^ + return int(__error()^) } get_last_error_string :: proc() -> string { From 2b31d85cd4539a805499242217974db8c68eab22 Mon Sep 17 00:00:00 2001 From: Laytan Laats Date: Sat, 27 May 2023 22:40:05 +0200 Subject: [PATCH 078/108] implement non blocking sockets for darwin --- core/net/socket_darwin.odin | 21 +++++++++++++++++++-- core/os/os_darwin.odin | 21 ++++++++++++++++++++- 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/core/net/socket_darwin.odin b/core/net/socket_darwin.odin index 0d8503cfd..f00be9915 100644 --- a/core/net/socket_darwin.odin +++ b/core/net/socket_darwin.odin @@ -303,8 +303,25 @@ _set_option :: proc(s: Any_Socket, option: Socket_Option, value: any, loc := #ca @(private) _set_blocking :: proc(socket: Any_Socket, should_block: bool) -> (err: Network_Error) { - // TODO: Implement - unimplemented() + socket := any_socket_to_socket(socket) + + flags, getfl_err := os.fcntl(int(socket), os.F_GETFL, 0) + if getfl_err != os.ERROR_NONE { + return Set_Blocking_Error(getfl_err) + } + + if should_block { + flags &= ~int(os.O_NONBLOCK) + } else { + flags |= int(os.O_NONBLOCK) + } + + _, setfl_err := os.fcntl(int(socket), os.F_SETFL, flags) + if setfl_err != os.ERROR_NONE { + return Set_Blocking_Error(setfl_err) + } + + return nil } @private diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin index ef85909c0..ed1027f63 100644 --- a/core/os/os_darwin.odin +++ b/core/os/os_darwin.odin @@ -267,6 +267,8 @@ SHUT_RD :: 0 SHUT_WR :: 1 SHUT_RDWR :: 2 +F_GETFL: int : 3 /* Get file flags */ +F_SETFL: int : 4 /* Set file flags */ // "Argv" arguments converted to Odin strings args := _alloc_command_line_arguments() @@ -438,7 +440,7 @@ foreign libc { @(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int --- @(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) --- - @(link_name="__fcntl") _unix__fcntl :: proc(fd: Handle, cmd: c.int, buf: ^byte) -> c.int --- + @(link_name="__fcntl") _unix__fcntl :: proc(fd: Handle, cmd: c.int, #c_vararg args: ..any) -> c.int --- @(link_name="rename") _unix_rename :: proc(old: cstring, new: cstring) -> c.int --- @(link_name="remove") _unix_remove :: proc(path: cstring) -> c.int --- @@ -464,6 +466,7 @@ foreign libc { @(link_name="connect") _unix_connect :: proc(socket: int, addr: rawptr, addr_len: socklen_t) -> int --- @(link_name="bind") _unix_bind :: proc(socket: int, addr: rawptr, addr_len: socklen_t) -> int --- @(link_name="setsockopt") _unix_setsockopt :: proc(socket: int, level: int, opt_name: int, opt_val: rawptr, opt_len: socklen_t) -> int --- + @(link_name="getsockopt") _unix_getsockopt :: proc(socket: int, level: int, opt_name: int, opt_val: rawptr, opt_len: socklen_t) -> int --- @(link_name="recvfrom") _unix_recvfrom :: proc(socket: int, buffer: rawptr, buffer_len: c.size_t, flags: int, addr: rawptr, addr_len: ^socklen_t) -> c.ssize_t --- @(link_name="recv") _unix_recv :: proc(socket: int, buffer: rawptr, buffer_len: c.size_t, flags: int) -> c.ssize_t --- @(link_name="sendto") _unix_sendto :: proc(socket: int, buffer: rawptr, buffer_len: c.size_t, flags: int, addr: rawptr, addr_len: socklen_t) -> c.ssize_t --- @@ -1016,6 +1019,14 @@ setsockopt :: proc(sd: Socket, level: int, optname: int, optval: rawptr, optlen: return ERROR_NONE } +getsockopt :: proc(sd: Socket, level: int, optname: int, optval: rawptr, optlen: socklen_t) -> Errno { + result := _unix_getsockopt(int(sd), level, optname, optval, optlen) + if result < 0 { + return Errno(get_last_error()) + } + return ERROR_NONE +} + recvfrom :: proc(sd: Socket, data: []byte, flags: int, addr: ^SOCKADDR, addr_size: ^socklen_t) -> (u32, Errno) { result := _unix_recvfrom(int(sd), raw_data(data), len(data), flags, addr, addr_size) if result < 0 { @@ -1055,3 +1066,11 @@ shutdown :: proc(sd: Socket, how: int) -> (Errno) { } return ERROR_NONE } + +fcntl :: proc(fd: int, cmd: int, arg: int) -> (int, Errno) { + result := _unix__fcntl(Handle(fd), c.int(cmd), c.int(arg)) + if result < 0 { + return 0, Errno(get_last_error()) + } + return int(result), ERROR_NONE +} From d167d18bb32cb03d82e1ff7265b6bd6248bd53d7 Mon Sep 17 00:00:00 2001 From: Simon Rowe Date: Sun, 28 May 2023 15:08:14 +0100 Subject: [PATCH 079/108] Update build_odin.sh to better support optimisation on Arm CPUs The `build_odin` flags include the option `release-native`. The current `EXTRAFLAGS` set however don't work for Arm CPUs as they dont support `-march=native`. Added code to detect CPU and either set the preferred flag for Arm CPUs (ie `-mcpu=native`) or keep the current default. Information on preferred Arm CPU optimisation flag taken from here: https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/compiler-flags-across-architectures-march-mtune-and-mcpu Changes tested on an Apple Silicon M1 CPU (arm64) using HomeBrew installed llvm as follows: ``` Homebrew clang version 14.0.6 Target: arm64-apple-darwin22.5.0 Thread model: posix InstalledDir: /opt/homebrew/opt/llvm@14/bin ``` --- build_odin.sh | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/build_odin.sh b/build_odin.sh index 93d6a979c..9b90a80e2 100755 --- a/build_odin.sh +++ b/build_odin.sh @@ -135,7 +135,14 @@ build_odin() { EXTRAFLAGS="-O3" ;; release-native) - EXTRAFLAGS="-O3 -march=native" + local ARCH=$(uname -m) + if [ "${ARCH}" == "arm64" ]; then + # Use preferred flag for Arm (ie arm64 / aarch64 / etc) + EXTRAFLAGS="-O3 -mcpu=native" + else + # Use preferred flag for x86 / amd64 + EXTRAFLAGS="-O3 -march=native" + fi ;; nightly) EXTRAFLAGS="-DNIGHTLY -O3" From d2f62730bc26fd18355de3c86d2d825a221aa288 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 14:55:27 +0100 Subject: [PATCH 080/108] Fix #2560 --- src/parser.cpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/parser.cpp b/src/parser.cpp index bb492fca9..1b48dce87 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -3744,8 +3744,18 @@ gb_internal bool allow_field_separator(AstFile *f) { if (allow_token(f, Token_Comma)) { return true; } - if (ALLOW_NEWLINE && token.kind == Token_Semicolon) { - if (!token_is_newline(token)) { + if (token.kind == Token_Semicolon) { + bool ok = false; + if (ALLOW_NEWLINE && token_is_newline(token)) { + TokenKind next = peek_token(f).kind; + switch (next) { + case Token_CloseBrace: + case Token_CloseParen: + ok = true; + break; + } + } + if (!ok) { String p = token_to_string(token); syntax_error(token_end_of_line(f, f->prev_token), "Expected a comma, got a %.*s", LIT(p)); } From 8b825b23b149924f1980e13d27f80414dd203e3e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 15:18:38 +0100 Subject: [PATCH 081/108] Add missing comma --- tests/core/crypto/test_core_crypto_modern.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/core/crypto/test_core_crypto_modern.odin b/tests/core/crypto/test_core_crypto_modern.odin index 1d76b715b..8f7abb5e8 100644 --- a/tests/core/crypto/test_core_crypto_modern.odin +++ b/tests/core/crypto/test_core_crypto_modern.odin @@ -272,7 +272,7 @@ test_x25519 :: proc(t: ^testing.T) { // Local copy of this so that the base point doesn't need to be exported. _BASE_POINT: [32]byte = { 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, } test_vectors := [?]TestECDH { From f3a463000d4d777cf255bfebda3f51fba4ce8fcc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 22:50:28 +0100 Subject: [PATCH 082/108] Fix #2561 - ARM64 ABI bug for homogenous structs with more than 4 elements --- src/llvm_abi.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/llvm_abi.cpp b/src/llvm_abi.cpp index dabdd6829..82eeac5fb 100644 --- a/src/llvm_abi.cpp +++ b/src/llvm_abi.cpp @@ -1179,7 +1179,11 @@ namespace lbAbiArm64 { if (is_register(type)) { args[i] = non_struct(c, type); } else if (is_homogenous_aggregate(c, type, &homo_base_type, &homo_member_count)) { - args[i] = lb_arg_type_direct(type, LLVMArrayType(homo_base_type, homo_member_count), nullptr, nullptr); + if (is_homogenous_aggregate_small_enough(homo_base_type, homo_member_count)) { + args[i] = lb_arg_type_direct(type, LLVMArrayType(homo_base_type, homo_member_count), nullptr, nullptr); + } else { + args[i] = lb_arg_type_indirect(type, nullptr);; + } } else { i64 size = lb_sizeof(type); if (size <= 16) { From 1247d36a12b9a0043fda0f73f164bd7fa5dc3897 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 22:57:42 +0100 Subject: [PATCH 083/108] Fix #2562 caused by inlining of procedure call --- src/check_decl.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 84b0d39d8..b651e33e6 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -950,6 +950,7 @@ gb_internal void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { if (ac.require_declaration) { e->flags |= EntityFlag_Require; + pl->inlining = ProcInlining_no_inline; } From 97490c6445cb3ba85f470e64e6ed6d24394c421a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 23:17:06 +0100 Subject: [PATCH 084/108] Basic support for `#reverse for in` on normal arrays --- src/check_stmt.cpp | 21 +++++++++++++ src/llvm_backend_stmt.cpp | 64 ++++++++++++++++++++++++++++----------- src/parser.cpp | 11 +++++++ src/parser.hpp | 1 + 4 files changed, 79 insertions(+), 18 deletions(-) diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 6c69ad59f..c64de40c7 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1461,6 +1461,7 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) bool is_map = false; bool use_by_reference_for_value = false; bool is_soa = false; + bool is_reverse = rs->reverse; Ast *expr = unparen_expr(rs->expr); @@ -1476,6 +1477,10 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) } array_add(&vals, x.type); array_add(&vals, t_int); + + if (is_reverse) { + error(node, "#reverse for is not yet supported with ranges"); + } } else { Operand operand = {Addressing_Invalid}; check_expr_base(ctx, &operand, expr, nullptr); @@ -1488,6 +1493,9 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) gb_string_free(t); goto skip_expr_range_stmt; } else { + if (is_reverse) { + error(node, "#reverse for is not supported for enum types"); + } array_add(&vals, operand.type); array_add(&vals, t_int); add_type_info_type(ctx, operand.type); @@ -1503,6 +1511,9 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) array_add(&vals, t_int); add_package_dependency(ctx, "runtime", "string_decode_rune"); } + if (is_reverse) { + error(node, "#reverse for is not supported for string types"); + } break; case Type_EnumeratedArray: @@ -1534,6 +1545,9 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) is_map = true; array_add(&vals, t->Map.key); array_add(&vals, t->Map.value); + if (is_reverse) { + error(node, "#reverse for is not supported for map types"); + } break; case Type_Tuple: @@ -1570,6 +1584,9 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) break; } + if (is_reverse) { + error(node, "#reverse for is not supported for multiple return valued parameters"); + } } break; @@ -1579,6 +1596,10 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) if (is_ptr) use_by_reference_for_value = true; array_add(&vals, t->Struct.soa_elem); array_add(&vals, t_int); + + if (is_reverse) { + error(node, "#reverse for is not yet supported for #soa types"); + } } break; } diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index 125913ac5..60468c7f0 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -249,7 +249,8 @@ gb_internal void lb_build_when_stmt(lbProcedure *p, AstWhenStmt *ws) { gb_internal void lb_build_range_indexed(lbProcedure *p, lbValue expr, Type *val_type, lbValue count_ptr, - lbValue *val_, lbValue *idx_, lbBlock **loop_, lbBlock **done_) { + lbValue *val_, lbValue *idx_, lbBlock **loop_, lbBlock **done_, + bool is_reverse) { lbModule *m = p->module; lbValue count = {}; @@ -267,23 +268,50 @@ gb_internal void lb_build_range_indexed(lbProcedure *p, lbValue expr, Type *val_ lbBlock *body = nullptr; - lbAddr index = lb_add_local_generated(p, t_int, false); - lb_addr_store(p, index, lb_const_int(m, t_int, cast(u64)-1)); + lbAddr index = {}; + lbValue incr = {}; + lbValue cond = {}; - loop = lb_create_block(p, "for.index.loop"); - lb_emit_jump(p, loop); - lb_start_block(p, loop); + index = lb_add_local_generated(p, t_int, false); - lbValue incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); - lb_addr_store(p, index, incr); + if (!is_reverse) { + lb_addr_store(p, index, lb_const_int(m, t_int, cast(u64)-1)); - body = lb_create_block(p, "for.index.body"); - done = lb_create_block(p, "for.index.done"); - if (count.value == nullptr) { - GB_ASSERT(count_ptr.value != nullptr); - count = lb_emit_load(p, count_ptr); + loop = lb_create_block(p, "for.index.loop"); + lb_emit_jump(p, loop); + lb_start_block(p, loop); + + incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); + lb_addr_store(p, index, incr); + + body = lb_create_block(p, "for.index.body"); + done = lb_create_block(p, "for.index.done"); + if (count.value == nullptr) { + GB_ASSERT(count_ptr.value != nullptr); + count = lb_emit_load(p, count_ptr); + } + cond = lb_emit_comp(p, Token_Lt, incr, count); + } else { + // NOTE(bill): REVERSED LOGIC + if (count.value == nullptr) { + GB_ASSERT(count_ptr.value != nullptr); + count = lb_emit_load(p, count_ptr); + } + count = lb_emit_conv(p, count, t_int); + lb_addr_store(p, index, count); + + loop = lb_create_block(p, "for.index.loop"); + lb_emit_jump(p, loop); + lb_start_block(p, loop); + + incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); + lb_addr_store(p, index, incr); + + body = lb_create_block(p, "for.index.body"); + done = lb_create_block(p, "for.index.done"); + cond = lb_emit_comp(p, Token_GtEq, incr, lb_const_int(m, t_int, 0)); } - lbValue cond = lb_emit_comp(p, Token_Lt, incr, count); + lb_emit_if(p, cond, body, done); lb_start_block(p, body); @@ -820,7 +848,7 @@ gb_internal void lb_build_range_stmt(lbProcedure *p, AstRangeStmt *rs, Scope *sc } lbAddr count_ptr = lb_add_local_generated(p, t_int, false); lb_addr_store(p, count_ptr, lb_const_int(p->module, t_int, et->Array.count)); - lb_build_range_indexed(p, array, val0_type, count_ptr.addr, &val, &key, &loop, &done); + lb_build_range_indexed(p, array, val0_type, count_ptr.addr, &val, &key, &loop, &done, rs->reverse); break; } case Type_EnumeratedArray: { @@ -830,7 +858,7 @@ gb_internal void lb_build_range_stmt(lbProcedure *p, AstRangeStmt *rs, Scope *sc } lbAddr count_ptr = lb_add_local_generated(p, t_int, false); lb_addr_store(p, count_ptr, lb_const_int(p->module, t_int, et->EnumeratedArray.count)); - lb_build_range_indexed(p, array, val0_type, count_ptr.addr, &val, &key, &loop, &done); + lb_build_range_indexed(p, array, val0_type, count_ptr.addr, &val, &key, &loop, &done, rs->reverse); break; } case Type_DynamicArray: { @@ -840,7 +868,7 @@ gb_internal void lb_build_range_stmt(lbProcedure *p, AstRangeStmt *rs, Scope *sc array = lb_emit_load(p, array); } count_ptr = lb_emit_struct_ep(p, array, 1); - lb_build_range_indexed(p, array, val0_type, count_ptr, &val, &key, &loop, &done); + lb_build_range_indexed(p, array, val0_type, count_ptr, &val, &key, &loop, &done, rs->reverse); break; } case Type_Slice: { @@ -853,7 +881,7 @@ gb_internal void lb_build_range_stmt(lbProcedure *p, AstRangeStmt *rs, Scope *sc count_ptr = lb_add_local_generated(p, t_int, false).addr; lb_emit_store(p, count_ptr, lb_slice_len(p, slice)); } - lb_build_range_indexed(p, slice, val0_type, count_ptr, &val, &key, &loop, &done); + lb_build_range_indexed(p, slice, val0_type, count_ptr, &val, &key, &loop, &done, rs->reverse); break; } case Type_Basic: { diff --git a/src/parser.cpp b/src/parser.cpp index 1b48dce87..afdb1078d 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -4759,6 +4759,17 @@ gb_internal Ast *parse_stmt(AstFile *f) { return stmt; } else if (tag == "unroll") { return parse_unrolled_for_loop(f, name); + } else if (tag == "reverse") { + Ast *for_stmt = parse_for_stmt(f); + if (for_stmt->kind == Ast_RangeStmt) { + if (for_stmt->RangeStmt.reverse) { + syntax_error(token, "#reverse already applied to a 'for in' statement"); + } + for_stmt->RangeStmt.reverse = true; + } else { + syntax_error(token, "#reverse can only be applied to a 'for in' statement"); + } + return for_stmt; } else if (tag == "include") { syntax_error(token, "#include is not a valid import declaration kind. Did you mean 'import'?"); s = ast_bad_stmt(f, token, f->curr_token); diff --git a/src/parser.hpp b/src/parser.hpp index d4883f287..6ba4ef6d6 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -529,6 +529,7 @@ AST_KIND(_ComplexStmtBegin, "", bool) \ Token in_token; \ Ast *expr; \ Ast *body; \ + bool reverse; \ }) \ AST_KIND(UnrollRangeStmt, "#unroll range statement", struct { \ Scope *scope; \ From 052051244fa32b417ce0695bf42981018a9a6bd7 Mon Sep 17 00:00:00 2001 From: charles Date: Mon, 29 May 2023 17:34:34 -0400 Subject: [PATCH 085/108] WASM: Use BasicC ABI convention for arguments that have a `proc "c"` annotation --- src/llvm_abi.cpp | 31 ++++++++++++++++++++++--------- 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/src/llvm_abi.cpp b/src/llvm_abi.cpp index dabdd6829..a9cfe5434 100644 --- a/src/llvm_abi.cpp +++ b/src/llvm_abi.cpp @@ -1213,7 +1213,7 @@ namespace lbAbiWasm { The approach taken optimizes for passing things in multiple registers/arguments if possible rather than by pointer. */ - gb_internal Array compute_arg_types(LLVMContextRef c, LLVMTypeRef *arg_types, unsigned arg_count); + gb_internal Array compute_arg_types(LLVMContextRef c, LLVMTypeRef *arg_types, unsigned arg_count, ProcCallingConvention calling_convention); gb_internal LB_ABI_COMPUTE_RETURN_TYPE(compute_return_type); enum {MAX_DIRECT_STRUCT_SIZE = 32}; @@ -1221,7 +1221,7 @@ namespace lbAbiWasm { gb_internal LB_ABI_INFO(abi_info) { lbFunctionType *ft = gb_alloc_item(permanent_allocator(), lbFunctionType); ft->ctx = c; - ft->args = compute_arg_types(c, arg_types, arg_count); + ft->args = compute_arg_types(c, arg_types, arg_count, calling_convention); ft->ret = compute_return_type(ft, c, return_type, return_is_defined, return_is_tuple); ft->calling_convention = calling_convention; return ft; @@ -1258,13 +1258,26 @@ namespace lbAbiWasm { return false; } - gb_internal bool type_can_be_direct(LLVMTypeRef type) { + gb_internal bool type_can_be_direct(LLVMTypeRef type, ProcCallingConvention calling_convention) { LLVMTypeKind kind = LLVMGetTypeKind(type); i64 sz = lb_sizeof(type); if (sz == 0) { return false; } - if (sz <= MAX_DIRECT_STRUCT_SIZE) { + if (calling_convention == ProcCC_CDecl) { + // WASM Basic C ABI: + // https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md#function-signatures + if (kind == LLVMArrayTypeKind) { + return false; + } else if (kind == LLVMStructTypeKind) { + unsigned count = LLVMCountStructElementTypes(type); + if (count == 1) { + return type_can_be_direct(LLVMStructGetTypeAtIndex(type, 0), calling_convention); + } + } else if (is_basic_register_type(type)) { + return true; + } + } else if (sz <= MAX_DIRECT_STRUCT_SIZE) { if (kind == LLVMArrayTypeKind) { if (is_basic_register_type(OdinLLVMGetArrayElementType(type))) { return true; @@ -1284,7 +1297,7 @@ namespace lbAbiWasm { return false; } - gb_internal lbArgType is_struct(LLVMContextRef c, LLVMTypeRef type) { + gb_internal lbArgType is_struct(LLVMContextRef c, LLVMTypeRef type, ProcCallingConvention calling_convention) { LLVMTypeKind kind = LLVMGetTypeKind(type); GB_ASSERT(kind == LLVMArrayTypeKind || kind == LLVMStructTypeKind); @@ -1292,21 +1305,21 @@ namespace lbAbiWasm { if (sz == 0) { return lb_arg_type_ignore(type); } - if (type_can_be_direct(type)) { + if (type_can_be_direct(type, calling_convention)) { return lb_arg_type_direct(type); } return lb_arg_type_indirect(type, nullptr); } - gb_internal Array compute_arg_types(LLVMContextRef c, LLVMTypeRef *arg_types, unsigned arg_count) { + gb_internal Array compute_arg_types(LLVMContextRef c, LLVMTypeRef *arg_types, unsigned arg_count, ProcCallingConvention calling_convention) { auto args = array_make(lb_function_type_args_allocator(), arg_count); for (unsigned i = 0; i < arg_count; i++) { LLVMTypeRef t = arg_types[i]; LLVMTypeKind kind = LLVMGetTypeKind(t); if (kind == LLVMStructTypeKind || kind == LLVMArrayTypeKind) { - args[i] = is_struct(c, t); + args[i] = is_struct(c, t, calling_convention); } else { args[i] = non_struct(c, t, false); } @@ -1318,7 +1331,7 @@ namespace lbAbiWasm { if (!return_is_defined) { return lb_arg_type_direct(LLVMVoidTypeInContext(c)); } else if (lb_is_type_kind(return_type, LLVMStructTypeKind) || lb_is_type_kind(return_type, LLVMArrayTypeKind)) { - if (type_can_be_direct(return_type)) { + if (type_can_be_direct(return_type, ft->calling_convention)) { return lb_arg_type_direct(return_type); } From f07453d0aee436ba8c0f81cedfde5db3a7bbe1b4 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 23:24:03 +0100 Subject: [PATCH 086/108] Support `#reverse` on `#soa` arrays --- src/check_stmt.cpp | 4 ---- src/llvm_backend_stmt.cpp | 41 ++++++++++++++++++++++++++++++--------- 2 files changed, 32 insertions(+), 13 deletions(-) diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index c64de40c7..73aaa1c37 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1596,10 +1596,6 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) if (is_ptr) use_by_reference_for_value = true; array_add(&vals, t->Struct.soa_elem); array_add(&vals, t_int); - - if (is_reverse) { - error(node, "#reverse for is not yet supported for #soa types"); - } } break; } diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index 60468c7f0..da7fdaead 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -730,6 +730,8 @@ gb_internal void lb_build_range_stmt_struct_soa(lbProcedure *p, AstRangeStmt *rs lbBlock *body = nullptr; lbBlock *done = nullptr; + bool is_reverse = rs->reverse; + lb_open_scope(p, scope); @@ -751,19 +753,40 @@ gb_internal void lb_build_range_stmt_struct_soa(lbProcedure *p, AstRangeStmt *rs lbAddr index = lb_add_local_generated(p, t_int, false); - lb_addr_store(p, index, lb_const_int(p->module, t_int, cast(u64)-1)); - loop = lb_create_block(p, "for.soa.loop"); - lb_emit_jump(p, loop); - lb_start_block(p, loop); + lbValue incr = {}; + lbValue cond = {}; - lbValue incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); - lb_addr_store(p, index, incr); + if (!is_reverse) { + lb_addr_store(p, index, lb_const_int(p->module, t_int, cast(u64)-1)); - body = lb_create_block(p, "for.soa.body"); - done = lb_create_block(p, "for.soa.done"); + loop = lb_create_block(p, "for.soa.loop"); + lb_emit_jump(p, loop); + lb_start_block(p, loop); - lbValue cond = lb_emit_comp(p, Token_Lt, incr, count); + incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); + lb_addr_store(p, index, incr); + + body = lb_create_block(p, "for.soa.body"); + done = lb_create_block(p, "for.soa.done"); + + cond = lb_emit_comp(p, Token_Lt, incr, count); + } else { + // NOTE(bill): REVERSED LOGIC + lb_addr_store(p, index, count); + + loop = lb_create_block(p, "for.soa.loop"); + lb_emit_jump(p, loop); + lb_start_block(p, loop); + + incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); + lb_addr_store(p, index, incr); + + body = lb_create_block(p, "for.soa.body"); + done = lb_create_block(p, "for.soa.done"); + + cond = lb_emit_comp(p, Token_GtEq, incr, lb_const_int(p->module, t_int, 0)); + } lb_emit_if(p, cond, body, done); lb_start_block(p, body); From b848ae7abb87e3c6a6cb75669d532683dfac5518 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 23:27:42 +0100 Subject: [PATCH 087/108] Improve error message for `#reverse` on an interval --- src/check_stmt.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 73aaa1c37..bf55be072 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1479,7 +1479,7 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) array_add(&vals, t_int); if (is_reverse) { - error(node, "#reverse for is not yet supported with ranges"); + error(node, "#reverse for is not supported with ranges, prefer an explicit for loop with init, condition, and post arguments"); } } else { Operand operand = {Addressing_Invalid}; @@ -1546,7 +1546,7 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) array_add(&vals, t->Map.key); array_add(&vals, t->Map.value); if (is_reverse) { - error(node, "#reverse for is not supported for map types"); + error(node, "#reverse for is not supported for map types, as maps are unordered"); } break; From c1eb536726cfe53e316ef63a51606b118f54f6b2 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 23:30:48 +0100 Subject: [PATCH 088/108] Change to `"contextless" from `"c"` --- core/sys/wasm/wasi/wasi_api.odin | 44 ++++++++++++++++---------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/core/sys/wasm/wasi/wasi_api.odin b/core/sys/wasm/wasi/wasi_api.odin index d4f0d19cf..e9ceb4667 100644 --- a/core/sys/wasm/wasi/wasi_api.odin +++ b/core/sys/wasm/wasi/wasi_api.odin @@ -968,7 +968,7 @@ prestat_t :: struct { }, } -@(default_calling_convention="c") +@(default_calling_convention="contextless") foreign wasi { /** * Read command-line argument data. @@ -1306,7 +1306,7 @@ foreign wasi { * Returns the number of arguments and the size of the argument string * data, or an error. */ -args_sizes_get :: proc "c" () -> (num_args, size_of_args: size_t, err: errno_t) { +args_sizes_get :: proc "contextless" () -> (num_args, size_of_args: size_t, err: errno_t) { err = wasi_args_sizes_get(&num_args, &size_of_args) return } @@ -1316,7 +1316,7 @@ args_sizes_get :: proc "c" () -> (num_args, size_of_args: size_t, err: errno_t) * Returns the number of environment variable arguments and the size of the * environment variable data. */ -environ_sizes_get :: proc "c" () -> (num_envs, size_of_envs: size_t, err: errno_t) { +environ_sizes_get :: proc "contextless" () -> (num_envs, size_of_envs: size_t, err: errno_t) { err = wasi_environ_sizes_get(&num_envs, &size_of_envs) return } @@ -1328,7 +1328,7 @@ environ_sizes_get :: proc "c" () -> (num_envs, size_of_envs: size_t, err: errno_ * @return * The resolution of the clock, or an error if one happened. */ -clock_res_get :: proc "c" ( +clock_res_get :: proc "contextless" ( /** * The clock for which to return the resolution. */ @@ -1343,7 +1343,7 @@ clock_res_get :: proc "c" ( * @return * The time value of the clock. */ -clock_time_get :: proc "c" ( +clock_time_get :: proc "contextless" ( /** * The clock for which to return the time. */ @@ -1362,7 +1362,7 @@ clock_time_get :: proc "c" ( * @return * The buffer where the file descriptor's attributes are stored. */ -fd_fdstat_get :: proc "c" ( +fd_fdstat_get :: proc "contextless" ( fd: fd_t, ) -> (stat: fdstat_t, err: errno_t) { err = wasi_fd_fdstat_get(fd, &stat) @@ -1373,7 +1373,7 @@ fd_fdstat_get :: proc "c" ( * @return * The buffer where the file's attributes are stored. */ -fd_filestat_get :: proc "c" ( +fd_filestat_get :: proc "contextless" ( fd: fd_t, ) -> (stat: filestat_t, err: errno_t) { err = wasi_fd_filestat_get(fd, &stat) @@ -1389,7 +1389,7 @@ fd_filestat_get :: proc "c" ( * @return * The number of bytes read. */ -fd_pread :: proc "c" ( +fd_pread :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors in which to store data. @@ -1408,7 +1408,7 @@ fd_pread :: proc "c" ( * @return * The buffer where the description is stored. */ -fd_prestat_get :: proc "c" ( +fd_prestat_get :: proc "contextless" ( fd: fd_t, ) -> (desc: prestat_t, err: errno_t) { err = wasi_fd_prestat_get(fd, &desc) @@ -1420,7 +1420,7 @@ fd_prestat_get :: proc "c" ( * @return * The number of bytes written. */ -fd_pwrite :: proc "c" ( +fd_pwrite :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors from which to retrieve data. @@ -1440,7 +1440,7 @@ fd_pwrite :: proc "c" ( * @return * The number of bytes read. */ -fd_read :: proc "c" ( +fd_read :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors to which to store data. @@ -1463,7 +1463,7 @@ fd_read :: proc "c" ( * @return * The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached. */ -fd_readdir :: proc "c" ( +fd_readdir :: proc "contextless" ( fd: fd_t, /** * The buffer where directory entries are stored @@ -1483,7 +1483,7 @@ fd_readdir :: proc "c" ( * @return * The new offset of the file descriptor, relative to the start of the file. */ -fd_seek :: proc "c" ( +fd_seek :: proc "contextless" ( fd: fd_t, /** * The number of bytes to move. @@ -1503,7 +1503,7 @@ fd_seek :: proc "c" ( * @return * The current offset of the file descriptor, relative to the start of the file. */ -fd_tell :: proc "c" ( +fd_tell :: proc "contextless" ( fd: fd_t, ) -> (offset: filesize_t, err: errno_t) { err = wasi_fd_tell(fd, &offset) @@ -1513,7 +1513,7 @@ fd_tell :: proc "c" ( * Write to a file descriptor. * Note: This is similar to `writev` in POSIX. */ -fd_write :: proc "c" ( +fd_write :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors from which to retrieve data. @@ -1529,7 +1529,7 @@ fd_write :: proc "c" ( * @return * The buffer where the file's attributes are stored. */ -path_filestat_get :: proc "c" ( +path_filestat_get :: proc "contextless" ( fd: fd_t, /** * Flags determining the method of how the path is resolved. @@ -1554,7 +1554,7 @@ path_filestat_get :: proc "c" ( * @return * The file descriptor of the file that has been opened. */ -path_open :: proc "c" ( +path_open :: proc "contextless" ( fd: fd_t, /** * Flags determining the method of how the path is resolved. @@ -1591,7 +1591,7 @@ path_open :: proc "c" ( * @return * The number of bytes placed in the buffer. */ -path_readlink :: proc "c" ( +path_readlink :: proc "contextless" ( fd: fd_t, /** * The path of the symbolic link from which to read. @@ -1610,7 +1610,7 @@ path_readlink :: proc "c" ( * @return * The number of events stored. */ -poll_oneoff :: proc "c" ( +poll_oneoff :: proc "contextless" ( /** * The events to which to subscribe. */ @@ -1634,7 +1634,7 @@ poll_oneoff :: proc "c" ( * @return * Number of bytes stored in ri_data and message flags. */ -sock_recv :: proc "c" ( +sock_recv :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors to which to store data. @@ -1655,7 +1655,7 @@ sock_recv :: proc "c" ( * @return * Number of bytes transmitted. */ -sock_send :: proc "c" ( +sock_send :: proc "contextless" ( fd: fd_t, /** * List of scatter/gather vectors to which to retrieve data @@ -1675,7 +1675,7 @@ sock_send :: proc "c" ( -@(default_calling_convention="c") +@(default_calling_convention="contextless") foreign wasi { @(link_name="args_sizes_get") wasi_args_sizes_get :: proc( From e0530df98af6e7f520dbdb7324f69dbb1dfaf763 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 29 May 2023 23:45:21 +0100 Subject: [PATCH 089/108] Support `#reverse` for strings --- src/check_stmt.cpp | 9 ++--- src/llvm_backend_stmt.cpp | 72 +++++++++++++++++++++++++++------------ 2 files changed, 56 insertions(+), 25 deletions(-) diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index bf55be072..bdfa24460 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1509,10 +1509,11 @@ gb_internal void check_range_stmt(CheckerContext *ctx, Ast *node, u32 mod_flags) if (is_type_string(t) && t->Basic.kind != Basic_cstring) { array_add(&vals, t_rune); array_add(&vals, t_int); - add_package_dependency(ctx, "runtime", "string_decode_rune"); - } - if (is_reverse) { - error(node, "#reverse for is not supported for string types"); + if (is_reverse) { + add_package_dependency(ctx, "runtime", "string_decode_last_rune"); + } else { + add_package_dependency(ctx, "runtime", "string_decode_rune"); + } } break; diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index da7fdaead..7f677b238 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -480,7 +480,8 @@ gb_internal void lb_build_range_map(lbProcedure *p, lbValue expr, Type *val_type gb_internal void lb_build_range_string(lbProcedure *p, lbValue expr, Type *val_type, - lbValue *val_, lbValue *idx_, lbBlock **loop_, lbBlock **done_) { + lbValue *val_, lbValue *idx_, lbBlock **loop_, lbBlock **done_, + bool is_reverse) { lbModule *m = p->module; lbValue count = lb_const_int(m, t_int, 0); Type *expr_type = base_type(expr.type); @@ -499,35 +500,64 @@ gb_internal void lb_build_range_string(lbProcedure *p, lbValue expr, Type *val_t lbBlock *done = nullptr; lbBlock *body = nullptr; - - lbAddr offset_ = lb_add_local_generated(p, t_int, false); - lb_addr_store(p, offset_, lb_const_int(m, t_int, 0)); - loop = lb_create_block(p, "for.string.loop"); - lb_emit_jump(p, loop); - lb_start_block(p, loop); - - - body = lb_create_block(p, "for.string.body"); done = lb_create_block(p, "for.string.done"); - lbValue offset = lb_addr_load(p, offset_); - lbValue cond = lb_emit_comp(p, Token_Lt, offset, count); + lbAddr offset_ = lb_add_local_generated(p, t_int, false); + lbValue offset = {}; + lbValue cond = {}; + + if (!is_reverse) { + lb_addr_store(p, offset_, lb_const_int(m, t_int, 0)); + + lb_emit_jump(p, loop); + lb_start_block(p, loop); + + + offset = lb_addr_load(p, offset_); + cond = lb_emit_comp(p, Token_Lt, offset, count); + } else { + // NOTE(bill): REVERSED LOGIC + lb_addr_store(p, offset_, count); + + lb_emit_jump(p, loop); + lb_start_block(p, loop); + + offset = lb_addr_load(p, offset_); + cond = lb_emit_comp(p, Token_Gt, offset, lb_const_int(m, t_int, 0)); + } lb_emit_if(p, cond, body, done); lb_start_block(p, body); - lbValue str_elem = lb_emit_ptr_offset(p, lb_string_elem(p, expr), offset); - lbValue str_len = lb_emit_arith(p, Token_Sub, count, offset, t_int); - auto args = array_make(permanent_allocator(), 1); - args[0] = lb_emit_string(p, str_elem, str_len); - lbValue rune_and_len = lb_emit_runtime_call(p, "string_decode_rune", args); - lbValue len = lb_emit_struct_ev(p, rune_and_len, 1); - lb_addr_store(p, offset_, lb_emit_arith(p, Token_Add, offset, len, t_int)); + lbValue rune_and_len = {}; + if (!is_reverse) { + lbValue str_elem = lb_emit_ptr_offset(p, lb_string_elem(p, expr), offset); + lbValue str_len = lb_emit_arith(p, Token_Sub, count, offset, t_int); + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_emit_string(p, str_elem, str_len); + + rune_and_len = lb_emit_runtime_call(p, "string_decode_rune", args); + lbValue len = lb_emit_struct_ev(p, rune_and_len, 1); + lb_addr_store(p, offset_, lb_emit_arith(p, Token_Add, offset, len, t_int)); + + idx = offset; + } else { + // NOTE(bill): REVERSED LOGIC + lbValue str_elem = lb_string_elem(p, expr); + lbValue str_len = offset; + auto args = array_make(permanent_allocator(), 1); + args[0] = lb_emit_string(p, str_elem, str_len); + + rune_and_len = lb_emit_runtime_call(p, "string_decode_last_rune", args); + lbValue len = lb_emit_struct_ev(p, rune_and_len, 1); + lb_addr_store(p, offset_, lb_emit_arith(p, Token_Sub, offset, len, t_int)); + + idx = lb_addr_load(p, offset_); + } - idx = offset; if (val_type != nullptr) { val = lb_emit_struct_ev(p, rune_and_len, 0); } @@ -919,7 +949,7 @@ gb_internal void lb_build_range_stmt(lbProcedure *p, AstRangeStmt *rs, Scope *sc } Type *t = base_type(string.type); GB_ASSERT(!is_type_cstring(t)); - lb_build_range_string(p, string, val0_type, &val, &key, &loop, &done); + lb_build_range_string(p, string, val0_type, &val, &key, &loop, &done, rs->reverse); break; } case Type_Tuple: From c241edaa30ae536f6172ed3c943e2d2637b32acf Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 00:05:24 +0100 Subject: [PATCH 090/108] Add missing procedure for `#reverse` on strings --- core/runtime/internal.odin | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin index 3c8cade39..16f8ed755 100644 --- a/core/runtime/internal.odin +++ b/core/runtime/internal.odin @@ -500,6 +500,42 @@ string_decode_rune :: #force_inline proc "contextless" (s: string) -> (rune, int return rune(s0&MASK4)<<18 | rune(b1&MASKX)<<12 | rune(b2&MASKX)<<6 | rune(b3&MASKX), 4 } +string_decode_last_rune :: proc "contextless" (s: string) -> (rune, int) { + RUNE_ERROR :: '\ufffd' + RUNE_SELF :: 0x80 + UTF_MAX :: 4 + + r: rune + size: int + start, end, limit: int + + end = len(s) + if end == 0 { + return RUNE_ERROR, 0 + } + start = end-1 + r = rune(s[start]) + if r < RUNE_SELF { + return r, 1 + } + + limit = max(end - UTF_MAX, 0) + + for start-=1; start >= limit; start-=1 { + if (s[start] & 0xc0) != RUNE_SELF { + break + } + } + + start = max(start, 0) + r, size = string_decode_rune(s[start:end]) + if start+size != end { + return RUNE_ERROR, 1 + } + return r, size +} + + abs_f16 :: #force_inline proc "contextless" (x: f16) -> f16 { return -x if x < 0 else x } From 3ab01dbc004e7c4b8eebdb5e1dc726e80bc535cc Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 00:05:52 +0100 Subject: [PATCH 091/108] Fix type `switch` debug information on `-o:none` --- src/llvm_backend.cpp | 4 ++-- src/llvm_backend_opt.cpp | 12 +++++++++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 83708e36d..ab9292fbe 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -1377,7 +1377,7 @@ gb_internal WORKER_TASK_PROC(lb_llvm_emit_worker_proc) { gb_internal void lb_llvm_function_pass_per_function_internal(lbModule *module, lbProcedure *p, lbFunctionPassManagerKind pass_manager_kind = lbFunctionPassManager_default) { LLVMPassManagerRef pass_manager = module->function_pass_managers[pass_manager_kind]; - lb_run_function_pass_manager(pass_manager, p); + lb_run_function_pass_manager(pass_manager, p, pass_manager_kind); } gb_internal WORKER_TASK_PROC(lb_llvm_function_pass_per_module) { @@ -1911,7 +1911,7 @@ gb_internal lbProcedure *lb_create_main_procedure(lbModule *m, lbProcedure *star LLVMVerifyFunction(p->value, LLVMAbortProcessAction); } - lb_run_function_pass_manager(default_function_pass_manager, p); + lb_run_function_pass_manager(default_function_pass_manager, p, lbFunctionPassManager_default); return p; } diff --git a/src/llvm_backend_opt.cpp b/src/llvm_backend_opt.cpp index 61f51b15b..141ee88c7 100644 --- a/src/llvm_backend_opt.cpp +++ b/src/llvm_backend_opt.cpp @@ -370,11 +370,21 @@ gb_internal void lb_run_remove_dead_instruction_pass(lbProcedure *p) { } -gb_internal void lb_run_function_pass_manager(LLVMPassManagerRef fpm, lbProcedure *p) { +gb_internal void lb_run_function_pass_manager(LLVMPassManagerRef fpm, lbProcedure *p, lbFunctionPassManagerKind pass_manager_kind) { if (p == nullptr) { return; } LLVMRunFunctionPassManager(fpm, p->value); + switch (pass_manager_kind) { + case lbFunctionPassManager_none: + return; + case lbFunctionPassManager_default: + case lbFunctionPassManager_default_without_memcpy: + if (build_context.optimization_level < 0) { + return; + } + break; + } // NOTE(bill): LLVMAddDCEPass doesn't seem to be exported in the official DLL's for LLVM // which means we cannot rely upon it // This is also useful for read the .ll for debug purposes because a lot of instructions From 837ba6c33b3d78dce332eeb5d5abe7da5d4f8b3a Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 00:21:40 +0100 Subject: [PATCH 092/108] Minor change to `#reverse for` logic; add comments explaining it --- src/llvm_backend_stmt.cpp | 127 +++++++++++++++++++++++++++++++------- 1 file changed, 103 insertions(+), 24 deletions(-) diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index 7f677b238..b305cc796 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -267,32 +267,61 @@ gb_internal void lb_build_range_indexed(lbProcedure *p, lbValue expr, Type *val_ lbBlock *done = nullptr; lbBlock *body = nullptr; + loop = lb_create_block(p, "for.index.loop"); + body = lb_create_block(p, "for.index.body"); + done = lb_create_block(p, "for.index.done"); - lbAddr index = {}; - lbValue incr = {}; - lbValue cond = {}; - - index = lb_add_local_generated(p, t_int, false); + lbAddr index = lb_add_local_generated(p, t_int, false); if (!is_reverse) { + /* + for x, i in array { + ... + } + + i := -1 + for { + i += 1 + if !(i < len(array)) { + break + } + #no_bounds_check x := array[i] + ... + } + */ + lb_addr_store(p, index, lb_const_int(m, t_int, cast(u64)-1)); - loop = lb_create_block(p, "for.index.loop"); lb_emit_jump(p, loop); lb_start_block(p, loop); - incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); + lbValue incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); lb_addr_store(p, index, incr); - body = lb_create_block(p, "for.index.body"); - done = lb_create_block(p, "for.index.done"); if (count.value == nullptr) { GB_ASSERT(count_ptr.value != nullptr); count = lb_emit_load(p, count_ptr); } - cond = lb_emit_comp(p, Token_Lt, incr, count); + lbValue cond = lb_emit_comp(p, Token_Lt, incr, count); + lb_emit_if(p, cond, body, done); } else { // NOTE(bill): REVERSED LOGIC + /* + #reverse for x, i in array { + ... + } + + i := len(array) + for { + i -= 1 + if i < 0 { + break + } + #no_bounds_check x := array[i] + ... + } + */ + if (count.value == nullptr) { GB_ASSERT(count_ptr.value != nullptr); count = lb_emit_load(p, count_ptr); @@ -300,19 +329,16 @@ gb_internal void lb_build_range_indexed(lbProcedure *p, lbValue expr, Type *val_ count = lb_emit_conv(p, count, t_int); lb_addr_store(p, index, count); - loop = lb_create_block(p, "for.index.loop"); lb_emit_jump(p, loop); lb_start_block(p, loop); - incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); + lbValue incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(m, t_int, 1), t_int); lb_addr_store(p, index, incr); - body = lb_create_block(p, "for.index.body"); - done = lb_create_block(p, "for.index.done"); - cond = lb_emit_comp(p, Token_GtEq, incr, lb_const_int(m, t_int, 0)); + lbValue anti_cond = lb_emit_comp(p, Token_Lt, incr, lb_const_int(m, t_int, 0)); + lb_emit_if(p, anti_cond, done, body); } - lb_emit_if(p, cond, body, done); lb_start_block(p, body); idx = lb_addr_load(p, index); @@ -509,6 +535,18 @@ gb_internal void lb_build_range_string(lbProcedure *p, lbValue expr, Type *val_t lbValue cond = {}; if (!is_reverse) { + /* + for c, offset in str { + ... + } + + offset := 0 + for offset < len(str) { + c, _w := string_decode_rune(str[offset:]) + ... + offset += _w + } + */ lb_addr_store(p, offset_, lb_const_int(m, t_int, 0)); lb_emit_jump(p, loop); @@ -519,6 +557,18 @@ gb_internal void lb_build_range_string(lbProcedure *p, lbValue expr, Type *val_t cond = lb_emit_comp(p, Token_Lt, offset, count); } else { // NOTE(bill): REVERSED LOGIC + /* + #reverse for c, offset in str { + ... + } + + offset := len(str) + for offset > 0 { + c, _w := string_decode_last_rune(str[:offset]) + offset -= _w + ... + } + */ lb_addr_store(p, offset_, count); lb_emit_jump(p, loop); @@ -784,40 +834,69 @@ gb_internal void lb_build_range_stmt_struct_soa(lbProcedure *p, AstRangeStmt *rs lbAddr index = lb_add_local_generated(p, t_int, false); - lbValue incr = {}; - lbValue cond = {}; - if (!is_reverse) { + /* + for x, i in array { + ... + } + + i := -1 + for { + i += 1 + if !(i < len(array)) { + break + } + x := array[i] // but #soa-ified + ... + } + */ + lb_addr_store(p, index, lb_const_int(p->module, t_int, cast(u64)-1)); loop = lb_create_block(p, "for.soa.loop"); lb_emit_jump(p, loop); lb_start_block(p, loop); - incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); + lbValue incr = lb_emit_arith(p, Token_Add, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); lb_addr_store(p, index, incr); body = lb_create_block(p, "for.soa.body"); done = lb_create_block(p, "for.soa.done"); - cond = lb_emit_comp(p, Token_Lt, incr, count); + lbValue cond = lb_emit_comp(p, Token_Lt, incr, count); + lb_emit_if(p, cond, body, done); } else { // NOTE(bill): REVERSED LOGIC + /* + #reverse for x, i in array { + ... + } + + i := len(array) + for { + i -= 1 + if i < 0 { + break + } + #no_bounds_check x := array[i] // but #soa-ified + ... + } + */ lb_addr_store(p, index, count); loop = lb_create_block(p, "for.soa.loop"); lb_emit_jump(p, loop); lb_start_block(p, loop); - incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); + lbValue incr = lb_emit_arith(p, Token_Sub, lb_addr_load(p, index), lb_const_int(p->module, t_int, 1), t_int); lb_addr_store(p, index, incr); body = lb_create_block(p, "for.soa.body"); done = lb_create_block(p, "for.soa.done"); - cond = lb_emit_comp(p, Token_GtEq, incr, lb_const_int(p->module, t_int, 0)); + lbValue cond = lb_emit_comp(p, Token_Lt, incr, lb_const_int(p->module, t_int, 0)); + lb_emit_if(p, cond, done, body); } - lb_emit_if(p, cond, body, done); lb_start_block(p, body); From 9d299143044f88c2c91dbc8c46cea17cf8de98df Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 20:26:22 +0100 Subject: [PATCH 093/108] Don't strip `builtin` attribute form AST --- src/checker.cpp | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/checker.cpp b/src/checker.cpp index c22ad1645..fd5f8e1e8 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3469,6 +3469,8 @@ gb_internal void check_decl_attributes(CheckerContext *c, Array const &at StringSet set = {}; defer (string_set_destroy(&set)); + bool is_runtime = ((c->scope->parent->flags&(ScopeFlag_File|ScopeFlag_Pkg)) != 0 && c->scope->file->pkg->kind == Package_Runtime); + for_array(i, attributes) { Ast *attr = attributes[i]; if (attr->kind != Ast_Attribute) continue; @@ -3504,6 +3506,10 @@ gb_internal void check_decl_attributes(CheckerContext *c, Array const &at continue; } + if (name == "builtin" && is_runtime) { + continue; + } + if (!proc(c, elem, name, value, ac)) { if (!build_context.ignore_unknown_attributes) { error(elem, "Unknown attribute element name '%.*s'", LIT(name)); @@ -3663,9 +3669,9 @@ gb_internal void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array< error(value, "'builtin' cannot have a field value"); } // Remove the builtin tag - attr->Attribute.elems[k] = attr->Attribute.elems[attr->Attribute.elems.count-1]; - attr->Attribute.elems.count -= 1; - k--; + // attr->Attribute.elems[k] = attr->Attribute.elems[attr->Attribute.elems.count-1]; + // attr->Attribute.elems.count -= 1; + // k--; mutex_unlock(&ctx->info->builtin_mutex); } From 2924e478ee0da20a8c07bf4581bf86a2c53b8eb1 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 20:36:43 +0100 Subject: [PATCH 094/108] Improve `check_decl_attributes` logic for `is_runtime` --- src/checker.cpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/checker.cpp b/src/checker.cpp index fd5f8e1e8..fc9a8f776 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3469,7 +3469,18 @@ gb_internal void check_decl_attributes(CheckerContext *c, Array const &at StringSet set = {}; defer (string_set_destroy(&set)); - bool is_runtime = ((c->scope->parent->flags&(ScopeFlag_File|ScopeFlag_Pkg)) != 0 && c->scope->file->pkg->kind == Package_Runtime); + bool is_runtime = false; + if (c->scope && c->scope->file && (c->scope->flags & ScopeFlag_File) && + c->scope->file->pkg && + c->scope->file->pkg->kind == Package_Runtime) { + is_runtime = true; + } else if (c->scope && c->scope->parent && + (c->scope->flags & ScopeFlag_Proc) && + (c->scope->parent->flags & ScopeFlag_File) && + c->scope->parent->file->pkg && + c->scope->parent->file->pkg->kind == Package_Runtime) { + is_runtime = true; + } for_array(i, attributes) { Ast *attr = attributes[i]; From 5376d32772186c5d676eb3718c67ac32fd662f7c Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 23:06:04 +0100 Subject: [PATCH 095/108] Parse leading comment above attribute for value declarations --- src/parser.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/parser.cpp b/src/parser.cpp index afdb1078d..c19e3f859 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -4519,7 +4519,7 @@ gb_internal Ast *parse_foreign_decl(AstFile *f) { return ast_bad_decl(f, token, f->curr_token); } -gb_internal Ast *parse_attribute(AstFile *f, Token token, TokenKind open_kind, TokenKind close_kind) { +gb_internal Ast *parse_attribute(AstFile *f, Token token, TokenKind open_kind, TokenKind close_kind, CommentGroup *docs) { Array elems = {}; Token open = {}; Token close = {}; @@ -4560,6 +4560,9 @@ gb_internal Ast *parse_attribute(AstFile *f, Token token, TokenKind open_kind, T Ast *decl = parse_stmt(f); if (decl->kind == Ast_ValueDecl) { + if (decl->ValueDecl.docs == nullptr && docs != nullptr) { + decl->ValueDecl.docs = docs; + } array_add(&decl->ValueDecl.attributes, attribute); } else if (decl->kind == Ast_ForeignBlockDecl) { array_add(&decl->ForeignBlockDecl.attributes, attribute); @@ -4708,8 +4711,9 @@ gb_internal Ast *parse_stmt(AstFile *f) { } break; case Token_At: { + CommentGroup *docs = f->lead_comment; Token token = expect_token(f, Token_At); - return parse_attribute(f, token, Token_OpenParen, Token_CloseParen); + return parse_attribute(f, token, Token_OpenParen, Token_CloseParen, docs); } case Token_Hash: { From 6fe2df1d7d785a7d56094943851476497f18045d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 30 May 2023 23:42:21 +0100 Subject: [PATCH 096/108] Add more documentation to numerous `@builtin` procedures in package runtime --- core/runtime/core_builtin.odin | 116 +++++++++++++++++++++++++++++++-- 1 file changed, 110 insertions(+), 6 deletions(-) diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin index f578a641e..c5cb8cc07 100644 --- a/core/runtime/core_builtin.odin +++ b/core/runtime/core_builtin.odin @@ -27,6 +27,11 @@ init_global_temporary_allocator :: proc(size: int, backup_allocator := context.a } +// `copy_slice` is a built-in procedure that copies elements from a source slice `src` to a destination slice `dst`. +// The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum +// of len(src) and len(dst). +// +// Prefer the procedure group `copy`. @builtin copy_slice :: proc "contextless" (dst, src: $T/[]$E) -> int { n := max(0, min(len(dst), len(src))) @@ -35,6 +40,11 @@ copy_slice :: proc "contextless" (dst, src: $T/[]$E) -> int { } return n } +// `copy_from_string` is a built-in procedure that copies elements from a source slice `src` to a destination string `dst`. +// The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum +// of len(src) and len(dst). +// +// Prefer the procedure group `copy`. @builtin copy_from_string :: proc "contextless" (dst: $T/[]$E/u8, src: $S/string) -> int { n := max(0, min(len(dst), len(src))) @@ -43,11 +53,20 @@ copy_from_string :: proc "contextless" (dst: $T/[]$E/u8, src: $S/string) -> int } return n } +// `copy` is a built-in procedure that copies elements from a source slice `src` to a destination slice/string `dst`. +// The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum +// of len(src) and len(dst). @builtin copy :: proc{copy_slice, copy_from_string} +// `unordered_remove` removed the element at the specified `index`. It does so by replacing the current end value +// with the old value, and reducing the length of the dynamic array by 1. +// +// Note: This is an O(1) operation. +// Note: If you the elements to remain in their order, use `ordered_remove`. +// Note: If the index is out of bounds, this procedure will panic. @builtin unordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) #no_bounds_check { bounds_check_error_loc(loc, index, len(array)) @@ -57,7 +76,11 @@ unordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_loca } (^Raw_Dynamic_Array)(array).len -= 1 } - +// `ordered_remove` removed the element at the specified `index` whilst keeping the order of the other elements. +// +// Note: This is an O(N) operation. +// Note: If you the elements do not have to remain in their order, prefer `unordered_remove`. +// Note: If the index is out of bounds, this procedure will panic. @builtin ordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) #no_bounds_check { bounds_check_error_loc(loc, index, len(array)) @@ -67,6 +90,10 @@ ordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_locati (^Raw_Dynamic_Array)(array).len -= 1 } +// `remove_range` removes a range of elements specified by the range `lo` and `hi`, whilst keeping the order of the other elements. +// +// Note: This is an O(N) operation. +// Note: If the range is out of bounds, this procedure will panic. @builtin remove_range :: proc(array: ^$D/[dynamic]$T, lo, hi: int, loc := #caller_location) #no_bounds_check { slice_expr_error_lo_hi_loc(loc, lo, hi, len(array)) @@ -80,6 +107,9 @@ remove_range :: proc(array: ^$D/[dynamic]$T, lo, hi: int, loc := #caller_locatio } +// `pop` will remove and return the end value of dynamic array `array` and reduces the length of `array` by 1. +// +// Note: If the dynamic array as no elements (`len(array) == 0`), this procedure will panic. @builtin pop :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check { assert(len(array) > 0, "", loc) @@ -89,6 +119,8 @@ pop :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bou } +// `pop_safe` trys to remove and return the end value of dynamic array `array` and reduces the length of `array` by 1. +// If the operation is not possible, it will return false. @builtin pop_safe :: proc(array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check { if len(array) == 0 { @@ -99,6 +131,9 @@ pop_safe :: proc(array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check return } +// `pop_front` will remove and return the first value of dynamic array `array` and reduces the length of `array` by 1. +// +// Note: If the dynamic array as no elements (`len(array) == 0`), this procedure will panic. @builtin pop_front :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check { assert(len(array) > 0, "", loc) @@ -110,6 +145,8 @@ pop_front :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) # return res } +// `pop_front_safe` trys to return and remove the first value of dynamic array `array` and reduces the length of `array` by 1. +// If the operation is not possible, it will return false. @builtin pop_front_safe :: proc(array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check { if len(array) == 0 { @@ -124,12 +161,15 @@ pop_front_safe :: proc(array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_ } +// `clear` will set the length of a passed dynamic array or map to `0` @builtin clear :: proc{clear_dynamic_array, clear_map} +// `reserve` will try to reserve memory of a passed dynamic array or map to the requested element count (setting the `cap`). @builtin reserve :: proc{reserve_dynamic_array, reserve_map} +// `resize` will try to resize memory of a passed dynamic array or map to the requested element count (setting the `len`, and possibly `cap`). @builtin resize :: proc{resize_dynamic_array} @@ -137,36 +177,56 @@ resize :: proc{resize_dynamic_array} @builtin shrink :: proc{shrink_dynamic_array, shrink_map} +// `free` will try to free the passed pointer, with the given `allocator` if the allocator supports this operation. @builtin free :: proc{mem_free} +// `free_all` will try to free/reset all of the memory of the given `allocator` if the allocator supports this operation. @builtin free_all :: proc{mem_free_all} +// `delete_string` will try to free the underlying data of the passed string, with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer the procedure group `delete`. @builtin delete_string :: proc(str: string, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { return mem_free_with_size(raw_data(str), len(str), allocator, loc) } +// `delete_cstring` will try to free the underlying data of the passed string, with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer the procedure group `delete`. @builtin delete_cstring :: proc(str: cstring, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { return mem_free((^byte)(str), allocator, loc) } +// `delete_dynamic_array` will try to free the underlying data of the passed dynamic array, with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer the procedure group `delete`. @builtin delete_dynamic_array :: proc(array: $T/[dynamic]$E, loc := #caller_location) -> Allocator_Error { return mem_free_with_size(raw_data(array), cap(array)*size_of(E), array.allocator, loc) } +// `delete_slice` will try to free the underlying data of the passed sliced, with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer the procedure group `delete`. @builtin delete_slice :: proc(array: $T/[]$E, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { return mem_free_with_size(raw_data(array), len(array)*size_of(E), allocator, loc) } +// `delete_map` will try to free the underlying data of the passed map, with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer the procedure group `delete`. @builtin delete_map :: proc(m: $T/map[$K]$V, loc := #caller_location) -> Allocator_Error { return map_free_dynamic(transmute(Raw_Map)m, map_info(T), loc) } +// `delete` will try to free the underlying data of the passed built-in data structure (string, cstring, dynamic array, slice, or map), with the given `allocator` if the allocator supports this operation. +// +// Note: Prefer `delete` over the specific `delete_*` procedures where possible. @builtin delete :: proc{ delete_string, @@ -213,18 +273,34 @@ make_aligned :: proc($T: typeid/[]$E, #any_int len: int, alignment: int, allocat return transmute(T)s, err } +// `make_slice` allocates and initializes a slice. Like `new`, the first argument is a type, not a value. +// Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it. +// +// Note: Prefer using the procedure group `make`. @(builtin, require_results) make_slice :: proc($T: typeid/[]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_aligned(T, len, align_of(E), allocator, loc) } +// `make_dynamic_array` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value. +// Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it. +// +// Note: Prefer using the procedure group `make`. @(builtin, require_results) make_dynamic_array :: proc($T: typeid/[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_dynamic_array_len_cap(T, 0, DEFAULT_RESERVE_CAPACITY, allocator, loc) } +// `make_dynamic_array_len` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value. +// Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it. +// +// Note: Prefer using the procedure group `make`. @(builtin, require_results) make_dynamic_array_len :: proc($T: typeid/[dynamic]$E, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_allocator_error { return make_dynamic_array_len_cap(T, len, len, allocator, loc) } +// `make_dynamic_array_len_cap` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value. +// Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it. +// +// Note: Prefer using the procedure group `make`. @(builtin, require_results) make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { make_dynamic_array_error_loc(loc, len, cap) @@ -236,6 +312,10 @@ make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #a array = transmute(T)s return } +// `make_map` allocates and initializes a dynamic array. Like `new`, the first argument is a type, not a value. +// Unlike `new`, `make`'s return value is the same as the type of its argument, not a pointer to it. +// +// Note: Prefer using the procedure group `make`. @(builtin, require_results) make_map :: proc($T: typeid/map[$K]$E, #any_int capacity: int = 1< (m: T, err: Allocator_Error) #optional_allocator_error { make_map_expr_error_loc(loc, capacity) @@ -244,6 +324,12 @@ make_map :: proc($T: typeid/map[$K]$E, #any_int capacity: int = 1< (mp: T, err: Allocator_Error) #optional_allocator_error { make_slice_error_loc(loc, len) @@ -256,8 +342,9 @@ make_multi_pointer :: proc($T: typeid/[^]$E, #any_int len: int, allocator := con } -// The make built-in procedure allocates and initializes a value of type slice, dynamic array, or map (only) -// Similar to new, the first argument is a type, not a value. Unlike new, make's return type is the same as the +// `make` built-in procedure allocates and initializes a value of type slice, dynamic array, map, or multi-pointer (only). +// +// Similar to `new`, the first argument is a type, not a value. Unlike new, make's return type is the same as the // type of its argument, not a pointer to it. // Make uses the specified allocator, default is context.allocator, default is context.allocator @builtin @@ -272,6 +359,9 @@ make :: proc{ +// `clear_map` will set the length of a passed map to `0` +// +// Note: Prefer the procedure group `clear` @builtin clear_map :: proc "contextless" (m: ^$T/map[$K]$V) { if m == nil { @@ -280,14 +370,17 @@ clear_map :: proc "contextless" (m: ^$T/map[$K]$V) { map_clear_dynamic((^Raw_Map)(m), map_info(T)) } +// `reserve_map` will try to reserve memory of a passed map to the requested element count (setting the `cap`). +// +// Note: Prefer the procedure group `reserve` @builtin reserve_map :: proc(m: ^$T/map[$K]$V, capacity: int, loc := #caller_location) -> Allocator_Error { return __dynamic_map_reserve((^Raw_Map)(m), map_info(T), uint(capacity), loc) if m != nil else nil } -/* - Shrinks the capacity of a map down to the current length. -*/ +// Shrinks the capacity of a map down to the current length. +// +// Note: Prefer the procedure group `shrink` @builtin shrink_map :: proc(m: ^$T/map[$K]$V, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) { if m != nil { @@ -526,6 +619,9 @@ assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string +// `clear_dynamic_array` will set the length of a passed dynamic array to `0` +// +// Note: Prefer the procedure group `clear`. @builtin clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) { if array != nil { @@ -533,6 +629,9 @@ clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) { } } +// `reserve_dynamic_array` will try to reserve memory of a passed dynamic array or map to the requested element count (setting the `cap`). +// +// Note: Prefer the procedure group `reserve`. @builtin reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error { if array == nil { @@ -563,6 +662,9 @@ reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, capacity: int, loc := #cal return nil } +// `resize_dynamic_array` will try to resize memory of a passed dynamic array or map to the requested element count (setting the `len`, and possibly `cap`). +// +// Note: Prefer the procedure group `resize` @builtin resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error { if array == nil { @@ -603,6 +705,8 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, length: int, loc := #caller Returns false if `cap(array) < new_cap`, or the allocator report failure. If `len(array) < new_cap`, then `len(array)` will be left unchanged. + + Note: Prefer the procedure group `shrink` */ shrink_dynamic_array :: proc(array: ^$T/[dynamic]$E, new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) { if array == nil { From ebe563630784a235ae9caf765c6a55e4e2db324f Mon Sep 17 00:00:00 2001 From: Lucas Perlind Date: Wed, 31 May 2023 09:32:10 +1000 Subject: [PATCH 097/108] Document core:math/rand and add 'possible output' Possible output allows us to just type check a test and have some sort of output field in the docs but not actually verify it matches stdout --- core/math/rand/rand.odin | 660 +++++++++++++++++- tests/documentation/documentation_tester.odin | 50 +- 2 files changed, 668 insertions(+), 42 deletions(-) diff --git a/core/math/rand/rand.odin b/core/math/rand/rand.odin index 825aa7b87..2fec1efc5 100644 --- a/core/math/rand/rand.odin +++ b/core/math/rand/rand.odin @@ -1,6 +1,10 @@ +/* +Package core:math/rand implements various random number generators +*/ package rand import "core:intrinsics" +import "core:mem" Rand :: struct { state: u64, @@ -12,17 +16,82 @@ Rand :: struct { @(private) global_rand := create(u64(intrinsics.read_cycle_counter())) +/* +Sets the seed used by the global random number generator. + +Inputs: +- seed: The seed value + +Example: + import "core:math/rand" + import "core:fmt" + + set_global_seed_example :: proc() { + rand.set_global_seed(1) + fmt.println(rand.uint64()) + } + +Possible Output: + + 10 + +*/ set_global_seed :: proc(seed: u64) { init(&global_rand, seed) } +/* +Creates a new random number generator. + +Inputs: +- seed: The seed value to create the random number generator with + +Returns: +- res: The created random number generator + +Example: + import "core:math/rand" + import "core:fmt" + + create_example :: proc() { + my_rand := rand.create(1) + fmt.println(rand.uint64(&my_rand)) + } + +Possible Output: + + 10 + +*/ @(require_results) -create :: proc(seed: u64) -> Rand { +create :: proc(seed: u64) -> (res: Rand) { r: Rand init(&r, seed) return r } +/* +Initialises a random number generator. + +Inputs: +- r: The random number generator to initialise +- seed: The seed value to initialise this random number generator + +Example: + import "core:math/rand" + import "core:fmt" + + init_example :: proc() { + my_rand: rand.Rand + rand.init(&my_rand, 1) + fmt.println(rand.uint64(&my_rand)) + } + +Possible Output: + + 10 + +*/ init :: proc(r: ^Rand, seed: u64) { r.state = 0 r.inc = (seed << 1) | 1 @@ -31,6 +100,35 @@ init :: proc(r: ^Rand, seed: u64) { _random(r) } +/* +Initialises a random number generator to use the system random number generator. +The system random number generator is platform specific. +On `linux` refer to the `getrandom` syscall. +On `darwin` refer to `getentropy`. +On `windows` refer to `BCryptGenRandom`. + +All other platforms wi + +Inputs: +- r: The random number generator to use the system random number generator + +WARNING: Panics if the system is not either `windows`, `darwin` or `linux` + +Example: + import "core:math/rand" + import "core:fmt" + + init_as_system_example :: proc() { + my_rand: rand.Rand + rand.init_as_system(&my_rand) + fmt.println(rand.uint64(&my_rand)) + } + +Possible Output: + + 10 + +*/ init_as_system :: proc(r: ^Rand) { if !#defined(_system_random) { panic(#procedure + " is not supported on this platform yet") @@ -61,18 +159,99 @@ _random :: proc(r: ^Rand) -> u32 { return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 31)) } -@(require_results) -uint32 :: proc(r: ^Rand = nil) -> u32 { return _random(r) } +/* +Generates a random 32 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random unsigned 32 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + uint32_example :: proc() { + // Using the global random number generator + fmt.println(rand.uint32()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.uint32(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ @(require_results) -uint64 :: proc(r: ^Rand = nil) -> u64 { +uint32 :: proc(r: ^Rand = nil) -> (val: u32) { return _random(r) } + +/* +Generates a random 64 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random unsigned 64 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + uint64_example :: proc() { + // Using the global random number generator + fmt.println(rand.uint64()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.uint64(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ +@(require_results) +uint64 :: proc(r: ^Rand = nil) -> (val: u64) { a := u64(_random(r)) b := u64(_random(r)) return (a<<32) | b } +/* +Generates a random 128 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random unsigned 128 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + uint128_example :: proc() { + // Using the global random number generator + fmt.println(rand.uint128()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.uint128(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ @(require_results) -uint128 :: proc(r: ^Rand = nil) -> u128 { +uint128 :: proc(r: ^Rand = nil) -> (val: u128) { a := u128(_random(r)) b := u128(_random(r)) c := u128(_random(r)) @@ -80,12 +259,126 @@ uint128 :: proc(r: ^Rand = nil) -> u128 { return (a<<96) | (b<<64) | (c<<32) | d } -@(require_results) int31 :: proc(r: ^Rand = nil) -> i32 { return i32(uint32(r) << 1 >> 1) } -@(require_results) int63 :: proc(r: ^Rand = nil) -> i64 { return i64(uint64(r) << 1 >> 1) } -@(require_results) int127 :: proc(r: ^Rand = nil) -> i128 { return i128(uint128(r) << 1 >> 1) } +/* +Generates a random 31 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. +The sign bit will always be set to 0, thus all generated numbers will be positive. +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 31 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + int31_example :: proc() { + // Using the global random number generator + fmt.println(rand.int31()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int31(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ +@(require_results) int31 :: proc(r: ^Rand = nil) -> (val: i32) { return i32(uint32(r) << 1 >> 1) } +/* +Generates a random 63 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. +The sign bit will always be set to 0, thus all generated numbers will be positive. + +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 63 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + int63_example :: proc() { + // Using the global random number generator + fmt.println(rand.int63()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int63(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ +@(require_results) int63 :: proc(r: ^Rand = nil) -> (val: i64) { return i64(uint64(r) << 1 >> 1) } +/* +Generates a random 127 bit value using the provided random number generator. If no generator is provided the global random number generator will be used. +The sign bit will always be set to 0, thus all generated numbers will be positive. + +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 127 bit value + +Example: + import "core:math/rand" + import "core:fmt" + + int127_example :: proc() { + // Using the global random number generator + fmt.println(rand.int127()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int127(&my_rand)) + } + +Possible Output: + + 10 + 389 + +*/ +@(require_results) int127 :: proc(r: ^Rand = nil) -> (val: i128) { return i128(uint128(r) << 1 >> 1) } + +/* +Generates a random 31 bit value in the range `(0, n]` using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- n: The upper bound of the generated number, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 31 bit value in the range `(0, n]` + +WARNING: Panics if n is less than 0 + +Example: + import "core:math/rand" + import "core:fmt" + + int31_max_example :: proc() { + // Using the global random number generator + fmt.println(rand.int31_max(16)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int31_max(1024, &my_rand)) + } + +Possible Output: + + 6 + 500 + +*/ @(require_results) -int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 { +int31_max :: proc(n: i32, r: ^Rand = nil) -> (val: i32) { if n <= 0 { panic("Invalid argument to int31_max") } @@ -99,9 +392,38 @@ int31_max :: proc(n: i32, r: ^Rand = nil) -> i32 { } return v % n } +/* +Generates a random 63 bit value in the range `(0, n]` using the provided random number generator. If no generator is provided the global random number generator will be used. +Inputs: +- n: The upper bound of the generated number, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 63 bit value in the range `(0, n]` + +WARNING: Panics if n is less than 0 + +Example: + import "core:math/rand" + import "core:fmt" + + int63_max_example :: proc() { + // Using the global random number generator + fmt.println(rand.int63_max(16)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int63_max(1024, &my_rand)) + } + +Possible Output: + + 6 + 500 + +*/ @(require_results) -int63_max :: proc(n: i64, r: ^Rand = nil) -> i64 { +int63_max :: proc(n: i64, r: ^Rand = nil) -> (val: i64) { if n <= 0 { panic("Invalid argument to int63_max") } @@ -115,9 +437,38 @@ int63_max :: proc(n: i64, r: ^Rand = nil) -> i64 { } return v % n } +/* +Generates a random 127 bit value in the range `(0, n]` using the provided random number generator. If no generator is provided the global random number generator will be used. +Inputs: +- n: The upper bound of the generated number, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random 127 bit value in the range `(0, n]` + +WARNING: Panics if n is less than 0 + +Example: + import "core:math/rand" + import "core:fmt" + + int127_max_example :: proc() { + // Using the global random number generator + fmt.println(rand.int127_max(16)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int127_max(1024, &my_rand)) + } + +Possible Output: + + 6 + 500 + +*/ @(require_results) -int127_max :: proc(n: i128, r: ^Rand = nil) -> i128 { +int127_max :: proc(n: i128, r: ^Rand = nil) -> (val: i128) { if n <= 0 { panic("Invalid argument to int127_max") } @@ -131,9 +482,38 @@ int127_max :: proc(n: i128, r: ^Rand = nil) -> i128 { } return v % n } +/* +Generates a random integer value in the range `(0, n]` using the provided random number generator. If no generator is provided the global random number generator will be used. +Inputs: +- n: The upper bound of the generated number, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random integer value in the range `(0, n]` + +WARNING: Panics if n is less than 0 + +Example: + import "core:math/rand" + import "core:fmt" + + int_max_example :: proc() { + // Using the global random number generator + fmt.println(rand.int_max(16)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.int_max(1024, &my_rand)) + } + +Possible Output: + + 6 + 500 + +*/ @(require_results) -int_max :: proc(n: int, r: ^Rand = nil) -> int { +int_max :: proc(n: int, r: ^Rand = nil) -> (val: int) { if n <= 0 { panic("Invalid argument to int_max") } @@ -144,14 +524,153 @@ int_max :: proc(n: int, r: ^Rand = nil) -> int { } } -// Uniform random distribution [0, 1) -@(require_results) float64 :: proc(r: ^Rand = nil) -> f64 { return f64(int63_max(1<<53, r)) / (1 << 53) } -// Uniform random distribution [0, 1) -@(require_results) float32 :: proc(r: ^Rand = nil) -> f32 { return f32(float64(r)) } +/* +Generates a random double floating point value in the range `(0, 1]` using the provided random number generator. If no generator is provided the global random number generator will be used. -@(require_results) float64_range :: proc(lo, hi: f64, r: ^Rand = nil) -> f64 { return (hi-lo)*float64(r) + lo } -@(require_results) float32_range :: proc(lo, hi: f32, r: ^Rand = nil) -> f32 { return (hi-lo)*float32(r) + lo } +Inputs: +- r: The random number generator to use, or nil for the global generator +Returns: +- val: A random double floating point value in the range `(0, 1]` + +Example: + import "core:math/rand" + import "core:fmt" + + float64_example :: proc() { + // Using the global random number generator + fmt.println(rand.float64()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.float64(&my_rand)) + } + +Possible Output: + + 0.043 + 0.511 + +*/ +@(require_results) float64 :: proc(r: ^Rand = nil) -> (val: f64) { return f64(int63_max(1<<53, r)) / (1 << 53) } + +/* +Generates a random single floating point value in the range `(0, 1]` using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random single floating point value in the range `(0, 1]` + +Example: + import "core:math/rand" + import "core:fmt" + + float32_example :: proc() { + // Using the global random number generator + fmt.println(rand.float32()) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.float32(&my_rand)) + } + +Possible Output: + + 0.043 + 0.511 + +*/ +@(require_results) float32 :: proc(r: ^Rand = nil) -> (val: f32) { return f32(float64(r)) } + +/* +Generates a random double floating point value in the range `(low, high]` using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- low: The lower bounds of the value, this value is inclusive +- high: The upper bounds of the value, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random double floating point value in the range `(low, high]` + +Example: + import "core:math/rand" + import "core:fmt" + + float64_range_example :: proc() { + // Using the global random number generator + fmt.println(rand.float64_range(-10, 300)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.float64_range(600, 900, &my_rand)) + } + +Possible Output: + + 15.312 + 673.130 + +*/ +@(require_results) float64_range :: proc(low, high: f64, r: ^Rand = nil) -> (val: f64) { return (high-low)*float64(r) + low } +/* +Generates a random single floating point value in the range `(low, high]` using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- low: The lower bounds of the value, this value is inclusive +- high: The upper bounds of the value, this value is exclusive +- r: The random number generator to use, or nil for the global generator + +Returns: +- val: A random single floating point value in the range `(low, high]` + +Example: + import "core:math/rand" + import "core:fmt" + + float32_range_example :: proc() { + // Using the global random number generator + fmt.println(rand.float32_range(-10, 300)) + // Using local random number generator + my_rand := rand.create(1) + fmt.println(rand.float32_range(600, 900, &my_rand)) + } + +Possible Output: + + 15.312 + 673.130 + +*/ +@(require_results) float32_range :: proc(low, high: f32, r: ^Rand = nil) -> (val: f32) { return (high-low)*float32(r) + low } + +/* +Fills a byte slice with random values using the provided random number generator. If no generator is provided the global random number generator will be used. + +Inputs: +- p: The byte slice to fill +- r: The random number generator to use, or nil for the global generator + +Returns: +- n: The number of bytes generated + +Example: + import "core:math/rand" + import "core:fmt" + + read_example :: proc() { + // Using the global random number generator + data: [8]byte + n := rand.read(data[:]) + fmt.println(n) + fmt.println(data) + } + +Possible Output: + + 8 + [32, 4, 59, 7, 1, 2, 2, 119] + +*/ @(require_results) read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) { pos := i8(0) @@ -168,19 +687,81 @@ read :: proc(p: []byte, r: ^Rand = nil) -> (n: int) { return } -// perm returns a slice of n ints in a pseudo-random permutation of integers in the range [0, n) +/* +Creates a slice of `int` filled with random values using the provided random number generator. If no generator is provided the global random number generator will be used. + +*Allocates Using Provided Allocator* + +Inputs: +- n: The size of the created slice +- r: The random number generator to use, or nil for the global generator +- allocator: (default: context.allocator) + +Returns: +- res: A slice filled with random values +- err: An allocator error if one occured, `nil` otherwise + +Example: + import "core:math/rand" + import "core:mem" + import "core:fmt" + + perm_example :: proc() -> (err: mem.Allocator_Error) { + // Using the global random number generator and using the context allocator + data := rand.perm(4) or_return + fmt.println(data) + defer delete(data, context.allocator) + + // Using local random number generator and temp allocator + my_rand := rand.create(1) + data_tmp := rand.perm(4, &my_rand, context.temp_allocator) or_return + fmt.println(data_tmp) + + return + } + +Possible Output: + + [7201011, 3, 9123, 231131] + [19578, 910081, 131, 7] + +*/ @(require_results) -perm :: proc(n: int, r: ^Rand = nil, allocator := context.allocator) -> []int { - m := make([]int, n, allocator) +perm :: proc(n: int, r: ^Rand = nil, allocator := context.allocator) -> (res: []int, err: mem.Allocator_Error) #optional_allocator_error { + m := make([]int, n, allocator) or_return for i := 0; i < n; i += 1 { j := int_max(i+1, r) m[i] = m[j] m[j] = i } - return m + return m, {} } +/* +Randomizes the ordering of elements for the provided slice. If no generator is provided the global random number generator will be used. +Inputs: +- array: The slice to randomize +- r: The random number generator to use, or nil for the global generator + +Example: + import "core:math/rand" + import "core:fmt" + + shuffle_example :: proc() { + // Using the global random number generator + data: [4]int = { 1, 2, 3, 4 } + fmt.println(data) // the contents are in order + rand.shuffle(data[:]) + fmt.println(data) // the contents have been shuffled + } + +Possible Output: + + [1, 2, 3, 4] + [2, 4, 3, 1] + +*/ shuffle :: proc(array: $T/[]$E, r: ^Rand = nil) { n := i64(len(array)) if n < 2 { @@ -193,7 +774,38 @@ shuffle :: proc(array: $T/[]$E, r: ^Rand = nil) { } } -// Returns a random element from the given slice +/* +Returns a random element from the provided slice. If no generator is provided the global random number generator will be used. + +Inputs: +- array: The slice to choose an element from +- r: The random number generator to use, or nil for the global generator + +Returns: +- res: A random element from `array` + +Example: + import "core:math/rand" + import "core:fmt" + + choice_example :: proc() { + // Using the global random number generator + data: [4]int = { 1, 2, 3, 4 } + fmt.println(rand.choice(data[:])) + fmt.println(rand.choice(data[:])) + fmt.println(rand.choice(data[:])) + fmt.println(rand.choice(data[:])) + } + + +Possible Output: + + 3 + 2 + 2 + 4 + +*/ @(require_results) choice :: proc(array: $T/[]$E, r: ^Rand = nil) -> (res: E) { n := i64(len(array)) @@ -201,4 +813,4 @@ choice :: proc(array: $T/[]$E, r: ^Rand = nil) -> (res: E) { return E{} } return array[int63_max(n, r)] -} \ No newline at end of file +} diff --git a/tests/documentation/documentation_tester.odin b/tests/documentation/documentation_tester.odin index efba63f88..086060000 100644 --- a/tests/documentation/documentation_tester.odin +++ b/tests/documentation/documentation_tester.odin @@ -14,6 +14,7 @@ Example_Test :: struct { package_name: string, example_code: []string, expected_output: []string, + skip_output_check: bool, } g_header: ^doc.Header @@ -145,6 +146,7 @@ find_and_add_examples :: proc(docs: string, package_name: string, entity_name: s curr_block_kind := Block_Kind.Other start := 0 + found_possible_output: bool example_block: Block // when set the kind should be Example output_block: Block // when set the kind should be Output // rely on zii that the kinds have not been set @@ -178,10 +180,16 @@ find_and_add_examples :: proc(docs: string, package_name: string, entity_name: s switch { case strings.has_prefix(line, "Example:"): next_block_kind = .Example case strings.has_prefix(line, "Output:"): next_block_kind = .Output + case strings.has_prefix(line, "Possible Output:"): + next_block_kind = .Output + found_possible_output = true } case .Example: switch { case strings.has_prefix(line, "Output:"): next_block_kind = .Output + case strings.has_prefix(line, "Possible Output:"): + next_block_kind = .Output + found_possible_output = true case ! (text == "" || strings.has_prefix(line, "\t")): next_block_kind = .Other } case .Output: @@ -219,8 +227,9 @@ find_and_add_examples :: proc(docs: string, package_name: string, entity_name: s { // Output block starts with // `Output:` and a number of white spaces, + // `Possible Output:` and a number of white spaces, lines := &output_block.lines - for len(lines) > 0 && (strings.trim_space(lines[0]) == "" || strings.has_prefix(lines[0], "Output:")) { + for len(lines) > 0 && (strings.trim_space(lines[0]) == "" || strings.has_prefix(lines[0], "Output:") || strings.has_prefix(lines[0], "Possible Output:")) { lines^ = lines[1:] } // Additionally we need to strip all empty lines at the end of output to not include those in the expected output @@ -240,6 +249,7 @@ find_and_add_examples :: proc(docs: string, package_name: string, entity_name: s package_name = package_name, example_code = example_block.lines, expected_output = output_block.lines, + skip_output_check = found_possible_output, }) } } @@ -404,25 +414,29 @@ main :: proc() { continue } - fmt.sbprintf(&test_runner, "\t%v_%v()\n", test.package_name, code_test_name) - fmt.sbprintf(&test_runner, "\t_check(%q, `", code_test_name) - had_line_error: bool - for line in test.expected_output { - // NOTE: this will escape the multiline string. Even with a backslash it still escapes due to the semantics of ` - // I don't think any examples would really need this specific character so let's just make it forbidden and change - // in the future if we really need to - if strings.contains_rune(line, '`') { - fmt.eprintf("The line %q in the output for \"%s.%s\" contains a ` which is not allowed\n", line, test.package_name, test.entity_name) - g_bad_doc = true - had_line_error = true + // NOTE: packages like 'rand' are random by nature, in these cases we cannot verify against the output string + // in these cases we just mark the output as 'Possible Output' and we simply skip checking against the output + if ! test.skip_output_check { + fmt.sbprintf(&test_runner, "\t%v_%v()\n", test.package_name, code_test_name) + fmt.sbprintf(&test_runner, "\t_check(%q, `", code_test_name) + had_line_error: bool + for line in test.expected_output { + // NOTE: this will escape the multiline string. Even with a backslash it still escapes due to the semantics of ` + // I don't think any examples would really need this specific character so let's just make it forbidden and change + // in the future if we really need to + if strings.contains_rune(line, '`') { + fmt.eprintf("The line %q in the output for \"%s.%s\" contains a ` which is not allowed\n", line, test.package_name, test.entity_name) + g_bad_doc = true + had_line_error = true + } + strings.write_string(&test_runner, line) + strings.write_string(&test_runner, "\n") } - strings.write_string(&test_runner, line) - strings.write_string(&test_runner, "\n") + if had_line_error { + continue + } + strings.write_string(&test_runner, "`)\n") } - if had_line_error { - continue - } - strings.write_string(&test_runner, "`)\n") save_path := fmt.tprintf("verify/test_%v_%v.odin", test.package_name, code_test_name) test_file_handle, err := os.open(save_path, os.O_WRONLY | os.O_CREATE); if err != 0 { From b52bf11ea564a7220ad0d7ea6db7e50cc310e01e Mon Sep 17 00:00:00 2001 From: Rehkitzdev Date: Wed, 31 May 2023 21:44:30 +0200 Subject: [PATCH 098/108] fixed webgl BindFramebuffer parameter --- vendor/wasm/WebGL/webgl.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vendor/wasm/WebGL/webgl.odin b/vendor/wasm/WebGL/webgl.odin index 04efc785b..4fa6c4c1d 100644 --- a/vendor/wasm/WebGL/webgl.odin +++ b/vendor/wasm/WebGL/webgl.odin @@ -50,7 +50,7 @@ foreign webgl { AttachShader :: proc(program: Program, shader: Shader) --- BindAttribLocation :: proc(program: Program, index: i32, name: string) --- BindBuffer :: proc(target: Enum, buffer: Buffer) --- - BindFramebuffer :: proc(target: Enum, buffer: Buffer) --- + BindFramebuffer :: proc(target: Enum, framebuffer: Framebuffer) --- BindTexture :: proc(target: Enum, texture: Texture) --- BlendColor :: proc(red, green, blue, alpha: f32) --- BlendEquation :: proc(mode: Enum) --- From c194dfbdf72325ffae41f2ad509f1b7b0140b05b Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 31 May 2023 22:23:47 +0100 Subject: [PATCH 099/108] Remove `thread.init_context = context` --- core/thread/thread_windows.odin | 1 - 1 file changed, 1 deletion(-) diff --git a/core/thread/thread_windows.odin b/core/thread/thread_windows.odin index 68382444c..d8883c02d 100644 --- a/core/thread/thread_windows.odin +++ b/core/thread/thread_windows.odin @@ -62,7 +62,6 @@ _create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^ thread.procedure = procedure thread.win32_thread = win32_thread thread.win32_thread_id = win32_thread_id - thread.init_context = context ok := win32.SetThreadPriority(win32_thread, _thread_priority_map[priority]) assert(ok == true) From a6c93e2c419d0504031aafe35ad957eb5d59f096 Mon Sep 17 00:00:00 2001 From: jakubtomsu <66876057+jakubtomsu@users.noreply.github.com> Date: Thu, 1 Jun 2023 13:42:26 +0200 Subject: [PATCH 100/108] Update SOA dynamic array procs to match non-SOA --- core/runtime/core_builtin_soa.odin | 87 ++++++++++++++---------------- 1 file changed, 41 insertions(+), 46 deletions(-) diff --git a/core/runtime/core_builtin_soa.odin b/core/runtime/core_builtin_soa.odin index 10f9846a2..ee2a5f2d0 100644 --- a/core/runtime/core_builtin_soa.odin +++ b/core/runtime/core_builtin_soa.odin @@ -145,26 +145,25 @@ make_soa_slice :: proc($T: typeid/#soa[]$E, length: int, allocator := context.al } @(builtin, require_results) -make_soa_dynamic_array :: proc($T: typeid/#soa[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (array: T) { +make_soa_dynamic_array :: proc($T: typeid/#soa[dynamic]$E, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { context.allocator = allocator - reserve_soa(&array, DEFAULT_RESERVE_CAPACITY, loc) - return + reserve_soa(&array, DEFAULT_RESERVE_CAPACITY, loc) or_return + return array, nil } @(builtin, require_results) -make_soa_dynamic_array_len :: proc($T: typeid/#soa[dynamic]$E, #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T) { +make_soa_dynamic_array_len :: proc($T: typeid/#soa[dynamic]$E, #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { context.allocator = allocator - resize_soa(&array, length, loc) - return + resize_soa(&array, length, loc) or_return + return array, nil } @(builtin, require_results) -make_soa_dynamic_array_len_cap :: proc($T: typeid/#soa[dynamic]$E, #any_int length, capacity: int, allocator := context.allocator, loc := #caller_location) -> (array: T) { +make_soa_dynamic_array_len_cap :: proc($T: typeid/#soa[dynamic]$E, #any_int length, capacity: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_allocator_error { context.allocator = allocator - if reserve_soa(&array, capacity, loc) { - resize_soa(&array, length, loc) - } - return + reserve_soa(&array, capacity, loc) or_return + resize_soa(&array, length, loc) or_return + return array, nil } @@ -178,27 +177,25 @@ make_soa :: proc{ @builtin -resize_soa :: proc(array: ^$T/#soa[dynamic]$E, length: int, loc := #caller_location) -> bool { +resize_soa :: proc(array: ^$T/#soa[dynamic]$E, length: int, loc := #caller_location) -> Allocator_Error { if array == nil { - return false - } - if !reserve_soa(array, length, loc) { - return false + return nil } + reserve_soa(array, length, loc) or_return footer := raw_soa_footer(array) footer.len = length - return true + return nil } @builtin -reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, loc := #caller_location) -> bool { +reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, loc := #caller_location) -> Allocator_Error { if array == nil { - return false + return nil } old_cap := cap(array) if capacity <= old_cap { - return true + return nil } if array.allocator.procedure == nil { @@ -209,7 +206,7 @@ reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, loc := #caller_lo footer := raw_soa_footer(array) if size_of(E) == 0 { footer.cap = capacity - return true + return nil } ti := type_info_of(typeid_of(T)) @@ -240,13 +237,10 @@ reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, loc := #caller_lo old_data := (^rawptr)(array)^ - new_bytes, err := array.allocator.procedure( + new_bytes := array.allocator.procedure( array.allocator.data, .Alloc, new_size, max_align, nil, old_size, loc, - ) - if new_bytes == nil || err != nil { - return false - } + ) or_return new_data := raw_data(new_bytes) @@ -271,31 +265,28 @@ reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, loc := #caller_lo new_offset += type.size * capacity } - _, err = array.allocator.procedure( + array.allocator.procedure( array.allocator.data, .Free, 0, max_align, old_data, old_size, loc, - ) + ) or_return - return true + return nil } @builtin -append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, arg: E, loc := #caller_location) { +append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { if array == nil { - return + return 0, nil } - arg_len := 1 - - if cap(array) <= len(array)+arg_len { - cap := 2 * cap(array) + max(8, arg_len) - _ = reserve_soa(array, cap, loc) + if cap(array) <= len(array) + 1 { + cap := 2 * cap(array) + 8 + err = reserve_soa(array, cap, loc) // do not 'or_return' here as it could be a partial success } - arg_len = min(cap(array)-len(array), arg_len) footer := raw_soa_footer(array) - if size_of(E) > 0 && arg_len > 0 { + if size_of(E) > 0 && cap(array)-len(array) > 0 { ti := type_info_of(typeid_of(T)) ti = type_info_base(ti) si := &ti.variant.(Type_Info_Struct) @@ -328,12 +319,14 @@ append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, arg: E, loc := #caller_locat soa_offset += type.size * cap(array) item_offset += type.size } + footer.len += 1 + return 1, err } - footer.len += arg_len + return 0, err } @builtin -append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, args: ..E, loc := #caller_location) { +append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, args: ..E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error { if array == nil { return } @@ -345,7 +338,7 @@ append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, args: ..E, loc := #caller_l if cap(array) <= len(array)+arg_len { cap := 2 * cap(array) + max(8, arg_len) - _ = reserve_soa(array, cap, loc) + err = reserve_soa(array, cap, loc) // do not 'or_return' here as it could be a partial success } arg_len = min(cap(array)-len(array), arg_len) @@ -382,8 +375,8 @@ append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, args: ..E, loc := #caller_l item_offset += type.size } } - footer.len += arg_len + return arg_len, err } @@ -395,21 +388,23 @@ append_soa :: proc{ } -delete_soa_slice :: proc(array: $T/#soa[]$E, allocator := context.allocator, loc := #caller_location) { +delete_soa_slice :: proc(array: $T/#soa[]$E, allocator := context.allocator, loc := #caller_location) -> Allocator_Error { when intrinsics.type_struct_field_count(E) != 0 { array := array ptr := (^rawptr)(&array)^ - free(ptr, allocator, loc) + free(ptr, allocator, loc) or_return } + return nil } -delete_soa_dynamic_array :: proc(array: $T/#soa[dynamic]$E, loc := #caller_location) { +delete_soa_dynamic_array :: proc(array: $T/#soa[dynamic]$E, loc := #caller_location) -> Allocator_Error { when intrinsics.type_struct_field_count(E) != 0 { array := array ptr := (^rawptr)(&array)^ footer := raw_soa_footer(&array) - free(ptr, footer.allocator, loc) + free(ptr, footer.allocator, loc) or_return } + return nil } From d8752da7d5f72dc8c01b9bfdae61f95706d1dde3 Mon Sep 17 00:00:00 2001 From: Rehkitzdev Date: Fri, 2 Jun 2023 22:19:32 +0200 Subject: [PATCH 101/108] added webgl bindFramebuffer --- vendor/wasm/js/runtime.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vendor/wasm/js/runtime.js b/vendor/wasm/js/runtime.js index 7f0ede146..bcc7e2051 100644 --- a/vendor/wasm/js/runtime.js +++ b/vendor/wasm/js/runtime.js @@ -313,8 +313,8 @@ class WebGLInterface { this.ctx.bindBuffer(target, bufferObj) } }, - BindFramebuffer: (target, buffer) => { - // TODO: BindFramebuffer + BindFramebuffer: (target, framebuffer) => { + this.ctx.bindFramebuffer(target, framebuffer ? this.framebuffers[framebuffer] : null) }, BindTexture: (target, texture) => { this.ctx.bindTexture(target, texture ? this.textures[texture] : null) From efb7fd919b140f5da44f608c6b74d8b8e072117d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 10:50:20 +0100 Subject: [PATCH 102/108] Minor fix to internal `using` logic with LLVM causing a compiler bug --- src/llvm_backend_const.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/llvm_backend_const.cpp b/src/llvm_backend_const.cpp index ea25a4594..8149b1eda 100644 --- a/src/llvm_backend_const.cpp +++ b/src/llvm_backend_const.cpp @@ -107,7 +107,11 @@ gb_internal LLVMValueRef llvm_const_cast(LLVMValueRef val, LLVMTypeRef dst) { case LLVMPointerTypeKind: return LLVMConstPointerCast(val, dst); case LLVMStructTypeKind: - return LLVMConstBitCast(val, dst); + // GB_PANIC("%s -> %s", LLVMPrintValueToString(val), LLVMPrintTypeToString(dst)); + // NOTE(bill): It's not possible to do a bit cast on a struct, why was this code even here in the first place? + // It seems mostly to exist to get around the "anonymous -> named" struct assignments + // return LLVMConstBitCast(val, dst); + return val; default: GB_PANIC("Unhandled const cast %s to %s", LLVMPrintTypeToString(src), LLVMPrintTypeToString(dst)); } @@ -1036,9 +1040,10 @@ gb_internal lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bo } cv_type = cvt->Struct.fields[index]->type; - if (is_type_struct(cv_type)) { - auto cv_field_remapping = lb_get_struct_remapping(m, cv_type); - idx_list[j-1] = cast(unsigned)cv_field_remapping[index]; + if (is_type_struct(cvt)) { + auto cv_field_remapping = lb_get_struct_remapping(m, cvt); + unsigned remapped_index = cast(unsigned)cv_field_remapping[index]; + idx_list[j-1] = remapped_index; } else { idx_list[j-1] = cast(unsigned)index; } From ecad7309453c8f6471b820a643e7676e1a71800f Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 11:08:09 +0100 Subject: [PATCH 103/108] Fix `map_get` typo --- core/runtime/dynamic_map_internal.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/runtime/dynamic_map_internal.odin b/core/runtime/dynamic_map_internal.odin index fe4690610..78fdb23f8 100644 --- a/core/runtime/dynamic_map_internal.odin +++ b/core/runtime/dynamic_map_internal.odin @@ -771,7 +771,7 @@ map_get :: proc "contextless" (m: $T/map[$K]$V, key: K) -> (stored_key: K, store info := intrinsics.type_map_info(T) key := key - h := info.key_hasher(&key, map_seed(m)) + h := info.key_hasher(&key, map_seed(rm)) pos := map_desired_position(rm, h) distance := uintptr(0) mask := (uintptr(1) << map_log2_cap(rm)) - 1 From 24ed07b6d563373b2185196447f9afe2a9831483 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 11:12:14 +0100 Subject: [PATCH 104/108] Add error requiring an explicit calling convention for foreign procedures --- core/runtime/os_specific_js.odin | 2 +- core/runtime/procs_wasm32.odin | 4 ++-- src/checker.cpp | 8 ++++++++ 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/core/runtime/os_specific_js.odin b/core/runtime/os_specific_js.odin index a9ba871f9..246141d87 100644 --- a/core/runtime/os_specific_js.odin +++ b/core/runtime/os_specific_js.odin @@ -5,7 +5,7 @@ foreign import "odin_env" _os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { foreign odin_env { - write :: proc "c" (fd: u32, p: []byte) --- + write :: proc "contextless" (fd: u32, p: []byte) --- } write(1, data) return len(data), 0 diff --git a/core/runtime/procs_wasm32.odin b/core/runtime/procs_wasm32.odin index 2a4210c1e..3981cead0 100644 --- a/core/runtime/procs_wasm32.odin +++ b/core/runtime/procs_wasm32.odin @@ -8,7 +8,7 @@ ti_int :: struct #raw_union { } @(link_name="__ashlti3", linkage="strong") -__ashlti3 :: proc "c" (a: i128, b_: u32) -> i128 { +__ashlti3 :: proc "contextless" (a: i128, b_: u32) -> i128 { bits_in_dword :: size_of(u32)*8 b := u32(b_) @@ -29,7 +29,7 @@ __ashlti3 :: proc "c" (a: i128, b_: u32) -> i128 { @(link_name="__multi3", linkage="strong") -__multi3 :: proc "c" (a, b: i128) -> i128 { +__multi3 :: proc "contextless" (a, b: i128) -> i128 { x, y, r: ti_int x.all = a diff --git a/src/checker.cpp b/src/checker.cpp index a25d85fb8..49f2c4bb4 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3889,6 +3889,14 @@ gb_internal void check_collect_value_decl(CheckerContext *c, Ast *decl) { GB_ASSERT(pl->type->kind == Ast_ProcType); auto cc = pl->type->ProcType.calling_convention; if (cc == ProcCC_ForeignBlockDefault) { + if (is_arch_wasm()) { + begin_error_block(); + error(init, "For wasm related targets, it is required that you either define the" + " @(default_calling_convention=) on the foreign block or" + " explicitly assign it on the procedure signature"); + error_line("\tSuggestion: when dealing with normal Odin code (e.g. js_wasm32), use \"contextless\"; when dealing with Emscripten like code, use \"c\"\n"); + end_error_block(); + } cc = ProcCC_CDecl; if (c->foreign_context.default_cc > 0) { cc = c->foreign_context.default_cc; From 0defd1d1418588a5a09de80080cf61edad71c42b Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 11:17:34 +0100 Subject: [PATCH 105/108] Correct printing in fmt for `ODIN_ERROR_POS_STYLE` --- core/fmt/fmt.odin | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index b82789813..199f55cff 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -1961,11 +1961,22 @@ fmt_named :: proc(fi: ^Info, v: any, verb: rune, info: runtime.Type_Info_Named) switch a in v { case runtime.Source_Code_Location: io.write_string(fi.writer, a.file_path, &fi.n) - io.write_byte(fi.writer, '(', &fi.n) - io.write_int(fi.writer, int(a.line), 10, &fi.n) - io.write_byte(fi.writer, ':', &fi.n) - io.write_int(fi.writer, int(a.column), 10, &fi.n) - io.write_byte(fi.writer, ')', &fi.n) + + when ODIN_ERROR_POS_STYLE == .Default { + io.write_byte(fi.writer, '(', &fi.n) + io.write_int(fi.writer, int(a.line), 10, &fi.n) + io.write_byte(fi.writer, ':', &fi.n) + io.write_int(fi.writer, int(a.column), 10, &fi.n) + io.write_byte(fi.writer, ')', &fi.n) + } else when ODIN_ERROR_POS_STYLE == .Unix { + io.write_byte(fi.writer, ':', &fi.n) + io.write_int(fi.writer, int(a.line), 10, &fi.n) + io.write_byte(fi.writer, ':', &fi.n) + io.write_int(fi.writer, int(a.column), 10, &fi.n) + io.write_byte(fi.writer, ':', &fi.n) + } else { + #panic("Unhandled ODIN_ERROR_POS_STYLE") + } return case time.Duration: From 1cdb0abf801bb7922868e7bf3bba990d4b8b31c7 Mon Sep 17 00:00:00 2001 From: Axel Pahl Date: Tue, 6 Jun 2023 15:17:18 +0200 Subject: [PATCH 106/108] Update core/mem/doc.odin --- core/mem/doc.odin | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/mem/doc.odin b/core/mem/doc.odin index fe53dee83..295a69e96 100644 --- a/core/mem/doc.odin +++ b/core/mem/doc.odin @@ -18,6 +18,7 @@ _main :: proc() { main :: proc() { track: mem.Tracking_Allocator mem.tracking_allocator_init(&track, context.allocator) + defer mem.tracking_allocator_destroy(&track) context.allocator = mem.tracking_allocator(&track) _main() @@ -31,4 +32,4 @@ main :: proc() { } ``` */ -package mem \ No newline at end of file +package mem From 356f66784f5fee819a29f1bff759fec93c9cdaed Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 22:36:36 +0100 Subject: [PATCH 107/108] Fix `@(default_calling_convention)` check on wasm --- src/checker.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/checker.cpp b/src/checker.cpp index 49f2c4bb4..a9893bca4 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -3889,7 +3889,10 @@ gb_internal void check_collect_value_decl(CheckerContext *c, Ast *decl) { GB_ASSERT(pl->type->kind == Ast_ProcType); auto cc = pl->type->ProcType.calling_convention; if (cc == ProcCC_ForeignBlockDefault) { - if (is_arch_wasm()) { + cc = ProcCC_CDecl; + if (c->foreign_context.default_cc > 0) { + cc = c->foreign_context.default_cc; + } else if (is_arch_wasm()) { begin_error_block(); error(init, "For wasm related targets, it is required that you either define the" " @(default_calling_convention=) on the foreign block or" @@ -3897,10 +3900,6 @@ gb_internal void check_collect_value_decl(CheckerContext *c, Ast *decl) { error_line("\tSuggestion: when dealing with normal Odin code (e.g. js_wasm32), use \"contextless\"; when dealing with Emscripten like code, use \"c\"\n"); end_error_block(); } - cc = ProcCC_CDecl; - if (c->foreign_context.default_cc > 0) { - cc = c->foreign_context.default_cc; - } } e->Procedure.link_prefix = c->foreign_context.link_prefix; From d6f45e4d767564e41d0a81d7976b7398ce34b5ba Mon Sep 17 00:00:00 2001 From: gingerBill Date: Tue, 6 Jun 2023 22:38:43 +0100 Subject: [PATCH 108/108] Fix `fmt` for `js` --- core/fmt/fmt_js.odin | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/fmt/fmt_js.odin b/core/fmt/fmt_js.odin index 7f6008889..5e06041f5 100644 --- a/core/fmt/fmt_js.odin +++ b/core/fmt/fmt_js.odin @@ -7,7 +7,7 @@ foreign import "odin_env" @(private="file") foreign odin_env { - write :: proc "c" (fd: u32, p: []byte) --- + write :: proc "contextless" (fd: u32, p: []byte) --- } @(private="file")